Adding upstream version 2.7.6.upstream/2.7.6upstream

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

13 files changed, 2937 insertions, 0 deletions

diff --git a/tests/contrib/test_base32hex.c b/tests/contrib/test_base32hex.c
new file mode 100644
index 0000000..4c52fad
--- /dev/null
+++ b/tests/contrib/test_base32hex.c
@@ -0,0 +1,267 @@
+/*  Copyright (C) 2017 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <tap/basic.h>
+
+#include "libknot/libknot.h"
+#include "contrib/base32hex.h"
+#include "contrib/openbsd/strlcpy.h"
+
+#define BUF_LEN			256
+#define MAX_BIN_DATA_LEN	((INT32_MAX / 8) * 5)
+
+int main(int argc, char *argv[])
+{
+	plan(67);
+
+	int32_t  ret;
+	uint8_t  in[BUF_LEN], ref[BUF_LEN], out[BUF_LEN], out2[BUF_LEN], *out3;
+	uint32_t in_len, ref_len;
+
+	// 0. test invalid input
+	ret = base32hex_encode(NULL, 0, out, BUF_LEN);
+	is_int(KNOT_EINVAL, ret, "base32hex_encode: NULL input buffer");
+	ret = base32hex_encode(in, BUF_LEN, NULL, 0);
+	is_int(KNOT_EINVAL, ret, "base32hex_encode: NULL output buffer");
+	ret = base32hex_encode(in, MAX_BIN_DATA_LEN + 1, out, BUF_LEN);
+	is_int(KNOT_ERANGE, ret, "base32hex_encode: input buffer too large");
+	ret = base32hex_encode(in, BUF_LEN, out, BUF_LEN);
+	is_int(KNOT_ERANGE, ret, "base32hex_encode: output buffer too small");
+
+	ret = base32hex_encode_alloc(NULL, 0, &out3);
+	is_int(KNOT_EINVAL, ret, "base32hex_encode_alloc: NULL input buffer");
+	ret = base32hex_encode_alloc(in, MAX_BIN_DATA_LEN + 1, &out3);
+	is_int(KNOT_ERANGE, ret, "base32hex_encode_alloc: input buffer too large");
+	ret = base32hex_encode_alloc(in, BUF_LEN, NULL);
+	is_int(KNOT_EINVAL, ret, "base32hex_encode_alloc: NULL output buffer");
+
+	ret = base32hex_decode(NULL, 0, out, BUF_LEN);
+	is_int(KNOT_EINVAL, ret, "base32hex_decode: NULL input buffer");
+	ret = base32hex_decode(in, BUF_LEN, NULL, 0);
+	is_int(KNOT_EINVAL, ret, "base32hex_decode: NULL output buffer");
+	ret = base32hex_decode(in, UINT32_MAX, out, BUF_LEN);
+	is_int(KNOT_ERANGE, ret, "base32hex_decode: input buffer too large");
+	ret = base32hex_decode(in, BUF_LEN, out, 0);
+	is_int(KNOT_ERANGE, ret, "base32hex_decode: output buffer too small");
+
+	ret = base32hex_decode_alloc(NULL, 0, &out3);
+	is_int(KNOT_EINVAL, ret, "base32hex_decode_alloc: NULL input buffer");
+	ret = base32hex_decode_alloc(in, UINT32_MAX, &out3);
+	is_int(KNOT_ERANGE, ret, "base32hex_decode_aloc: input buffer too large");
+	ret = base32hex_decode_alloc(in, BUF_LEN, NULL);
+	is_int(KNOT_EINVAL, ret, "base32hex_decode_alloc: NULL output buffer");
+
+	// 1. test vector -> ENC -> DEC
+	strlcpy((char *)in, "", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base32hex_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "1. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "1. test vector - ENC output content");
+	}
+	ret = base32hex_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "1. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "1. test vector - DEC output content");
+	}
+
+	// 2. test vector -> ENC -> DEC
+	strlcpy((char *)in, "f", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "co======", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base32hex_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "2. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "2. test vector - ENC output content");
+	}
+	ret = base32hex_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "2. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "2. test vector - DEC output content");
+	}
+
+	// 3. test vector -> ENC -> DEC
+	strlcpy((char *)in, "fo", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "cpng====", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base32hex_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "3. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "3. test vector - ENC output content");
+	}
+	ret = base32hex_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "3. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "3. test vector - DEC output content");
+	}
+
+	// 4. test vector -> ENC -> DEC
+	strlcpy((char *)in, "foo", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "cpnmu===", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base32hex_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "4. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "4. test vector - ENC output content");
+	}
+	ret = base32hex_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "4. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "4. test vector - DEC output content");
+	}
+
+	// 5. test vector -> ENC -> DEC
+	strlcpy((char *)in, "foob", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "cpnmuog=", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base32hex_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "5. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "5. test vector - ENC output content");
+	}
+	ret = base32hex_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "5. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "5. test vector - DEC output content");
+	}
+
+	// 6. test vector -> ENC -> DEC
+	strlcpy((char *)in, "fooba", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "cpnmuoj1", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base32hex_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "6. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "6. test vector - ENC output content");
+	}
+	ret = base32hex_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "6. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "6. test vector - DEC output content");
+	}
+
+	// 7. test vector -> ENC -> DEC
+	strlcpy((char *)in, "foobar", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "cpnmuoj1e8======", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base32hex_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "7. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "7. test vector - ENC output content");
+	}
+	ret = base32hex_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "7. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "7. test vector - DEC output content");
+	}
+
+	// Bad paddings
+	ret = base32hex_decode((uint8_t *)"AAAAAA==", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad padding length 2");
+	ret = base32hex_decode((uint8_t *)"AAA=====", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad padding length 5");
+	ret = base32hex_decode((uint8_t *)"A=======", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad padding length 7");
+	ret = base32hex_decode((uint8_t *)"========", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad padding length 8");
+	ret = base32hex_decode((uint8_t *)"AAAAA=A=", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad padding character on position 2");
+	ret = base32hex_decode((uint8_t *)"AA=A====", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad padding character on position 5");
+	ret = base32hex_decode((uint8_t *)"=A======", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad padding character on position 7");
+	ret = base32hex_decode((uint8_t *)"CO======CO======", 16, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Two octects with padding");
+
+	// Bad data length
+	ret = base32hex_decode((uint8_t *)"A", 1, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ESIZE, "Bad data length 1");
+	ret = base32hex_decode((uint8_t *)"AA", 2, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ESIZE, "Bad data length 2");
+	ret = base32hex_decode((uint8_t *)"AAA", 3, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ESIZE, "Bad data length 3");
+	ret = base32hex_decode((uint8_t *)"AAAA", 4, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ESIZE, "Bad data length 4");
+	ret = base32hex_decode((uint8_t *)"AAAAA", 5, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ESIZE, "Bad data length 5");
+	ret = base32hex_decode((uint8_t *)"AAAAAA", 6, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ESIZE, "Bad data length 6");
+	ret = base32hex_decode((uint8_t *)"AAAAAAA", 7, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ESIZE, "Bad data length 7");
+	ret = base32hex_decode((uint8_t *)"AAAAAAAAA", 9, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ESIZE, "Bad data length 9");
+
+	// Bad data character
+	ret = base32hex_decode((uint8_t *)"AAAAAAA$", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad data character dollar");
+	ret = base32hex_decode((uint8_t *)"AAAAAAA ", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad data character space");
+	ret = base32hex_decode((uint8_t *)"AAAAAA$A", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad data character dollar on position 7");
+	ret = base32hex_decode((uint8_t *)"AAAAA$AA", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad data character dollar on position 6");
+	ret = base32hex_decode((uint8_t *)"AAAA$AAA", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad data character dollar on position 5");
+	ret = base32hex_decode((uint8_t *)"AAA$AAAA", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad data character dollar on position 4");
+	ret = base32hex_decode((uint8_t *)"AA$AAAAA", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad data character dollar on position 3");
+	ret = base32hex_decode((uint8_t *)"A$AAAAAA", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad data character dollar on position 2");
+	ret = base32hex_decode((uint8_t *)"$AAAAAAA", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE32HEX_ECHAR, "Bad data character dollar on position 1");
+
+	return 0;
+}
diff --git a/tests/contrib/test_base64.c b/tests/contrib/test_base64.c
new file mode 100644
index 0000000..45e4e55
--- /dev/null
+++ b/tests/contrib/test_base64.c
@@ -0,0 +1,237 @@
+/*  Copyright (C) 2011 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <tap/basic.h>
+
+#include "libknot/libknot.h"
+#include "contrib/base64.h"
+#include "contrib/openbsd/strlcpy.h"
+
+#define BUF_LEN			256
+#define MAX_BIN_DATA_LEN	((INT32_MAX / 4) * 3)
+
+int main(int argc, char *argv[])
+{
+	plan(52);
+
+	int32_t  ret;
+	uint8_t  in[BUF_LEN], ref[BUF_LEN], out[BUF_LEN], out2[BUF_LEN], *out3;
+	uint32_t in_len, ref_len;
+
+	// 0. test invalid input
+	ret = base64_encode(NULL, 0, out, BUF_LEN);
+	is_int(KNOT_EINVAL, ret, "base64_encode: NULL input buffer");
+	ret = base64_encode(in, BUF_LEN, NULL, 0);
+	is_int(KNOT_EINVAL, ret, "base64_encode: NULL output buffer");
+	ret = base64_encode(in, MAX_BIN_DATA_LEN + 1, out, BUF_LEN);
+	is_int(KNOT_ERANGE, ret, "base64_encode: input buffer too large");
+	ret = base64_encode(in, BUF_LEN, out, BUF_LEN);
+	is_int(KNOT_ERANGE, ret, "base64_encode: output buffer too small");
+
+	ret = base64_encode_alloc(NULL, 0, &out3);
+	is_int(KNOT_EINVAL, ret, "base64_encode_alloc: NULL input buffer");
+	ret = base64_encode_alloc(in, MAX_BIN_DATA_LEN + 1, &out3);
+	is_int(KNOT_ERANGE, ret, "base64_encode_alloc: input buffer too large");
+	ret = base64_encode_alloc(in, BUF_LEN, NULL);
+	is_int(KNOT_EINVAL, ret, "base64_encode_alloc: NULL output buffer");
+
+	ret = base64_decode(NULL, 0, out, BUF_LEN);
+	is_int(KNOT_EINVAL, ret, "base64_decode: NULL input buffer");
+	ret = base64_decode(in, BUF_LEN, NULL, 0);
+	is_int(KNOT_EINVAL, ret, "base64_decode: NULL output buffer");
+	ret = base64_decode(in, UINT32_MAX, out, BUF_LEN);
+	is_int(KNOT_ERANGE, ret, "base64_decode: input buffer too large");
+	ret = base64_decode(in, BUF_LEN, out, 0);
+	is_int(KNOT_ERANGE, ret, "base64_decode: output buffer too small");
+
+	ret = base64_decode_alloc(NULL, 0, &out3);
+	is_int(KNOT_EINVAL, ret, "base64_decode_alloc: NULL input buffer");
+	ret = base64_decode_alloc(in, UINT32_MAX, &out3);
+	is_int(KNOT_ERANGE, ret, "base64_decode_aloc: input buffer too large");
+	ret = base64_decode_alloc(in, BUF_LEN, NULL);
+	is_int(KNOT_EINVAL, ret, "base64_decode_alloc: NULL output buffer");
+
+	// 1. test vector -> ENC -> DEC
+	strlcpy((char *)in, "", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base64_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "1. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "1. test vector - ENC output content");
+	}
+	ret = base64_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "1. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "1. test vector - DEC output content");
+	}
+
+	// 2. test vector -> ENC -> DEC
+	strlcpy((char *)in, "f", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "Zg==", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base64_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "2. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "2. test vector - ENC output content");
+	}
+	ret = base64_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "2. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "2. test vector - DEC output content");
+	}
+
+	// 3. test vector -> ENC -> DEC
+	strlcpy((char *)in, "fo", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "Zm8=", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base64_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "3. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "3. test vector - ENC output content");
+	}
+	ret = base64_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "3. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "3. test vector - DEC output content");
+	}
+
+	// 4. test vector -> ENC -> DEC
+	strlcpy((char *)in, "foo", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "Zm9v", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base64_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "4. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "4. test vector - ENC output content");
+	}
+	ret = base64_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "4. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "4. test vector - DEC output content");
+	}
+
+	// 5. test vector -> ENC -> DEC
+	strlcpy((char *)in, "foob", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "Zm9vYg==", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base64_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "5. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "5. test vector - ENC output content");
+	}
+	ret = base64_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "5. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "5. test vector - DEC output content");
+	}
+
+	// 6. test vector -> ENC -> DEC
+	strlcpy((char *)in, "fooba", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "Zm9vYmE=", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base64_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "6. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "6. test vector - ENC output content");
+	}
+	ret = base64_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "6. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "6. test vector - DEC output content");
+	}
+
+	// 7. test vector -> ENC -> DEC
+	strlcpy((char *)in, "foobar", BUF_LEN);
+	in_len = strlen((char *)in);
+	strlcpy((char *)ref, "Zm9vYmFy", BUF_LEN);
+	ref_len = strlen((char *)ref);
+	ret = base64_encode(in, in_len, out, BUF_LEN);
+	ok(ret == ref_len, "7. test vector - ENC output length");
+	if (ret < 0) {
+		skip("Encode err");
+	} else {
+		ok(memcmp(out, ref, ret) == 0, "7. test vector - ENC output content");
+	}
+	ret = base64_decode(out, ret, out2, BUF_LEN);
+	ok(ret == in_len, "7. test vector - DEC output length");
+	if (ret < 0) {
+		skip("Decode err");
+	} else {
+		ok(memcmp(out2, in, ret) == 0, "7. test vector - DEC output content");
+	}
+
+	// Bad paddings
+	ret = base64_decode((uint8_t *)"A===", 4, out, BUF_LEN);
+	ok(ret == KNOT_BASE64_ECHAR, "Bad padding length 3");
+	ret = base64_decode((uint8_t *)"====", 4, out, BUF_LEN);
+	ok(ret == KNOT_BASE64_ECHAR, "Bad padding length 4");
+	ret = base64_decode((uint8_t *)"AA=A", 4, out, BUF_LEN);
+	ok(ret == KNOT_BASE64_ECHAR, "Bad padding character on position 2");
+	ret = base64_decode((uint8_t *)"Zg==Zg==", 8, out, BUF_LEN);
+	ok(ret == KNOT_BASE64_ECHAR, "Two quartets with padding");
+
+	// Bad data length
+	ret = base64_decode((uint8_t *)"A", 1, out, BUF_LEN);
+	ok(ret == KNOT_BASE64_ESIZE, "Bad data length 1");
+	ret = base64_decode((uint8_t *)"AA", 2, out, BUF_LEN);
+	ok(ret == KNOT_BASE64_ESIZE, "Bad data length 2");
+	ret = base64_decode((uint8_t *)"AAA", 3, out, BUF_LEN);
+	ok(ret == KNOT_BASE64_ESIZE, "Bad data length 3");
+	ret = base64_decode((uint8_t *)"AAAAA", 5, out, BUF_LEN);
+	ok(ret == KNOT_BASE64_ESIZE, "Bad data length 5");
+
+	// Bad data character
+	ret = base64_decode((uint8_t *)"AAA$", 4, out, BUF_LEN);
+	ok(ret == KNOT_BASE64_ECHAR, "Bad data character dollar");
+	ret = base64_decode((uint8_t *)"AAA ", 4, out, BUF_LEN);
+	ok(ret == KNOT_BASE64_ECHAR, "Bad data character space");
+
+	return 0;
+}
diff --git a/tests/contrib/test_dynarray.c b/tests/contrib/test_dynarray.c
new file mode 100644
index 0000000..3e4c57f
--- /dev/null
+++ b/tests/contrib/test_dynarray.c
@@ -0,0 +1,81 @@
+/*  Copyright (C) 2017 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+ */
+
+#include <string.h>
+#include <tap/basic.h>
+
+#include "contrib/dynarray.h"
+
+#define test_capacity 5
+// minimum 3
+
+typedef struct {
+	int x;
+	int x2;
+} quadrate_t;
+
+dynarray_declare(q, quadrate_t, DYNARRAY_VISIBILITY_STATIC, test_capacity);
+dynarray_define(q, quadrate_t, DYNARRAY_VISIBILITY_STATIC);
+
+static q_dynarray_t q_fill(size_t howmany)
+{
+	quadrate_t q = { 0 };
+	q_dynarray_t qd = { 0 };
+
+	for (size_t i = 0; i < howmany; i++) {
+		q.x2 = q.x * q.x;
+		q_dynarray_add(&qd, &q);
+		q.x++;
+	}
+	return qd;
+}
+
+static void check_arr(q_dynarray_t *q, size_t count, size_t index, const char *msg)
+{
+	quadrate_t *arr = q->arr(q);
+	ok(arr[index].x == index && arr[index].x2 == index * index,
+	   "%s check: index %zu", msg, index);
+
+	size_t i = 0;
+	dynarray_foreach(q, quadrate_t, p, *q) {
+		ok(p->x == i && p->x2 == i * i, "%s foreach: index %zu", msg, i);
+		i++;
+	}
+
+	ok(i == count, "%s foreach: whole array", msg);
+}
+
+int main(int argc, char *argv[])
+{
+	plan_lazy();
+
+	// first fill
+	q_dynarray_t q = q_fill(test_capacity - 1);
+	check_arr(&q, test_capacity - 1, test_capacity - 3, "initial");
+	q_dynarray_free(&q);
+
+	// second fill
+	q = q_fill(test_capacity + 3);
+	check_arr(&q, test_capacity + 3, test_capacity + 1, "second");
+	q_dynarray_free(&q);
+
+	// third fill
+	q = q_fill(test_capacity * 5);
+	check_arr(&q, test_capacity * 5, test_capacity * 4, "third");
+	q_dynarray_free(&q);
+
+	return 0;
+}
diff --git a/tests/contrib/test_heap.c b/tests/contrib/test_heap.c
new file mode 100644
index 0000000..e49204c
--- /dev/null
+++ b/tests/contrib/test_heap.c
@@ -0,0 +1,166 @@
+/*  Copyright (C) 2016 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+ */
+
+#include <tap/basic.h>
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "contrib/ucw/heap.h"
+
+static void seed_random(void)
+{
+	unsigned short int seed[3] = { 0 };
+
+	FILE *f = fopen("/dev/urandom", "r");
+	if (f) {
+		if (fread(seed, sizeof(seed), 1, f) != 1) {
+			diag("failed to seed random source");
+		}
+		fclose(f);
+	}
+
+	diag("seed %hu %hu %hu", seed[0], seed[1], seed[2]);
+	seed48(seed);
+}
+
+struct value {
+	heap_val_t _heap;
+	int data;
+};
+
+static int value_cmp(void *_a, void *_b)
+{
+	const struct value *a = _a;
+	const struct value *b = _b;
+	return (a->data - b->data);
+}
+
+int main(int argc, char *argv[])
+{
+	plan_lazy();
+
+	seed_random();
+
+	static const int VALUE_COUNT = 1000;
+	static const int VALUE_RANGE = 950;
+	static const int VALUE_REPLACE = 300;
+	static const int VALUE_DELETE = 100;
+
+	struct heap heap;
+	heap_init(&heap, value_cmp, 0);
+
+	ok(EMPTY_HEAP(&heap), "heap is empty");
+
+	// fill the heap with random values (with duplicates)
+
+	struct value *values = calloc(VALUE_COUNT, sizeof(struct value));
+	assert(values);
+	assert(VALUE_RANGE < VALUE_COUNT);
+
+	bool valid = true;
+	for (int i = 0; i < VALUE_COUNT; i++) {
+		values[i].data = lrand48() % VALUE_RANGE;
+		if (heap_insert(&heap, &values[i]._heap) == 0) {
+			valid = false;
+		}
+	}
+	ok(valid, "heap_insert");
+	ok(!EMPTY_HEAP(&heap), "heap is non-empty");
+
+	// exercise heap_insert
+
+	valid = true;
+	for (int i = 0; i < VALUE_COUNT; i++) {
+		int pos = heap_find(&heap, &values[i]._heap);
+		if (*HELEMENT(&heap, pos) != &values[i]._heap) {
+			valid = false;
+		}
+	}
+	ok(valid, "heap_find");
+
+	// exercise heap_replace
+
+	assert(VALUE_REPLACE <= VALUE_COUNT);
+	struct value *replaced = calloc(VALUE_REPLACE, sizeof(struct value));
+	assert(replaced);
+
+	valid = true;
+	for (int i = 0; i < VALUE_REPLACE; i++) {
+		replaced[i].data = lrand48() % VALUE_RANGE;
+		int pos = heap_find(&heap, &values[i]._heap);
+		if (pos < 1) {
+			valid = false;
+			continue;
+		}
+
+		heap_replace(&heap, pos, &replaced[i]._heap);
+		int newpos = heap_find(&heap, &replaced[i]._heap);
+		if (newpos < 1) {
+			valid = false;
+		}
+	}
+	ok(valid, "heap_replace");
+
+	// exercise heap_delete
+
+	assert(VALUE_REPLACE + VALUE_DELETE < VALUE_COUNT);
+
+	valid = true;
+	for (int i = 0; i < VALUE_DELETE; i++) {
+		heap_val_t *value = &values[i + VALUE_REPLACE]._heap;
+		int pos = heap_find(&heap, value);
+		if (pos < 1) {
+			valid = false;
+			continue;
+
+		}
+		heap_delete(&heap, pos);
+		pos = heap_find(&heap, value);
+		if (pos != 0) {
+			valid = false;
+		}
+	}
+	ok(valid, "heap_delete");
+
+	// exercise item retrieval
+
+	assert(VALUE_COUNT > VALUE_DELETE);
+
+	valid = true;
+	int current = -1;
+	for (int i = 0; i < VALUE_COUNT - VALUE_DELETE; i++) {
+		struct value *val = (struct value *)*HHEAD(&heap);
+		heap_delmin(&heap);
+		if (current <= val->data) {
+			current = val->data;
+		} else {
+			valid = false;
+		}
+	}
+
+	ok(valid, "heap ordering");
+	ok(EMPTY_HEAP(&heap), "heap_delmin");
+
+	free(replaced);
+	free(values);
+	heap_deinit(&heap);
+
+	return 0;
+}
diff --git a/tests/contrib/test_net.c b/tests/contrib/test_net.c
new file mode 100644
index 0000000..9583362
--- /dev/null
+++ b/tests/contrib/test_net.c
@@ -0,0 +1,759 @@
+/*  Copyright (C) 2015 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+*/
+
+#include <tap/basic.h>
+
+#include <assert.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "libknot/errcode.h"
+#include "contrib/net.h"
+#include "contrib/sockaddr.h"
+
+#undef ENABLE_NET_UNREACHABLE_TEST
+//#define ENABLE_NET_UNREACHABLE_TEST
+
+const int TIMEOUT = 5000;
+const int TIMEOUT_SHORT = 500;
+
+/*!
+ * \brief Get loopback socket address with unset port.
+ */
+static struct sockaddr_storage addr_local(void)
+{
+	struct sockaddr_storage addr = { 0 };
+	struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&addr;
+
+	addr6->sin6_family = AF_INET6;
+	addr6->sin6_addr = in6addr_loopback;
+
+	return addr;
+}
+
+#ifdef ENABLE_NET_UNREACHABLE_TEST
+/*!
+ * \brief Get unreachable IPv6 address.
+ *
+ * Allocated from 100::/64 (Discard-Only Address Block).
+ */
+static struct sockaddr_storage addr_unreachable(void)
+{
+	struct sockaddr_storage addr = { 0 };
+	sockaddr_set(&addr, AF_INET6, "100::b1ac:h01e", 42);
+
+	return addr;
+}
+#endif
+
+/*!
+ * \brief Get address of a socket.
+ */
+static struct sockaddr_storage addr_from_socket(int sock)
+{
+	struct sockaddr_storage addr = { 0 };
+	socklen_t len = sizeof(addr);
+	getsockname(sock, (struct sockaddr *)&addr, &len);
+
+	return addr;
+}
+
+static const char *socktype_name(int type)
+{
+	switch (type) {
+	case SOCK_STREAM: return "TCP";
+	case SOCK_DGRAM:  return "UDP";
+	default:          return "unknown";
+	}
+}
+
+static bool socktype_is_stream(int type)
+{
+	return type == SOCK_STREAM;
+}
+
+/* -- mock server ---------------------------------------------------------- */
+
+#define LISTEN_BACKLOG 5
+
+struct server_ctx;
+typedef struct server_ctx server_ctx_t;
+
+typedef void (*server_cb)(int sock, void *data);
+
+/*!
+ * \brief Server context.
+ */
+struct server_ctx {
+	int sock;
+	int type;
+	bool terminate;
+	server_cb handler;
+	void *handler_data;
+
+	pthread_t thr;
+	pthread_mutex_t mx;
+};
+
+static int poll_read(int sock)
+{
+	struct pollfd pfd = { .fd = sock, .events = POLLIN };
+	return poll(&pfd, 1, TIMEOUT);
+}
+
+static void server_handle(server_ctx_t *ctx)
+{
+	int remote = ctx->sock;
+
+	assert(ctx->type == SOCK_STREAM || ctx->type == SOCK_DGRAM);
+
+	if (socktype_is_stream(ctx->type)) {
+		remote = accept(ctx->sock, 0, 0);
+		if (remote < 0) {
+			return;
+		}
+	}
+
+	pthread_mutex_lock(&ctx->mx);
+	server_cb handler = ctx->handler;
+	pthread_mutex_unlock(&ctx->mx);
+	handler(remote, ctx->handler_data);
+
+	if (socktype_is_stream(ctx->type)) {
+		close(remote);
+	}
+}
+
+/*!
+ * \brief Simple server.
+ *
+ * Terminated when a one-byte message is delivered.
+ */
+static void *server_main(void *_ctx)
+{
+	server_ctx_t *ctx = _ctx;
+
+	for (;;) {
+		pthread_mutex_lock(&ctx->mx);
+		bool terminate = ctx->terminate;
+		pthread_mutex_unlock(&ctx->mx);
+		if (terminate) {
+			break;
+		}
+
+		int r = poll_read(ctx->sock);
+		if (r == -1) {
+			if (errno == EINTR) {
+				continue;
+			} else {
+				break;
+			}
+		} else if (r == 0) {
+			continue;
+		}
+
+		assert(r == 1);
+		server_handle(ctx);
+	}
+
+	return NULL;
+}
+
+static bool server_start(server_ctx_t *ctx, int sock, int type,
+                         server_cb handler, void *handler_data)
+{
+	memset(ctx, 0, sizeof(*ctx));
+
+	ctx->sock = sock;
+	ctx->type = type;
+	ctx->handler = handler;
+	ctx->handler_data = handler_data;
+
+	ctx->terminate = false;
+
+	pthread_mutex_init(&ctx->mx, NULL);
+	return (pthread_create(&ctx->thr, NULL, server_main, ctx) == 0);
+}
+
+static void server_stop(server_ctx_t *ctx)
+{
+	pthread_mutex_lock(&ctx->mx);
+	ctx->terminate = true;
+	pthread_mutex_unlock(&ctx->mx);
+
+	pthread_kill(ctx->thr, SIGUSR1);
+	pthread_join(ctx->thr, NULL);
+}
+
+/* -- tests ---------------------------------------------------------------- */
+
+static void handler_echo(int sock, void *_server)
+{
+	server_ctx_t *server = _server;
+	uint8_t buffer[16] = { 0 };
+
+	struct sockaddr_storage remote = { 0 };
+	struct sockaddr_storage *addr = NULL;
+	if (!socktype_is_stream(server->type)) {
+		addr = &remote;
+	}
+
+	int in = net_recv(sock, buffer, sizeof(buffer), addr, TIMEOUT);
+	if (in <= 0) {
+		return;
+	}
+
+	net_send(sock, buffer, in, (struct sockaddr *)addr, TIMEOUT);
+}
+
+static void test_connected_one(const struct sockaddr_storage *server_addr,
+                               const struct sockaddr_storage *source_addr,
+                               int type, const char *name, const char *addr_name)
+{
+	int r;
+
+	int client = net_connected_socket(type, (struct sockaddr *)server_addr, NULL);
+	ok(client >= 0, "%s, %s: client, create connected socket", name, addr_name);
+
+	const uint8_t out[] = "test message";
+	const size_t out_len = sizeof(out);
+	if (socktype_is_stream(type)) {
+		r = net_stream_send(client, out, out_len, TIMEOUT);
+	} else {
+		r = net_dgram_send(client, out, out_len, NULL);
+	}
+	ok(r == out_len, "%s, %s: client, send message", name, addr_name);
+
+	r = net_is_connected(client);
+	ok(r, "%s, %s: client, is connected", name, addr_name);
+
+	uint8_t in[128] = { 0 };
+	if (socktype_is_stream(type)) {
+		r = net_stream_recv(client, in, sizeof(in), TIMEOUT);
+	} else {
+		r = net_dgram_recv(client, in, sizeof(in), TIMEOUT);
+	}
+	ok(r == out_len && memcmp(out, in, out_len) == 0,
+	   "%s, %s: client, receive message", name, addr_name);
+
+	close(client);
+}
+
+static void test_connected(int type)
+{
+	const char *name = socktype_name(type);
+	const struct sockaddr_storage empty_addr = { 0 };
+	const struct sockaddr_storage local_addr = addr_local();
+
+	int r;
+
+	// setup server
+
+	int server = net_bound_socket(type, (struct sockaddr *)&local_addr, 0);
+	ok(server >= 0, "%s: server, create bound socket", name);
+
+	if (socktype_is_stream(type)) {
+		r = listen(server, LISTEN_BACKLOG);
+		ok(r == 0, "%s: server, start listening", name);
+	}
+
+	server_ctx_t server_ctx = { 0 };
+	r = server_start(&server_ctx, server, type, handler_echo, &server_ctx);
+	ok(r, "%s: server, start", name);
+
+	const struct sockaddr_storage server_addr = addr_from_socket(server);
+
+	// connected socket, send and receive
+
+	test_connected_one(&server_addr, NULL, type, name, "NULL source");
+	test_connected_one(&server_addr, &empty_addr, type, name, "zero source");
+	test_connected_one(&server_addr, &local_addr, type, name, "valid source");
+
+	// cleanup
+
+	server_stop(&server_ctx);
+	close(server);
+}
+
+static void handler_noop(int sock, void *data)
+{
+}
+
+static void test_unconnected(void)
+{
+	int r = 0;
+	int sock = -1;
+	const struct sockaddr_storage local = addr_local();
+
+	uint8_t buffer[] = { 'k', 'n', 'o', 't' };
+	ssize_t buffer_len = sizeof(buffer);
+
+	// server
+
+	int server = net_bound_socket(SOCK_DGRAM, (struct sockaddr *)&local, 0);
+	ok(server >= 0, "UDP, create server socket");
+
+	server_ctx_t server_ctx = { 0 };
+	r = server_start(&server_ctx, server, SOCK_DGRAM, handler_noop, NULL);
+	ok(r, "UDP, start server");
+
+	// UDP
+
+	sock = net_unbound_socket(SOCK_DGRAM, (struct sockaddr *)&local);
+	ok(sock >= 0, "UDP, create unbound socket");
+
+	ok(!net_is_connected(sock), "UDP, is not connected");
+
+	r = net_dgram_send(sock, buffer, buffer_len, NULL);
+	ok(r == KNOT_ECONN, "UDP, send failure on unconnected socket");
+
+	r = net_dgram_recv(sock, buffer, buffer_len, TIMEOUT_SHORT);
+	ok(r == KNOT_ETIMEOUT, "UDP, receive timeout on unconnected socket");
+
+	struct sockaddr_storage server_addr = addr_from_socket(server);
+	r = net_dgram_send(sock, buffer, buffer_len, (struct sockaddr *)&server_addr);
+	ok(r == buffer_len, "UDP, send on defined address");
+
+	close(sock);
+
+	// TCP
+
+	sock = net_unbound_socket(SOCK_STREAM, (struct sockaddr *)&local);
+	ok(sock >= 0, "TCP, create unbound socket");
+
+	ok(!net_is_connected(sock), "TCP, is not connected");
+
+#ifdef __linux__
+	const int expected = KNOT_ECONN;
+	const char *expected_msg = "failure";
+	const int expected_timeout = TIMEOUT;
+#else
+	const int expected = KNOT_ETIMEOUT;
+	const char *expected_msg = "timeout";
+	const int expected_timeout = TIMEOUT_SHORT;
+#endif
+
+	r = net_stream_send(sock, buffer, buffer_len, expected_timeout);
+	ok(r == expected, "TCP, send %s on unconnected socket", expected_msg);
+
+	r = net_stream_recv(sock, buffer, sizeof(buffer), expected_timeout);
+	ok(r == expected, "TCP, receive %s on unconnected socket", expected_msg);
+
+	close(sock);
+
+	// server termination
+
+	server_stop(&server_ctx);
+	close(server);
+}
+
+static void test_refused(void)
+{
+	int r = -1;
+
+	struct sockaddr_storage addr = { 0 };
+	uint8_t buffer[1] = { 0 };
+	int server, client;
+
+	// unreachable remote
+
+#ifdef ENABLE_NET_UNREACHABLE_TEST
+	addr = addr_unreachable();
+
+	client = net_connected_socket(SOCK_STREAM, &addr, NULL);
+	ok(client >= 0, "client, connected");
+
+	tv = TIMEOUT_SHORT;
+	r = net_stream_send(client, (uint8_t *)"", 1, &tv);
+	ok(r == KNOT_ETIMEOUT, "client, timeout on write");
+	close(client);
+
+	client = net_connected_socket(SOCK_STREAM, &addr, NULL);
+	ok(client >= 0, "client, connected");
+
+	tv = TIMEOUT_SHORT;
+	r = net_stream_recv(client, buffer, sizeof(buffer), &tv);
+	ok(r == KNOT_ETIMEOUT, "client, timeout on read");
+	close(client);
+#else
+	skip("unreachable tests disabled");
+#endif
+
+	// listening, not accepting
+
+	addr = addr_local();
+	server = net_bound_socket(SOCK_STREAM, (struct sockaddr *)&addr, 0);
+	ok(server >= 0, "server, create server");
+	addr = addr_from_socket(server);
+
+	r = listen(server, LISTEN_BACKLOG);
+	ok(r == 0, "server, start listening");
+
+	client = net_connected_socket(SOCK_STREAM, (struct sockaddr *)&addr, NULL);
+	ok(client >= 0, "client, connect");
+
+	r = net_stream_send(client, (uint8_t *)"", 1, TIMEOUT);
+	ok(r == 1, "client, successful write");
+
+	r = net_stream_recv(client, buffer, sizeof(buffer), TIMEOUT_SHORT);
+	ok(r == KNOT_ETIMEOUT, "client, timeout on read");
+
+	close(client);
+
+	// listening, closed immediately
+
+	client = net_connected_socket(SOCK_STREAM, (struct sockaddr *)&addr, NULL);
+	ok(client >= 0, "client, connect");
+
+	r = close(server);
+	ok(r == 0, "server, close socket");
+
+	r = net_stream_send(client, (uint8_t *)"", 1, TIMEOUT);
+	ok(r == KNOT_ECONN, "client, refused on write");
+
+	close(client);
+}
+
+struct dns_handler_ctx {
+	const uint8_t *expected;
+	int len;
+	bool raw;
+	bool success;
+};
+
+static void _sync(int remote, int send)
+{
+	uint8_t buf[1] = { 0 };
+	int r;
+	if (send) {
+		r = net_stream_send(remote, buf, sizeof(buf), TIMEOUT);
+	} else {
+		r = net_stream_recv(remote, buf, sizeof(buf), TIMEOUT);
+
+	}
+	assert(r == sizeof(buf));
+	(void)r;
+}
+
+static void sync_signal(int remote)
+{
+	_sync(remote, true);
+}
+
+static void sync_wait(int remote)
+{
+	_sync(remote, false);
+}
+
+static void handler_dns(int sock, void *_ctx)
+{
+	struct dns_handler_ctx *ctx = _ctx;
+
+	uint8_t in[16] = { 0 };
+	int in_len = 0;
+
+	sync_signal(sock);
+
+	if (ctx->raw) {
+		in_len = net_stream_recv(sock, in, sizeof(in), TIMEOUT);
+	} else {
+		in_len = net_dns_tcp_recv(sock, in, sizeof(in), TIMEOUT);
+	}
+
+	ctx->success = in_len == ctx->len &&
+	               (ctx->len < 0 || memcmp(in, ctx->expected, in_len) == 0);
+}
+
+static void dns_send_hello(int sock)
+{
+	net_dns_tcp_send(sock, (uint8_t *)"wimbgunts", 9, TIMEOUT);
+}
+
+static void dns_send_fragmented(int sock)
+{
+	struct fragment { const uint8_t *data; size_t len; };
+
+	const struct fragment fragments[] = {
+		{ (uint8_t *)"\x00",     1 },
+		{ (uint8_t *)"\x08""qu", 3 },
+		{ (uint8_t *)"oopisk",   6 },
+		{ NULL }
+	};
+
+	for (const struct fragment *f = fragments; f->len > 0; f++) {
+		net_stream_send(sock, f->data, f->len, TIMEOUT);
+	}
+}
+
+static void dns_send_incomplete(int sock)
+{
+	net_stream_send(sock, (uint8_t *)"\x00\x08""korm", 6, TIMEOUT);
+}
+
+static void dns_send_trailing(int sock)
+{
+	net_stream_send(sock, (uint8_t *)"\x00\x05""bloitxx", 9, TIMEOUT);
+}
+
+static void test_dns_tcp(void)
+{
+	struct testcase {
+		const char *name;
+		const uint8_t *expected;
+		size_t expected_len;
+		bool expected_raw;
+		void (*send_callback)(int sock);
+	};
+
+	const struct testcase testcases[] = {
+		{ "single DNS",       (uint8_t *)"wimbgunts", 9, false, dns_send_hello },
+		{ "single RAW",       (uint8_t *)"\x00\x09""wimbgunts", 11, true, dns_send_hello },
+		{ "fragmented",       (uint8_t *)"quoopisk", 8, false, dns_send_fragmented },
+		{ "incomplete",       NULL, KNOT_ECONN, false, dns_send_incomplete },
+		{ "trailing garbage", (uint8_t *)"bloit", 5, false, dns_send_trailing },
+		{ NULL }
+	};
+
+	for (const struct testcase *t = testcases; t->name != NULL; t++) {
+		struct dns_handler_ctx handler_ctx = {
+			.expected = t->expected,
+			.len      = t->expected_len,
+			.raw      = t->expected_raw,
+			.success  = false
+		};
+
+		struct sockaddr_storage addr = addr_local();
+		int server = net_bound_socket(SOCK_STREAM, (struct sockaddr *)&addr, 0);
+		ok(server >= 0, "%s, server, create socket", t->name);
+
+		int r = listen(server, LISTEN_BACKLOG);
+		ok(r == 0, "%s, server, start listening", t->name);
+
+		server_ctx_t server_ctx = { 0 };
+		r = server_start(&server_ctx, server, SOCK_STREAM, handler_dns, &handler_ctx);
+		ok(r, "%s, server, start handler", t->name);
+
+		addr = addr_from_socket(server);
+		int client = net_connected_socket(SOCK_STREAM, (struct sockaddr *)&addr, NULL);
+		ok(client >= 0, "%s, client, create connected socket", t->name);
+
+		sync_wait(client);
+		t->send_callback(client);
+
+		close(client);
+		server_stop(&server_ctx);
+		close(server);
+
+		ok(handler_ctx.success, "%s, expected result", t->name);
+	}
+}
+
+static bool socket_is_blocking(int sock)
+{
+	return fcntl(sock, F_GETFL, O_NONBLOCK) == 0;
+}
+
+static void test_nonblocking_mode(int type)
+{
+	const char *name = socktype_name(type);
+	const struct sockaddr_storage addr = addr_local();
+
+	int client = net_unbound_socket(type, (struct sockaddr *)&addr);
+	ok(client >= 0, "%s: unbound, create", name);
+	ok(!socket_is_blocking(client), "%s: unbound, nonblocking mode", name);
+	close(client);
+
+	int server = net_bound_socket(type, (struct sockaddr *)&addr, 0);
+	ok(server >= 0, "%s: bound, create", name);
+	ok(!socket_is_blocking(server), "%s: bound, nonblocking mode", name);
+
+	if (socktype_is_stream(type)) {
+		int r = listen(server, LISTEN_BACKLOG);
+		ok(r == 0, "%s: bound, start listening", name);
+	}
+
+	struct sockaddr_storage server_addr = addr_from_socket(server);
+	client = net_connected_socket(type, (struct sockaddr *)&server_addr, NULL);
+	ok(client >= 0, "%s: connected, create", name);
+	ok(!socket_is_blocking(client), "%s: connected, nonblocking mode", name);
+
+	close(client);
+	close(server);
+}
+
+static void test_nonblocking_accept(void)
+{
+	int r;
+
+	// create server
+
+	struct sockaddr_storage addr_server = addr_local();
+
+	int server = net_bound_socket(SOCK_STREAM, (struct sockaddr *)&addr_server, 0);
+	ok(server >= 0, "server, create socket");
+
+	r = listen(server, LISTEN_BACKLOG);
+	ok(r == 0, "server, start listening");
+
+	addr_server = addr_from_socket(server);
+
+	// create client
+
+	int client = net_connected_socket(SOCK_STREAM, (struct sockaddr *)&addr_server, NULL);
+	ok(client >= 0, "client, create connected socket");
+
+	struct sockaddr_storage addr_client = addr_from_socket(client);
+
+	// accept connection
+
+	r = poll_read(server);
+	ok(r == 1, "server, pending connection");
+
+	struct sockaddr_storage addr_accepted = { 0 };
+	int accepted = net_accept(server, &addr_accepted);
+	ok(accepted >= 0, "server, accept connection");
+
+	ok(!socket_is_blocking(accepted), "accepted, nonblocking mode");
+
+	ok(sockaddr_cmp((struct sockaddr *)&addr_client,
+	                (struct sockaddr *)&addr_accepted) == 0,
+	   "accepted, correct address");
+
+	close(client);
+
+	// client reconnect
+
+	close(client);
+	client = net_connected_socket(SOCK_STREAM, (struct sockaddr *)&addr_server, NULL);
+	ok(client >= 0, "client, reconnect");
+
+	r = poll_read(server);
+	ok(r == 1, "server, pending connection");
+
+	accepted = net_accept(server, NULL);
+	ok(accepted >= 0, "server, accept connection (no remote address)");
+
+	ok(!socket_is_blocking(accepted), "accepted, nonblocking mode");
+
+	// cleanup
+
+	close(client);
+	close(server);
+}
+
+static void test_socket_types(void)
+{
+	struct sockaddr_storage addr = addr_local();
+
+	struct testcase {
+		const char *name;
+		int type;
+		bool is_stream;
+	};
+
+	const struct testcase testcases[] = {
+		{ "UDP", SOCK_DGRAM, false },
+		{ "TCP", SOCK_STREAM, true },
+		{ NULL }
+	};
+
+	for (const struct testcase *t = testcases; t->name != NULL; t++) {
+		int sock = net_unbound_socket(t->type, (struct sockaddr *)&addr);
+		ok(sock >= 0, "%s, create socket", t->name);
+
+		is_int(t->type, net_socktype(sock), "%s, socket type", t->name);
+
+		ok(net_is_stream(sock) == t->is_stream, "%s, is stream", t->name);
+
+		close(sock);
+	}
+
+	is_int(AF_UNSPEC, net_socktype(-1), "invalid, socket type");
+	ok(!net_is_stream(-1), "invalid, is stream");
+}
+
+static void test_bind_multiple(void)
+{
+	const struct sockaddr_storage addr = addr_local();
+
+	// bind first socket
+
+	int sock_one = net_bound_socket(SOCK_DGRAM, (struct sockaddr *)&addr, NET_BIND_MULTIPLE);
+	if (sock_one == KNOT_ENOTSUP) {
+		skip("not supported on this system");
+		return;
+	}
+	ok(sock_one >= 0, "bind first socket");
+
+	// bind second socket to the same address
+
+	const struct sockaddr_storage addr_one = addr_from_socket(sock_one);
+	int sock_two = net_bound_socket(SOCK_DGRAM, (struct sockaddr *)&addr_one, NET_BIND_MULTIPLE);
+	ok(sock_two >= 0, "bind second socket");
+
+	// compare sockets
+
+	ok(sock_one != sock_two, "descriptors are different");
+
+	const struct sockaddr_storage addr_two = addr_from_socket(sock_two);
+	ok(sockaddr_cmp((struct sockaddr *)&addr_one,
+	                (struct sockaddr *)&addr_two) == 0,
+	   "addresses are the same");
+
+	close(sock_one);
+	close(sock_two);
+}
+
+static void signal_noop(int sig)
+{
+}
+
+int main(int argc, char *argv[])
+{
+	plan_lazy();
+
+	signal(SIGUSR1, signal_noop);
+
+	diag("nonblocking mode");
+	test_nonblocking_mode(SOCK_DGRAM);
+	test_nonblocking_mode(SOCK_STREAM);
+	test_nonblocking_accept();
+
+	diag("socket types");
+	test_socket_types();
+
+	diag("connected sockets");
+	test_connected(SOCK_DGRAM);
+	test_connected(SOCK_STREAM);
+
+	diag("unconnected sockets");
+	test_unconnected();
+
+	diag("refused connections");
+	test_refused();
+
+	diag("DNS messages over TCP");
+	test_dns_tcp();
+
+	diag("flag NET_BIND_MULTIPLE");
+	test_bind_multiple();
+
+	return 0;
+}
diff --git a/tests/contrib/test_net_shortwrite.c b/tests/contrib/test_net_shortwrite.c
new file mode 100644
index 0000000..37b80ac
--- /dev/null
+++ b/tests/contrib/test_net_shortwrite.c
@@ -0,0 +1,151 @@
+/*  Copyright (C) 2015 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+*/
+
+#include <tap/basic.h>
+
+#include <fcntl.h>
+#include <stdint.h>
+#include <string.h>
+#include <pthread.h>
+#include <poll.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+
+#include "libknot/errcode.h"
+#include "contrib/net.h"
+#include "contrib/sockaddr.h"
+
+const int TIMEOUT = 2000;
+
+static struct sockaddr_storage localhost(void)
+{
+	struct sockaddr_storage addr = { 0 };
+
+	struct addrinfo *res = NULL;
+	if (getaddrinfo(NULL, "0", NULL, &res) == 0) {
+		memcpy(&addr, res->ai_addr, res->ai_addrlen);
+		freeaddrinfo(res);
+	}
+
+	return addr;
+}
+
+struct data {
+	int server_fd;
+	uint8_t *buffer;
+	size_t size;
+	int result;
+};
+
+static void *thr_receive(void *data)
+{
+	struct data *d = data;
+
+	struct pollfd pfd = { .fd = d->server_fd, .events = POLLIN };
+	int r = poll(&pfd, 1, TIMEOUT);
+	if (r != 1) {
+		d->result = KNOT_ETIMEOUT;
+		return NULL;
+	}
+
+	int client = accept(d->server_fd, NULL, NULL);
+	if (client < 0) {
+		d->result = KNOT_ECONN;
+		return NULL;
+	}
+
+	d->result = net_dns_tcp_recv(client, d->buffer, d->size, TIMEOUT);
+
+	close(client);
+
+	return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+	plan_lazy();
+
+	int r;
+
+	// create TCP server
+
+	struct sockaddr_storage addr = localhost();
+	int server = net_bound_socket(SOCK_STREAM, (struct sockaddr *)&addr, 0);
+	ok(server >= 0, "server: bind socket");
+
+	r = listen(server, 0);
+	ok(r == 0, "server: start listening");
+
+	struct sockaddr *sa = (struct sockaddr *)&addr;
+	socklen_t salen = sockaddr_len(sa);
+	r = getsockname(server, sa, &salen);
+	ok(r == 0, "server: get bound address");
+
+	// create TCP client
+
+	int client = net_connected_socket(SOCK_STREAM, (struct sockaddr *)&addr, NULL);
+	ok(client >= 0, "client: connect to server");
+
+	int optval = 8192;
+	socklen_t optlen = sizeof(optval);
+	r = setsockopt(client, SOL_SOCKET, SO_SNDBUF, &optval, optlen);
+	ok(r == 0, "client: configure small send buffer");
+
+	// accept TCP connection on the background
+
+	uint8_t recvbuf[UINT16_MAX] = { 0 };
+	struct data recv_data = {
+		.server_fd = server,
+		.buffer = recvbuf,
+		.size = sizeof(recvbuf)
+	};
+
+	pthread_t thr;
+	r = pthread_create(&thr, NULL, thr_receive, &recv_data);
+	ok(r == 0, "server: start receiver thread");
+
+	// send message (should handle partial-write correctly)
+
+	uint8_t sndbuf[UINT16_MAX];
+	for (size_t i = 0; i < sizeof(sndbuf); i++) {
+		sndbuf[i] = i;
+	}
+	r = net_dns_tcp_send(client, sndbuf, sizeof(sndbuf), TIMEOUT);
+	ok(r == sizeof(sndbuf), "client: net_dns_tcp_send() with short-write");
+
+	// receive message
+
+	r = pthread_join(thr, NULL);
+	ok(r == 0, "server: wait for receiver thread to terminate");
+
+	ok(recv_data.result == sizeof(recvbuf) &&
+	   memcmp(sndbuf, recvbuf, sizeof(recvbuf)) == 0,
+	   "server: net_dns_tcp_recv() complete and valid data");
+
+	// clean up
+
+	if (server >= 0) {
+		close(server);
+	}
+
+	if (client >= 0) {
+		close(client);
+	}
+
+	return 0;
+}
diff --git a/tests/contrib/test_qp-trie.c b/tests/contrib/test_qp-trie.c
new file mode 100644
index 0000000..f1440f2
--- /dev/null
+++ b/tests/contrib/test_qp-trie.c
@@ -0,0 +1,202 @@
+/*  Copyright (C) 2016 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <tap/basic.h>
+
+#include "contrib/qp-trie/trie.h"
+#include "contrib/macros.h"
+#include "contrib/string.h"
+#include "libknot/errcode.h"
+
+/* UCW array sorting defines. */
+#define ASORT_PREFIX(X) str_key_##X
+#define ASORT_KEY_TYPE char*
+#define ASORT_LT(x, y) (strcmp((x), (y)) < 0)
+#include "contrib/ucw/array-sort.h"
+
+/* Constants. */
+#define KEY_MAXLEN 64
+
+/*! \brief Generate random key. */
+static const char *alphabet = "abcdefghijklmn0123456789";
+static char *str_key_rand(size_t len)
+{
+	char *s = malloc(len);
+	memset(s, 0, len);
+	for (unsigned i = 0; i < len - 1; ++i) {
+		s[i] = alphabet[rand() % strlen(alphabet)];
+	}
+	return s;
+}
+
+/* \brief Check lesser or equal result. */
+static bool str_key_get_leq(trie_t *trie, char **keys, size_t i, size_t size)
+{
+	static char key_buf[KEY_MAXLEN];
+
+	int ret = 0;
+	trie_val_t *val = NULL;
+	const char *key = keys[i];
+	size_t key_len = strlen(key) + 1;
+	memcpy(key_buf, key, key_len);
+
+	/* Count equal first keys. */
+	size_t first_key_count = 1;
+	for (size_t k = 1; k < size; ++k) {
+		if (strcmp(keys[0], keys[k]) == 0) {
+			first_key_count += 1;
+		} else {
+			break;
+		}
+	}
+
+	/* Before current key. */
+	key_buf[key_len - 2] -= 1;
+	if (i < first_key_count) {
+		ret = trie_get_leq(trie, key_buf, key_len, &val);
+		if (ret != KNOT_ENOENT) {
+			diag("%s: leq for key BEFORE %zu/'%s' ret = %d", __func__, i, keys[i], ret);
+			return false; /* No key before first. */
+		}
+	} else {
+		ret = trie_get_leq(trie, key_buf, key_len, &val);
+		if (ret < KNOT_EOK || strcmp(*val, key_buf) > 0) {
+			diag("%s: '%s' is not before the key %zu/'%s'", __func__, (char*)*val, i, keys[i]);
+			return false; /* Found key must be LEQ than searched. */
+		}
+	}
+
+	/* Current key. */
+	key_buf[key_len - 2] += 1;
+	ret = trie_get_leq(trie, key_buf, key_len, &val);
+	if (! (ret == KNOT_EOK && val && strcmp(*val, key_buf) == 0)) {
+		diag("%s: leq for key %zu/'%s' ret = %d", __func__, i, keys[i], ret);
+		return false; /* Must find equal match. */
+	}
+
+	/* After the current key. */
+	key_buf[key_len - 2] += 1;
+	ret = trie_get_leq(trie, key_buf, key_len, &val);
+	if (! (ret >= KNOT_EOK && strcmp(*val, key_buf) <= 0)) {
+		diag("%s: leq for key AFTER %zu/'%s' ret = %d %s", __func__, i, keys[i], ret, (char*)*val);
+		return false; /* Every key must have its LEQ match. */
+	}
+
+	return true;
+
+}
+
+int main(int argc, char *argv[])
+{
+	plan_lazy();
+
+	/* Random keys. */
+	srand(time(NULL));
+	unsigned key_count = 100000;
+	char **keys = malloc(sizeof(char*) * key_count);
+	for (unsigned i = 0; i < key_count; ++i) {
+		keys[i] = str_key_rand(KEY_MAXLEN);
+	}
+
+	/* Sort random keys. */
+	str_key_sort(keys, key_count);
+
+	/* Create trie */
+	trie_val_t *val = NULL;
+	trie_t *trie = trie_create(NULL);
+	ok(trie != NULL, "trie: create");
+
+	/* Insert keys */
+	bool passed = true;
+	size_t inserted = 0;
+	for (unsigned i = 0; i < key_count; ++i) {
+		val = trie_get_ins(trie, keys[i], strlen(keys[i]) + 1);
+		if (!val) {
+			passed = false;
+			break;
+		}
+		if (*val == NULL) {
+			*val = keys[i];
+			++inserted;
+		}
+	}
+	ok(passed, "trie: insert");
+
+	/* Check total insertions against trie weight. */
+	is_int(trie_weight(trie), inserted, "trie: trie weight matches insertions");
+
+	/* Lookup all keys */
+	passed = true;
+	for (unsigned i = 0; i < key_count; ++i) {
+		val = trie_get_try(trie, keys[i], strlen(keys[i]) + 1);
+		if (val && (*val == keys[i] || strcmp(*val, keys[i]) == 0)) {
+			continue;
+		} else {
+			diag("trie: mismatch on element '%u'", i);
+			passed = false;
+			break;
+		}
+	}
+	ok(passed, "trie: lookup all keys");
+
+	/* Lesser or equal lookup. */
+	passed = true;
+	for (unsigned i = 0; i < key_count; ++i) {
+		if (!str_key_get_leq(trie, keys, i, key_count)) {
+			passed = false;
+			for (int off = -10; off < 10; ++off) {
+				int k = (int)i + off;
+				if (k < 0 || k >= key_count) {
+					continue;
+				}
+				diag("[%u/%d]: %s%s", i, off, off == 0?">":"",keys[k]);
+			}
+			break;
+		}
+	}
+	ok(passed, "trie: find lesser or equal for all keys");
+
+	/* Sorted iteration. */
+	char key_buf[KEY_MAXLEN] = {'\0'};
+	size_t iterated = 0;
+	trie_it_t *it = trie_it_begin(trie);
+	while (!trie_it_finished(it)) {
+		size_t cur_key_len = 0;
+		const char *cur_key = trie_it_key(it, &cur_key_len);
+		if (iterated > 0) { /* Only if previous exists. */
+			if (strcmp(key_buf, cur_key) > 0) {
+				diag("'%s' <= '%s' FAIL\n", key_buf, cur_key);
+				break;
+			}
+		}
+		++iterated;
+		memcpy(key_buf, cur_key, cur_key_len);
+		trie_it_next(it);
+	}
+	is_int(inserted, iterated, "trie: sorted iteration");
+	trie_it_free(it);
+
+	/* Cleanup */
+	for (unsigned i = 0; i < key_count; ++i) {
+		free(keys[i]);
+	}
+	free(keys);
+	trie_free(trie);
+	return 0;
+}
diff --git a/tests/contrib/test_siphash.c b/tests/contrib/test_siphash.c
new file mode 100644
index 0000000..b7e2739
--- /dev/null
+++ b/tests/contrib/test_siphash.c
@@ -0,0 +1,135 @@
+/*  Copyright (C) 2018 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+ */
+
+#include <string.h>
+#include <tap/basic.h>
+
+// Prevent possible linking with a system SiphHash (OpenBSD).
+#include "contrib/openbsd/siphash.c"
+
+// https://github.com/veorq/SipHash
+const uint8_t vectors24[64][8] = {
+	{ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72 },
+	{ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74 },
+	{ 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d },
+	{ 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85 },
+	{ 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf },
+	{ 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18 },
+	{ 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb },
+	{ 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab },
+	{ 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93 },
+	{ 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e },
+	{ 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a },
+	{ 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4 },
+	{ 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75 },
+	{ 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14 },
+	{ 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7 },
+	{ 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1 },
+	{ 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f },
+	{ 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69 },
+	{ 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b },
+	{ 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb },
+	{ 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe },
+	{ 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0 },
+	{ 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93 },
+	{ 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8 },
+	{ 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8 },
+	{ 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc },
+	{ 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17 },
+	{ 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f },
+	{ 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde },
+	{ 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6 },
+	{ 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad },
+	{ 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32 },
+	{ 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71 },
+	{ 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7 },
+	{ 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12 },
+	{ 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15 },
+	{ 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31 },
+	{ 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02 },
+	{ 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca },
+	{ 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a },
+	{ 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e },
+	{ 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad },
+	{ 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18 },
+	{ 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4 },
+	{ 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9 },
+	{ 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9 },
+	{ 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb },
+	{ 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0 },
+	{ 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6 },
+	{ 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7 },
+	{ 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee },
+	{ 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1 },
+	{ 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a },
+	{ 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81 },
+	{ 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f },
+	{ 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24 },
+	{ 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7 },
+	{ 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea },
+	{ 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60 },
+	{ 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66 },
+	{ 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c },
+	{ 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f },
+	{ 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5 },
+	{ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95 },
+};
+
+static void block_test(SIPHASH_KEY *key, uint8_t *data, int data_len, int block_len)
+{
+	int count = data_len / block_len;
+	int rest = data_len % block_len;
+
+	SIPHASH_CTX ctx;
+	SipHash24_Init(&ctx, key);
+
+	for (int i = 0; i < count; i++) {
+		SipHash24_Update(&ctx, data + i * block_len, block_len);
+	}
+	SipHash24_Update(&ctx, data + count * block_len, rest);
+
+	uint64_t hash = SipHash24_End(&ctx);
+	ok(memcmp(&hash, vectors24[data_len], sizeof(uint64_t)) == 0,
+	   "siphash24: %i-byte block updates", block_len);
+}
+
+int main(void)
+{
+	plan_lazy();
+
+	SIPHASH_KEY key;
+	memcpy(&key.k0, "\x00\x01\x02\x03\x04\x05\x06\x07", sizeof(uint64_t));
+	memcpy(&key.k1, "\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f", sizeof(uint64_t));
+
+	uint8_t data[64];
+	for (int i = 0; i < sizeof(data); i++) {
+		data[i] = i;
+	}
+
+	for (int data_len = 0; data_len < sizeof(data); data_len++) {
+		diag("data length %i", data_len);
+
+		uint64_t hash = SipHash24(&key, data, data_len);
+		ok(memcmp(&hash, vectors24[data_len], sizeof(uint64_t)) == 0,
+		   "siphash24: 1-block update");
+
+		for (int block_len = 1; block_len <= 8; block_len++) {
+			block_test(&key, data, data_len, block_len);
+		}
+	}
+
+	return 0;
+}
diff --git a/tests/contrib/test_sockaddr.c b/tests/contrib/test_sockaddr.c
new file mode 100644
index 0000000..5f80507
--- /dev/null
+++ b/tests/contrib/test_sockaddr.c
@@ -0,0 +1,234 @@
+/*  Copyright (C) 2016 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+ */
+
+#include <tap/basic.h>
+
+#include "contrib/sockaddr.h"
+#include "libknot/errcode.h"
+
+struct sockaddr *SA(struct sockaddr_storage *ss)
+{
+	return (struct sockaddr *)ss;
+}
+
+static void test_sockaddr_is_any(void)
+{
+	struct sockaddr_storage invalid = { 0 };
+	ok(!sockaddr_is_any(SA(&invalid)), "sockaddr_is_any: invalid");
+
+	struct sockaddr_storage path = { 0 };
+	path.ss_family = AF_UNIX;
+	ok(!sockaddr_is_any(SA(&path)), "sockaddr_is_any: unix");
+
+	struct sockaddr_storage ipv4_local = { 0 };
+	sockaddr_set(&ipv4_local, AF_INET, "127.0.0.1", 0);
+	ok(!sockaddr_is_any(SA(&ipv4_local)), "sockaddr_is_any: IPv4 local");
+
+	struct sockaddr_storage ipv4_any = { 0 };
+	sockaddr_set(&ipv4_any, AF_INET, "0.0.0.0", 0);
+	ok(sockaddr_is_any(SA(&ipv4_any)), "sockaddr_is_any: IPv4 any");
+
+	struct sockaddr_storage ipv6_local = { 0 };
+	sockaddr_set(&ipv6_local, AF_INET6, "::1", 0);
+	ok(!sockaddr_is_any(SA(&ipv6_local)), "sockaddr_is_any: IPv6 local");
+
+	struct sockaddr_storage ipv6_any = { 0 };
+	sockaddr_set(&ipv6_any, AF_INET6, "::", 0);
+	ok(sockaddr_is_any(SA(&ipv6_any)), "sockaddr_is_any: IPv6 any");
+}
+
+static void check_sockaddr_set(struct sockaddr_storage *ss, int family,
+                               const char *straddr, int port)
+{
+	int ret = sockaddr_set(ss, family, straddr, port);
+	is_int(KNOT_EOK, ret, "set address '%s'", straddr);
+}
+
+static void test_net_match(void)
+{
+	int ret;
+	struct sockaddr_storage t = { 0 };
+
+	// 127 dec ~ 01111111 bin
+	// 170 dec ~ 10101010 bin
+	struct sockaddr_storage ref4 = { 0 };
+	check_sockaddr_set(&ref4, AF_INET, "127.170.170.127", 0);
+
+	// 7F hex ~ 01111111 bin
+	// AA hex ~ 10101010 bin
+	struct sockaddr_storage ref6 = { 0 };
+	check_sockaddr_set(&ref6, AF_INET6, "7FAA::AA7F", 0);
+
+	ret = sockaddr_net_match(SA(&ref4), SA(&ref6), 32);
+	ok(ret == false, "match: family mismatch");
+
+	ret = sockaddr_net_match(NULL, SA(&ref4), 32);
+	ok(ret == false, "match: NULL first parameter");
+	ret = sockaddr_net_match(SA(&ref4), NULL, 32);
+	ok(ret == false, "match: NULL second parameter");
+
+	ret = sockaddr_net_match(SA(&ref4), SA(&ref4), -1);
+	ok(ret == true, "match: ipv4 - identity, auto full prefix");
+	ret = sockaddr_net_match(SA(&ref4), SA(&ref4), 31);
+	ok(ret == true, "match: ipv4 - identity, subnet");
+	ret = sockaddr_net_match(SA(&ref4), SA(&ref4), 32);
+	ok(ret == true, "match: ipv4 - identity, full prefix");
+	ret = sockaddr_net_match(SA(&ref4), SA(&ref4), 33);
+	ok(ret == true, "match: ipv4 - identity, prefix overflow");
+
+	ret = sockaddr_net_match(SA(&ref6), SA(&ref6), -1);
+	ok(ret == true, "match: ipv6 - identity, auto full prefix");
+	ret = sockaddr_net_match(SA(&ref6), SA(&ref6), 127);
+	ok(ret == true, "match: ipv6 - identity, subnet");
+	ret = sockaddr_net_match(SA(&ref6), SA(&ref6), 128);
+	ok(ret == true, "match: ipv6 - identity, full prefix");
+	ret = sockaddr_net_match(SA(&ref6), SA(&ref6), 129);
+	ok(ret == true, "match: ipv6 - identity, prefix overflow");
+
+	// 124 dec ~ 01111100 bin
+	check_sockaddr_set(&t, AF_INET, "124.0.0.0", 0);
+	ret = sockaddr_net_match(SA(&t), SA(&ref4), 5);
+	ok(ret == true, "match: ipv4 - first byte, shorter prefix");
+	ret = sockaddr_net_match(SA(&t), SA(&ref4), 6);
+	ok(ret == true, "match: ipv4 - first byte, precise prefix");
+	ret = sockaddr_net_match(SA(&t), SA(&ref4), 7);
+	ok(ret == false, "match: ipv4 - first byte, not match");
+
+	check_sockaddr_set(&t, AF_INET, "127.170.170.124", 0);
+	ret = sockaddr_net_match(SA(&t), SA(&ref4), 29);
+	ok(ret == true, "match: ipv4 - last byte, shorter prefix");
+	ret = sockaddr_net_match(SA(&t), SA(&ref4), 30);
+	ok(ret == true, "match: ipv4 - last byte, precise prefix");
+	ret = sockaddr_net_match(SA(&t), SA(&ref4), 31);
+	ok(ret == false, "match: ipv4 - last byte, not match");
+
+	// 7C hex ~ 01111100 bin
+	check_sockaddr_set(&t, AF_INET6, "7CAA::", 0);
+	ret = sockaddr_net_match(SA(&t), SA(&ref6), 5);
+	ok(ret == true, "match: ipv6 - first byte, shorter prefix");
+	ret = sockaddr_net_match(SA(&t), SA(&ref6), 6);
+	ok(ret == true, "match: ipv6 - first byte, precise prefix");
+	ret = sockaddr_net_match(SA(&t), SA(&ref6), 7);
+	ok(ret == false, "match: ipv6 - first byte, not match");
+
+	check_sockaddr_set(&t, AF_INET6, "7FAA::AA7C", 0);
+	ret = sockaddr_net_match(SA(&t), SA(&ref6), 125);
+	ok(ret == true, "match: ipv6 - last byte, shorter prefix");
+	ret = sockaddr_net_match(SA(&t), SA(&ref6), 126);
+	ok(ret == true, "match: ipv6 - last byte, precise prefix");
+	ret = sockaddr_net_match(SA(&t), SA(&ref6), 127);
+	ok(ret == false, "match: ipv6 - last byte, not match");
+}
+
+static void test_range_match(void)
+{
+	bool ret;
+	struct sockaddr_storage t = { 0 };
+	struct sockaddr_storage min = { 0 };
+	struct sockaddr_storage max = { 0 };
+
+	// IPv4 tests.
+
+	check_sockaddr_set(&min, AF_INET, "0.0.0.0", 0);
+	check_sockaddr_set(&max, AF_INET, "255.255.255.255", 0);
+
+	check_sockaddr_set(&t, AF_INET, "0.0.0.0", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == true, "match: ipv4 max range - minimum");
+	check_sockaddr_set(&t, AF_INET, "255.255.255.255", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == true, "match: ipv4 max range - maximum");
+
+	check_sockaddr_set(&min, AF_INET, "1.13.113.213", 0);
+	check_sockaddr_set(&max, AF_INET, "2.24.124.224", 0);
+
+	check_sockaddr_set(&t, AF_INET, "1.12.113.213", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == false, "match: ipv4 middle range - negative far min");
+	check_sockaddr_set(&t, AF_INET, "1.13.113.212", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == false, "match: ipv4 middle range - negative close min");
+	check_sockaddr_set(&t, AF_INET, "1.13.113.213", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == true, "match: ipv4 middle range - minimum");
+	check_sockaddr_set(&t, AF_INET, "1.13.213.213", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == true, "match: ipv4 middle range - middle");
+	check_sockaddr_set(&t, AF_INET, "2.24.124.224", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == true, "match: ipv4 middle range - max");
+	check_sockaddr_set(&t, AF_INET, "2.24.124.225", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == false, "match: ipv4 middle range - negative close max");
+	check_sockaddr_set(&t, AF_INET, "2.25.124.225", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == false, "match: ipv4 middle range - negative far max");
+
+	// IPv6 tests.
+
+	check_sockaddr_set(&min, AF_INET6, "::0", 0);
+	check_sockaddr_set(&max, AF_INET6,
+	                   "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF", 0);
+
+	check_sockaddr_set(&t, AF_INET6, "::0", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == true, "match: ipv6 max range - minimum");
+	check_sockaddr_set(&t, AF_INET6,
+	                   "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == true, "match: ipv6 max range - maximum");
+
+	check_sockaddr_set(&min, AF_INET6, "1:13::ABCD:200B", 0);
+	check_sockaddr_set(&max, AF_INET6, "2:A24::124:224", 0);
+
+	check_sockaddr_set(&t, AF_INET6, "1:12::BCD:2000", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == false, "match: ipv6 middle range - negative far min");
+	check_sockaddr_set(&t, AF_INET6, "1:13::ABCD:200A", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == false, "match: ipv6 middle range - negative close min");
+	check_sockaddr_set(&t, AF_INET6, "1:13::ABCD:200B", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == true, "match: ipv6 middle range - minimum");
+	check_sockaddr_set(&t, AF_INET6, "1:13:0:12:34:0:ABCD:200B", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == true, "match: ipv6 middle range - middle");
+	check_sockaddr_set(&t, AF_INET6, "2:A24::124:224", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == true, "match: ipv6 middle range - max");
+	check_sockaddr_set(&t, AF_INET6, "2:A24::124:225", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == false, "match: ipv6 middle range - negative close max");
+	check_sockaddr_set(&t, AF_INET6, "2:FA24::4:24", 0);
+	ret = sockaddr_range_match(SA(&t), SA(&min), SA(&max));
+	ok(ret == false, "match: ipv6 middle range - negative far max");
+}
+
+int main(int argc, char *argv[])
+{
+	plan_lazy();
+
+	diag("sockaddr_is_any");
+	test_sockaddr_is_any();
+
+	diag("sockaddr_net_match");
+	test_net_match();
+
+	diag("sockaddr_range_match");
+	test_range_match();
+
+	return 0;
+}
diff --git a/tests/contrib/test_string.c b/tests/contrib/test_string.c
new file mode 100644
index 0000000..fca8b8a
--- /dev/null
+++ b/tests/contrib/test_string.c
@@ -0,0 +1,59 @@
+/*  Copyright (C) 2015 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+*/
+
+#include <tap/basic.h>
+
+#include <stdlib.h>
+
+#include "contrib/string.h"
+
+static void test_strstrip(void)
+{
+	char *c = NULL;
+
+	c = strstrip("hello");
+	is_string("hello", c, "strstrip: no whitespace");
+	free(c);
+
+	c = strstrip("world \n");
+	is_string("world", c, "strstrip: trailing whitespace");
+	free(c);
+
+	c = strstrip(" \n banana");
+	is_string("banana", c, "strstrip: leading whitespace");
+	free(c);
+
+	c = strstrip(" \t hello  world   \n");
+	is_string("hello  world", c, "strstrip: leading and trailing");
+	free(c);
+
+	c = strstrip("");
+	is_string("", c, "strstrip: empty string");
+	free(c);
+
+	c = strstrip("   ");
+	is_string("", c, "strstrip: just whitespaces");
+	free(c);
+}
+
+int main(int argc, char *argv[])
+{
+	plan_lazy();
+
+	test_strstrip();
+
+	return 0;
+}
diff --git a/tests/contrib/test_strtonum.c b/tests/contrib/test_strtonum.c
new file mode 100644
index 0000000..48f2559
--- /dev/null
+++ b/tests/contrib/test_strtonum.c
@@ -0,0 +1,156 @@
+/*  Copyright (C) 2018 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+*/
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <tap/basic.h>
+
+#include "contrib/strtonum.h"
+#include "libdnssec/error.h"
+
+static void test_u8(const char *in, uint8_t expected, int errcode)
+{
+	uint8_t out = 0x11;
+	assert(expected != out);
+
+	ok(str_to_u8(in, &out) == errcode &&
+	   (errcode != KNOT_EOK || out == expected),
+	   "str_to_u8 %s on \"%s\"",
+	   (errcode == KNOT_EOK ? "succeeds" : "fails"), in);
+}
+
+static void test_u16(const char *in, uint16_t expected, int errcode)
+{
+	uint16_t out = 0x0101;
+	assert(expected != out);
+
+	ok(str_to_u16(in, &out) == errcode &&
+	   (errcode != KNOT_EOK || out == expected),
+	   "str_to_u16 %s on \"%s\"",
+	   (errcode == KNOT_EOK ? "succeeds" : "fails"), in);
+}
+
+static void test_u32(const char *in, uint32_t expected, int errcode)
+{
+	uint32_t out = 0x010101;
+	assert(expected != out);
+
+	ok(str_to_u32(in, &out) == errcode &&
+	   (errcode != KNOT_EOK || out == expected),
+	   "str_to_u32 %s on \"%s\"",
+	   (errcode == KNOT_EOK ? "succeeds" : "fails"), in);
+}
+
+static void test_int(const char *in, int expected, int errcode)
+{
+	int out = 12345;
+	assert(expected != out);
+
+	ok(str_to_int(in, &out, INT_MIN, INT_MAX) == errcode &&
+	   (errcode != KNOT_EOK || out == expected),
+	   "str_to_int %s on \"%s\"",
+	   (errcode == KNOT_EOK ? "succeeds" : "fails"), in);
+}
+
+static void test_size(const char *in, size_t expected, size_t min, size_t max,
+                      int errcode)
+{
+	size_t out = 12345;
+	assert(expected != out);
+
+	ok(str_to_size(in, &out, min, max) == errcode &&
+	   (errcode != KNOT_EOK || out == expected),
+	   "str_to_int %s on \"%s\"",
+	   (errcode == KNOT_EOK ? "succeeds" : "fails"), in);
+}
+
+// mute warn_unused_result
+#define asprintf(args, ...) do { \
+	int r = (asprintf)(args, ##__VA_ARGS__); assert(r >= 0); (void)r; \
+} while (0);
+
+int main(int argc, char *argv[])
+{
+	plan_lazy();
+
+	test_u8("-1",          0,          KNOT_EINVAL);
+	test_u8("256",         0,          KNOT_ERANGE);
+	test_u8("0x1",         0,          KNOT_EINVAL);
+	test_u8(" 1",          0,          KNOT_EINVAL);
+	test_u8("1 ",          0,          KNOT_EINVAL);
+	test_u8("0",           0,          KNOT_EOK);
+	test_u8("42",          42,         KNOT_EOK);
+	test_u8("+84",         84,         KNOT_EOK);
+	test_u8("255",         UINT8_MAX,  KNOT_EOK);
+
+	test_u16("-1",         0,          KNOT_EINVAL);
+	test_u16("65536",      0,          KNOT_ERANGE);
+	test_u16("0x1",        0,          KNOT_EINVAL);
+	test_u16(" 1",         0,          KNOT_EINVAL);
+	test_u16("1 ",         0,          KNOT_EINVAL);
+	test_u16("0",          0,          KNOT_EOK);
+	test_u16("65280",      65280,      KNOT_EOK);
+	test_u16("+256",       256,        KNOT_EOK);
+	test_u16("65535",      UINT16_MAX, KNOT_EOK);
+
+	test_u32("-1",         0,          KNOT_EINVAL);
+	test_u32("4294967296", 0,          KNOT_ERANGE);
+	test_u32("0x1",        0,          KNOT_EINVAL);
+	test_u32(" 1",         0,          KNOT_EINVAL);
+	test_u32("1 ",         0,          KNOT_EINVAL);
+	test_u32("0",          0,          KNOT_EOK);
+	test_u32("65280",      65280,      KNOT_EOK);
+	test_u32("+256",       256,        KNOT_EOK);
+	test_u32("4294967295", UINT32_MAX, KNOT_EOK);
+
+	test_size("-1",         0,          0, 1, KNOT_EINVAL);
+	test_size("4294967296", 0,          0, 1, KNOT_ERANGE);
+	test_size("0",          0,          1, 2, KNOT_ERANGE);
+	test_size("0x1",        0,          0, 1, KNOT_EINVAL);
+	test_size(" 1",         0,          0, 1, KNOT_EINVAL);
+	test_size("1 ",         0,          0, 1, KNOT_EINVAL);
+	test_size("0",          0,          0, 1, KNOT_EOK);
+	test_size("65280",      65280,      0, 65280, KNOT_EOK);
+	test_size("+256",       256,        0, 65280, KNOT_EOK);
+
+	char *int_under = NULL;
+	asprintf(&int_under, "%lld", (long long)INT_MIN - 1);
+	char *int_min = NULL;
+	asprintf(&int_min,   "%lld", (long long)INT_MIN);
+	char *int_max = NULL;
+	asprintf(&int_max,   "%lld", (long long)INT_MAX);
+	char *int_over = NULL;
+	asprintf(&int_over,  "%lld", (long long)INT_MAX + 1);
+
+	test_int(int_under,      0,           KNOT_ERANGE);
+	test_int(int_over,       0,           KNOT_ERANGE);
+	test_int("0x1",          0,           KNOT_EINVAL);
+	test_int(" 1",           0,           KNOT_EINVAL);
+	test_int("1 ",           0,           KNOT_EINVAL);
+	test_int(int_min,        INT_MIN,     KNOT_EOK);
+	test_int("0",            0,           KNOT_EOK);
+	test_int("268435459",    268435459,   KNOT_EOK);
+	test_int("+1073741827",  1073741827,  KNOT_EOK);
+	test_int(int_max,        INT_MAX,     KNOT_EOK);
+
+	free(int_under);
+	free(int_min);
+	free(int_max);
+	free(int_over);
+
+	return 0;
+}
diff --git a/tests/contrib/test_time.c b/tests/contrib/test_time.c
new file mode 100644
index 0000000..a21f8c2
--- /dev/null
+++ b/tests/contrib/test_time.c
@@ -0,0 +1,203 @@
+/*  Copyright (C) 2017 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+ */
+
+#include <tap/basic.h>
+
+#include <string.h>
+
+#include "contrib/time.h"
+
+static void test_now(void)
+{
+	struct timespec t = time_now();
+	ok(t.tv_sec != 0, "time_now() returns something");
+}
+
+static void test_diff(void)
+{
+	struct timespec t1 = { 10, 1000 };
+	struct timespec t2 = { 50, 1500 };
+	struct timespec t3 = { 70, 500 };
+
+	struct timespec res;
+
+	res = time_diff(&t1, &t2);
+	ok(res.tv_sec == 40 && res.tv_nsec == 500, "time_diff()");
+
+	res = time_diff(&t2, &t3);
+	ok(res.tv_sec == 19 && res.tv_nsec == 999999000, "time_diff() ns overflow");
+
+	res = time_diff(&t3, &t1);
+	ok(res.tv_sec == -60 && res.tv_nsec == 500, "time_diff() negative");
+
+	res = time_diff(&t2, &t1);
+	ok(res.tv_sec == -41 && res.tv_nsec == 999999500, "time_diff() negative");
+}
+
+static void test_diff_ms(void)
+{
+	struct timespec t1 = { 10, 1000 };
+	struct timespec t2 = { 50, 500 };
+
+	float ms = 0.0;
+
+	ms = time_diff_ms(&t1, &t2);
+	ok(39990.0 < ms && ms < 40010.0, "time_diff_ms()");
+
+	ms = time_diff_ms(&t2, &t1);
+	ok(-40010.0 < ms && ms < -39990.0, "time_diff_ms() negative");
+}
+
+static void test_knot_time(void)
+{
+	knot_time_t a = knot_time();
+	knot_time_t inf = 0;
+	knot_time_t c;
+	knot_timediff_t d;
+	int ret;
+
+	ok(a != 0, "knot time not zero");
+
+	ret = knot_time_cmp(a, a);
+	ok(ret == 0, "compare same times");
+
+	ret = knot_time_cmp(a - 1, a + 1);
+	ok(ret == -1, "compare smaller time");
+
+	ret = knot_time_cmp(a + 10, a - 10);
+	ok(ret == 1, "compare bigger time");
+
+	ret = knot_time_cmp(inf, inf);
+	ok(ret == 0, "compare two infinities");
+
+	ret = knot_time_cmp(a, inf);
+	ok(ret == -1, "compare time and infty");
+
+	ret = knot_time_cmp(inf, a);
+	ok(ret == 1, "compare infty and time");
+
+	c = knot_time_min(a, a);
+	ok(c == a, "take same time");
+
+	c = knot_time_min(a, a + 1);
+	ok(c == a, "take first smaller");
+
+	c = knot_time_min(a + 1, a);
+	ok(c == a, "take second smaller");
+
+	c = knot_time_min(inf, inf);
+	ok(c == inf, "take same infty");
+
+	c = knot_time_min(a, inf);
+	ok(c == a, "take first finite");
+
+	c = knot_time_min(inf, a);
+	ok(c == a, "take second finite");
+
+	d = knot_time_diff(a + 1, a);
+	ok(d == 1, "positive diff");
+
+	d = knot_time_diff(a, a + 1);
+	ok(d == -1, "negative diff");
+
+	d = knot_time_diff(inf, inf);
+	ok(d == KNOT_TIMEDIFF_MAX, "positive double infty diff");
+
+	d = knot_time_diff(inf, a);
+	ok(d == KNOT_TIMEDIFF_MAX, "positive infty diff");
+
+	d = knot_time_diff(a, inf);
+	ok(d == KNOT_TIMEDIFF_MIN, "negative infty diff");
+}
+
+static void test_time_parse_expect(int ret, knot_time_t res,
+				   knot_time_t expected, const char *msg)
+{
+	ok(ret == 0, "time_parse %s ok", msg);
+	ok(res == expected, "time_parse %s result", msg);
+}
+
+static void test_time_parse(void)
+{
+	knot_time_t res;
+	int ret;
+
+	ret = knot_time_parse("", "", &res);
+	test_time_parse_expect(ret, res, 0, "nihilist");
+
+	ret = knot_time_parse("#", "12345", &res);
+	test_time_parse_expect(ret, res, 12345, "unix");
+
+	ret = knot_time_parse("+-#U", "-1h", &res);
+	test_time_parse_expect(ret, res, knot_time() - 3600, "hour");
+
+	ret = knot_time_parse("+-#u'nths'|+-#u'nutes'", "+1minutes", &res);
+	test_time_parse_expect(ret, res, knot_time() + 60, "minute");
+}
+
+static void test_time_print_expect(int ret, const char *res, int res_len,
+				   const char *expected, const char *msg)
+{
+	ok(ret == 0, "time_print %s ok", msg);
+	ok(strncmp(res, expected, res_len) == 0, "time_print %s result", msg);
+}
+
+static void test_time_print(void)
+{
+	char buff[100];
+	int bufl = sizeof(buff);
+	int ret;
+	knot_time_t t = 44000, t2, big;
+
+	ret = knot_time_print(TIME_PRINT_UNIX, t, buff, bufl);
+	test_time_print_expect(ret, buff, bufl, "44000", "unix");
+
+	t2 = knot_time_add(knot_time(), -10000);
+	ret = knot_time_print(TIME_PRINT_RELSEC, t2, buff, bufl);
+	test_time_print_expect(ret, buff, bufl, "-10000", "relsec");
+
+	ret = knot_time_print(TIME_PRINT_ISO8601, t, buff, bufl);
+	buff[11] = '0', buff[12] = '0'; // zeroing 'hours' field to avoid locality issues
+	test_time_print_expect(ret, buff, bufl, "1970-01-01T00:13:20Z", "iso");
+
+	t2 = knot_time_add(knot_time(), -10000);
+	ret = knot_time_print(TIME_PRINT_HUMAN_MIXED, t2, buff, bufl);
+	test_time_print_expect(ret, buff, bufl, "-2h46m40s", "negative human mixed");
+	big = knot_time_add(knot_time(), 2 * 365 * 24 * 3600 + 1);
+	ret = knot_time_print(TIME_PRINT_HUMAN_MIXED, big, buff, bufl);
+	test_time_print_expect(ret, buff, bufl, "+2Y1s", "big human mixed");
+
+	t2 = knot_time_add(knot_time(), -10000);
+	ret = knot_time_print(TIME_PRINT_HUMAN_LOWER, t2, buff, bufl);
+	test_time_print_expect(ret, buff, bufl, "-2h46mi40s", "negative human lower");
+	big = knot_time_add(knot_time(), 2 * 365 * 24 * 3600 + 1);
+	ret = knot_time_print(TIME_PRINT_HUMAN_LOWER, big, buff, bufl);
+	test_time_print_expect(ret, buff, bufl, "+2y1s", "big human lower");
+}
+
+int main(int argc, char *argv[])
+{
+	plan_lazy();
+
+	test_now();
+	test_diff();
+	test_diff_ms();
+	test_knot_time();
+	test_time_parse();
+	test_time_print();
+
+	return 0;
+}
diff --git a/tests/contrib/test_wire_ctx.c b/tests/contrib/test_wire_ctx.c
new file mode 100644
index 0000000..93456c3
--- /dev/null
+++ b/tests/contrib/test_wire_ctx.c
@@ -0,0 +1,287 @@
+/*  Copyright (C) 2015 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz>
+
+    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/>.
+*/
+
+#include <tap/basic.h>
+#include <netinet/in.h>
+#include <stdio.h>
+
+#include "libknot/errcode.h"
+#include "contrib/wire_ctx.h"
+
+#define OK(wire) { \
+	is_int(KNOT_EOK, (wire)->error, "check for no error"); \
+}
+
+#define NOK(wire, code) { \
+	is_int(code, (wire)->error, "check for error"); \
+}
+
+void ok_offset(wire_ctx_t *wire, size_t max, size_t i)
+{
+	wire_ctx_set_offset(wire, i);
+	OK(wire);
+	is_int(max - i, wire_ctx_available(wire), "get available %zu", max - i);
+	OK(wire);
+	is_int(i, wire_ctx_offset(wire), "get start position %zu", i);
+	OK(wire);
+}
+
+void nok_offset(wire_ctx_t *wire, size_t max)
+{
+	wire_ctx_set_offset(wire, max);
+	OK(wire);
+	wire_ctx_set_offset(wire, max + 1);
+	NOK(wire, KNOT_ERANGE);
+	is_int(0, wire_ctx_available(wire), "get available %i", 0);
+	NOK(wire, KNOT_ERANGE);
+	is_int(max, wire_ctx_offset(wire), "get last start position %zu", max);
+	NOK(wire, KNOT_ERANGE);
+}
+
+void offset_test(void)
+{
+	diag("offset operation");
+
+	const size_t LEN = 3;
+	uint8_t data[LEN];
+
+	wire_ctx_t wire = wire_ctx_init(data, sizeof(data));
+
+	// First free byte.
+	ok_offset(&wire, LEN, 0);
+	// Last free byte.
+	ok_offset(&wire, LEN, 2);
+	// First non-free byte.
+	ok_offset(&wire, LEN, 3);
+	// Invalid offset.
+	nok_offset(&wire, LEN);
+}
+
+void skip_test(void)
+{
+	diag("skip operation");
+
+	uint8_t data[3];
+
+	// Forward skips.
+
+	wire_ctx_t wire = wire_ctx_init(data, sizeof(data));
+
+	wire_ctx_skip(&wire, 2);
+	OK(&wire);
+	is_int(2, wire_ctx_offset(&wire), "skip by offset %i", 2);
+
+	wire_ctx_skip(&wire, 1);
+	OK(&wire);
+	is_int(3, wire_ctx_offset(&wire), "skip by offset %i", 1);
+
+	// Out-of-bounds skip.
+	wire_ctx_skip(&wire, 1);
+	NOK(&wire, KNOT_ERANGE);
+	is_int(3, wire_ctx_offset(&wire), "out-of-bounds skip by %i", 1);
+
+	// Backward skips.
+
+	wire = wire_ctx_init(data, sizeof(data));
+
+	wire_ctx_set_offset(&wire, 3);
+	OK(&wire);
+
+	wire_ctx_skip(&wire, -2);
+	OK(&wire);
+	is_int(1, wire_ctx_offset(&wire), "skip by offset %i", -2);
+
+	wire_ctx_skip(&wire, -1);
+	OK(&wire);
+	is_int(0, wire_ctx_offset(&wire), "skip by offset %i", -1);
+
+	// Out-of-bounds skip.
+	wire_ctx_skip(&wire, -1);
+	NOK(&wire, KNOT_ERANGE);
+	is_int(0, wire_ctx_offset(&wire), "out-of-bounds skip by %i", -1);
+}
+
+void clear_test(void)
+{
+	diag("clear operation");
+
+	uint8_t data[] = { 1, 2, 3 };
+
+	wire_ctx_t wire = wire_ctx_init(data, sizeof(data));
+
+	wire_ctx_clear(&wire, 10);
+	NOK(&wire, KNOT_ESPACE);
+	is_int(1, data[0], "no attempt to clear");
+
+	wire = wire_ctx_init(data, sizeof(data));
+	wire_ctx_clear(&wire, 3);
+	OK(&wire);
+	is_int(0, wire_ctx_available(&wire), "no space available");
+	for (int i = 0; i < sizeof(data); i++) {
+		is_int(0, data[i], "wire position %i is zero", i);
+	}
+}
+
+#define check_rw(size, value, ...) { \
+	const uint8_t expect[] = { __VA_ARGS__ }; \
+	uint8_t data[sizeof(expect)] = { 0 }; \
+	\
+	wire_ctx_t wire = wire_ctx_init(data, sizeof(data)); \
+	\
+	wire_ctx_write_u ## size(&wire, value); \
+	OK(&wire); \
+	ok(memcmp(data, expect, sizeof(expect)) == 0, "write %i value", size); \
+	is_int(size/8, wire_ctx_offset(&wire), "write %i offset", size); \
+	\
+	wire_ctx_set_offset(&wire, 0); \
+	OK(&wire); \
+	\
+	uint64_t num = wire_ctx_read_u ## size(&wire); \
+	OK(&wire); \
+	is_int(value, num, "read %i value", size); \
+	is_int(size/8, wire_ctx_offset(&wire), "read %i offset", size); \
+}
+
+#define check_general_rw(...) { \
+	const uint8_t expect[] = { __VA_ARGS__ }; \
+	uint8_t data[sizeof(expect)] = { 0 }; \
+	\
+	wire_ctx_t wire = wire_ctx_init(data, sizeof(data)); \
+	\
+	wire_ctx_write(&wire, expect, sizeof(expect)); \
+	OK(&wire); \
+	ok(memcmp(data, expect, sizeof(expect)) == 0, "write value"); \
+	is_int(sizeof(expect), wire_ctx_offset(&wire), "write offset"); \
+	\
+	wire_ctx_set_offset(&wire, 0); \
+	OK(&wire); \
+	\
+	uint8_t d[sizeof(expect)] = { 0 }; \
+	wire_ctx_read(&wire, d, sizeof(expect)); \
+	OK(&wire); \
+	ok(memcmp(d, expect, sizeof(expect)) == 0, "read value"); \
+	is_int(sizeof(expect), wire_ctx_offset(&wire), "read offset"); \
+}
+
+void read_write_test(void)
+{
+	diag("read and write operation");
+
+	check_rw( 8, 0x11,               0x11);
+	check_rw(16, 0x1122,             0x11, 0x22);
+	check_rw(32, 0x11223344,         0x11, 0x22, 0x33, 0x44);
+	check_rw(48, 0x112233445566,     0x11, 0x22, 0x33, 0x44, 0x55, 0x66);
+	check_rw(64, 0x1122334455667788, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88);
+
+	check_general_rw(0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x10);
+}
+
+#define check_rw_over(size) { \
+	uint8_t data[1] = { 0 }; \
+	\
+	wire_ctx_t wire = wire_ctx_init(data, sizeof(data)); \
+	wire_ctx_set_offset(&wire, 1); \
+	OK(&wire); \
+	\
+	wire_ctx_write_u ## size(&wire, 0); \
+	NOK(&wire, KNOT_ESPACE); \
+	is_int(1, wire_ctx_offset(&wire), "err write %i offset", size); \
+	\
+	wire = wire_ctx_init(data, sizeof(data)); \
+	wire_ctx_set_offset(&wire, 1); \
+	OK(&wire); \
+	\
+	uint64_t num = wire_ctx_read_u ## size(&wire); \
+	NOK(&wire, KNOT_EFEWDATA); \
+	is_int(0, num, "err read %i value", size); \
+	is_int(1, wire_ctx_offset(&wire), "err read %i offset", size); \
+}
+
+#define check_general_rw_over(void) { \
+	uint8_t data[1] = { 0 }; \
+	uint8_t d[2] = { 0 }; \
+	\
+	wire_ctx_t wire = wire_ctx_init(data, sizeof(data)); \
+	wire_ctx_write(&wire, d, sizeof(d)); \
+	NOK(&wire, KNOT_ESPACE); \
+	is_int(0, wire_ctx_offset(&wire), "err write offset"); \
+	\
+	wire = wire_ctx_init(data, sizeof(data)); \
+	wire_ctx_read(&wire, d, sizeof(d)); \
+	NOK(&wire, KNOT_EFEWDATA); \
+	is_int(0, wire_ctx_offset(&wire), "err read offset"); \
+}
+
+void read_write_overflow_test(void)
+{
+	diag("overflow read and write operation");
+
+	check_rw_over(8);
+	check_rw_over(16);
+	check_rw_over(32);
+	check_rw_over(48);
+	check_rw_over(64);
+
+	check_general_rw_over();
+}
+
+#define check_ro(size) { \
+	uint8_t data[8] = { 0 }; \
+	\
+	wire_ctx_t wire = wire_ctx_init_const(data, sizeof(data)); \
+	\
+	wire_ctx_write_u ## size(&wire, 0); \
+	NOK(&wire, KNOT_EACCES); \
+	is_int(0, wire_ctx_offset(&wire), "err write %i offset", size); \
+}
+
+#define check_general_ro(void) { \
+	uint8_t data[8] = { 0 }; \
+	uint8_t d[2] = { 0 }; \
+	\
+	wire_ctx_t wire = wire_ctx_init_const(data, sizeof(data)); \
+	\
+	wire_ctx_write(&wire, d, sizeof(d)); \
+	NOK(&wire, KNOT_EACCES); \
+	is_int(0, wire_ctx_offset(&wire), "err write offset"); \
+}
+
+void write_readonly_test(void)
+{
+	diag("readonly write operation");
+
+	check_ro(8);
+	check_ro(16);
+	check_ro(32);
+	check_ro(48);
+	check_ro(64);
+
+	check_general_ro();
+}
+
+int main(void)
+{
+	plan_lazy();
+
+	offset_test();
+	skip_test();
+	clear_test();
+	read_write_test();
+	read_write_overflow_test();
+	write_readonly_test();
+
+	return 0;
+}