Fix windows compile issues.

Implemented a simlpe red-black tree which should give better performance
for certain lookups. The rb_tree will act as a general purpose key/value storage, and also give a performance boost in the cases where the other simple alternative would be to use a linked_list. On average this should give on average O(log n) lookups, while the linked_list would be O(n) at worst.
2012-11-01 21:52:33 +01:00 · 2012-11-01 21:46:44 +01:00 · 2012-11-01 21:18:49 +01:00 · 2012-11-01 21:10:51 +01:00 · 2012-11-01 10:42:19 +01:00 · 2012-11-01 10:40:51 +01:00
30 changed files with 3121 additions and 288 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,7 +17,7 @@ set (PROJECT_SOURCE_DIR "${CMAKE_SOURCE_DIR}/src")
 option(RELEASE "Release build, debug build if disabled" ON)
 option(LINK_SUPPORT "Allow hub linking" OFF)
 option(SSL_SUPPORT "Enable SSL support" ON)
-option(USE_OPENSSL "Use OpenSSL's SSL support" OFF)
+option(USE_OPENSSL "Use OpenSSL's SSL support" ON )
 option(SQLITE_SUPPORT "Enable SQLite support" ON)
 option(ADC_STRESS "Enable the stress tester client" OFF)

@@ -40,57 +40,15 @@ endif()

 include_directories("${PROJECT_SOURCE_DIR}")

-set (network_SOURCES
-	${PROJECT_SOURCE_DIR}/network/backend.c
-	${PROJECT_SOURCE_DIR}/network/connection.c
-	${PROJECT_SOURCE_DIR}/network/epoll.c
-	${PROJECT_SOURCE_DIR}/network/kqueue.c
-	${PROJECT_SOURCE_DIR}/network/select.c
-	${PROJECT_SOURCE_DIR}/network/timeout.c
-	${PROJECT_SOURCE_DIR}/network/timer.c
-	${PROJECT_SOURCE_DIR}/network/network.c
-	${PROJECT_SOURCE_DIR}/network/openssl.c
-	${PROJECT_SOURCE_DIR}/network/ipcalc.c
+file (GLOB uhub_SOURCES ${PROJECT_SOURCE_DIR}/core/*.c)
+list (REMOVE_ITEM uhub_SOURCES
+	${PROJECT_SOURCE_DIR}/core/gen_config.c
+	${PROJECT_SOURCE_DIR}/core/main.c
 )

-set (uhub_SOURCES
-	${PROJECT_SOURCE_DIR}/core/auth.c
-	${PROJECT_SOURCE_DIR}/core/command_parser.c
-	${PROJECT_SOURCE_DIR}/core/commands.c
-	${PROJECT_SOURCE_DIR}/core/config.c
-	${PROJECT_SOURCE_DIR}/core/eventqueue.c
-	${PROJECT_SOURCE_DIR}/core/hub.c
-	${PROJECT_SOURCE_DIR}/core/hubevent.c
-	${PROJECT_SOURCE_DIR}/core/inf.c
-	${PROJECT_SOURCE_DIR}/core/ioqueue.c
-	${PROJECT_SOURCE_DIR}/core/netevent.c
-	${PROJECT_SOURCE_DIR}/core/probe.c
-	${PROJECT_SOURCE_DIR}/core/route.c
-	${PROJECT_SOURCE_DIR}/core/user.c
-	${PROJECT_SOURCE_DIR}/core/usermanager.c
-	${PROJECT_SOURCE_DIR}/core/plugincallback.c
-	${PROJECT_SOURCE_DIR}/core/plugininvoke.c
-	${PROJECT_SOURCE_DIR}/core/pluginloader.c
-)
-
-set (adc_SOURCES
-	${PROJECT_SOURCE_DIR}/adc/message.c
-	${PROJECT_SOURCE_DIR}/adc/sid.c
-)
-
-set (utils_SOURCES
-	${PROJECT_SOURCE_DIR}/util/cbuffer.c
-	${PROJECT_SOURCE_DIR}/util/config_token.c
-	${PROJECT_SOURCE_DIR}/util/credentials.c
-	${PROJECT_SOURCE_DIR}/util/floodctl.c
-	${PROJECT_SOURCE_DIR}/util/getopt.c
-	${PROJECT_SOURCE_DIR}/util/list.c
-	${PROJECT_SOURCE_DIR}/util/log.c
-	${PROJECT_SOURCE_DIR}/util/memory.c
-	${PROJECT_SOURCE_DIR}/util/misc.c
-	${PROJECT_SOURCE_DIR}/util/rbtree.c
-	${PROJECT_SOURCE_DIR}/util/tiger.c
-)
+file (GLOB adc_SOURCES ${PROJECT_SOURCE_DIR}/adc/*.c)
+file (GLOB network_SOURCES ${PROJECT_SOURCE_DIR}/network/*.c)
+file (GLOB utils_SOURCES ${PROJECT_SOURCE_DIR}/util/*.c)

 set (adcclient_SOURCES
 	${PROJECT_SOURCE_DIR}/tools/adcclient.c
@@ -100,36 +58,38 @@ set (adcclient_SOURCES
 add_library(adc       STATIC ${adc_SOURCES})
 add_library(network   STATIC ${network_SOURCES})
 add_library(utils     STATIC ${utils_SOURCES})
-
+if(CMAKE_COMPILER_IS_GNUCC)
+	set_target_properties(utils PROPERTIES COMPILE_FLAGS -fPIC)
+	set_target_properties(network PROPERTIES COMPILE_FLAGS -fPIC)
+endif()

 add_dependencies(adc utils)
 add_dependencies(network utils)

 add_executable(uhub ${PROJECT_SOURCE_DIR}/core/main.c ${uhub_SOURCES} )
+add_executable(test ${CMAKE_SOURCE_DIR}/autotest/test.c ${uhub_SOURCES} )

-add_library(mod_example MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_example.c ${utils_SOURCES})
-add_library(mod_welcome MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_welcome.c ${utils_SOURCES} ${network_SOURCES})
-add_library(mod_logging MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_logging.c ${utils_SOURCES} ${PROJECT_SOURCE_DIR}/adc/sid.c ${network_SOURCES})
-add_library(mod_auth_simple MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_auth_simple.c ${utils_SOURCES})
-add_library(mod_chat_history MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_chat_history.c ${utils_SOURCES})
-add_library(mod_chat_only MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_chat_only.c ${utils_SOURCES})
-add_library(mod_topic MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_topic.c ${utils_SOURCES})
+add_library(mod_example MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_example.c)
+add_library(mod_welcome MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_welcome.c)
+add_library(mod_logging MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_logging.c ${PROJECT_SOURCE_DIR}/adc/sid.c)
+add_library(mod_auth_simple MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_auth_simple.c )
+add_library(mod_chat_history MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_chat_history.c )
+add_library(mod_chat_only MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_chat_only.c)
+add_library(mod_topic MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_topic.c)

 if (SQLITE_SUPPORT)
-	add_library(mod_auth_sqlite MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_auth_sqlite.c ${utils_SOURCES})
-	add_executable(uhub-passwd ${PROJECT_SOURCE_DIR}/tools/uhub-passwd.c ${PROJECT_SOURCE_DIR}/util/misc.c ${PROJECT_SOURCE_DIR}/util/memory.c ${PROJECT_SOURCE_DIR}/util/log.c ${PROJECT_SOURCE_DIR}/util/list.c)
+	add_library(mod_auth_sqlite MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_auth_sqlite.c)
+	add_executable(uhub-passwd ${PROJECT_SOURCE_DIR}/tools/uhub-passwd.c)

-	target_link_libraries(mod_auth_sqlite sqlite3)
-	target_link_libraries(uhub-passwd sqlite3)
+	target_link_libraries(mod_auth_sqlite sqlite3 utils)
+	target_link_libraries(uhub-passwd sqlite3 utils)
 	set_target_properties(mod_auth_sqlite PROPERTIES PREFIX "")
-
-	if (UNIX)
-		target_link_libraries(uhub pthread)
-	endif()
 endif()

+
 if(WIN32)
 	target_link_libraries(uhub ws2_32)
+	target_link_libraries(test ws2_32)
 	target_link_libraries(mod_logging ws2_32)
 	target_link_libraries(mod_welcome ws2_32)
 endif()
@@ -145,25 +105,48 @@ set_target_properties(
 	PROPERTIES PREFIX "")

 target_link_libraries(uhub ${CMAKE_DL_LIBS} adc network utils)
+target_link_libraries(test ${CMAKE_DL_LIBS} adc network utils)
+target_link_libraries(mod_example utils)
+target_link_libraries(mod_welcome utils)
+target_link_libraries(mod_auth_simple utils)
+target_link_libraries(mod_chat_history utils)
+target_link_libraries(mod_chat_only utils)
+target_link_libraries(mod_logging utils)
+target_link_libraries(mod_topic utils)
+target_link_libraries(utils network)
+target_link_libraries(mod_welcome network)
+target_link_libraries(mod_logging network)

 if(UNIX)
 	add_library(adcclient STATIC ${adcclient_SOURCES})
 	add_executable(uhub-admin ${PROJECT_SOURCE_DIR}/tools/admin.c)
-	target_link_libraries(uhub-admin adcclient adc network utils)
+	target_link_libraries(uhub-admin adcclient adc network utils pthread)
+	target_link_libraries(uhub pthread)
+	target_link_libraries(test pthread)

 	if (ADC_STRESS)
 		add_executable(adcrush ${PROJECT_SOURCE_DIR}/tools/adcrush.c ${adcclient_SOURCES})
-		target_link_libraries(adcrush adcclient adc network utils)
+		target_link_libraries(adcrush adcclient adc network utils pthread)
 	endif()
 endif()

-if(GIT_FOUND AND IS_DIRECTORY ".git")
-	execute_process(COMMAND ${GIT_EXECUTABLE} show -s --pretty=format:%h OUTPUT_VARIABLE UHUB_REVISION)
-	set (UHUB_GIT_VERSION "${UHUB_VERSION_MAJOR}.${UHUB_VERSION_MINOR}.${UHUB_VERSION_PATCH}-git-${UHUB_REVISION}")
-else()
-	set (UHUB_GIT_VERSION "${UHUB_VERSION_MAJOR}.${UHUB_VERSION_MINOR}.${UHUB_VERSION_PATCH}-release")
+if (NOT UHUB_REVISION AND GIT_FOUND)
+	execute_process(COMMAND ${GIT_EXECUTABLE} show -s --pretty=format:%h
+					WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+					OUTPUT_VARIABLE UHUB_REVISION_TEMP
+					OUTPUT_STRIP_TRAILING_WHITESPACE)
+	if (UHUB_REVISION_TEMP)
+		set (UHUB_REVISION "git-${UHUB_REVISION_TEMP}")
+	endif()
 endif()

+if (NOT UHUB_REVISION)
+	set (UHUB_REVISION "release")
+endif()
+
+set (UHUB_GIT_VERSION "${UHUB_VERSION_MAJOR}.${UHUB_VERSION_MINOR}.${UHUB_VERSION_PATCH}-${UHUB_REVISION}")
+message (STATUS "Configuring uhub version: ${UHUB_GIT_VERSION}")
+
 if(OPENSSL_FOUND)
 	set(SSL_LIBS ${OPENSSL_LIBRARIES})
 	add_definitions(-DSSL_SUPPORT=1 -DSSL_USE_OPENSSL=1)
@@ -178,6 +161,7 @@ endif()

 if(SSL_SUPPORT)
 	target_link_libraries(uhub ${SSL_LIBS})
+	target_link_libraries(test ${SSL_LIBS})
 	if(UNIX)
 		target_link_libraries(uhub-admin ${SSL_LIBS})
 	endif()
@@ -200,8 +184,8 @@ endif()

 if (UNIX)
 	install( TARGETS uhub RUNTIME DESTINATION bin )
-	install( TARGETS mod_example mod_welcome mod_logging mod_auth_simple mod_auth_sqlite mod_chat_history mod_chat_only mod_topic DESTINATION /var/lib/uhub/ OPTIONAL )
-	install( FILES ${CMAKE_SOURCE_DIR}/uhub.conf ${CMAKE_SOURCE_DIR}/plugins.conf ${CMAKE_SOURCE_DIR}/rules.txt ${CMAKE_SOURCE_DIR}/motd.txt DESTINATION /etc/uhub OPTIONAL )
+	install( TARGETS mod_example mod_welcome mod_logging mod_auth_simple mod_auth_sqlite mod_chat_history mod_chat_only mod_topic DESTINATION /usr/lib/uhub/ OPTIONAL )
+	install( FILES ${CMAKE_SOURCE_DIR}/doc/uhub.conf ${CMAKE_SOURCE_DIR}/doc/plugins.conf ${CMAKE_SOURCE_DIR}/doc/rules.txt ${CMAKE_SOURCE_DIR}/doc/motd.txt DESTINATION /etc/uhub OPTIONAL )

 	if (SQLITE_SUPPORT)
 		install( TARGETS uhub-passwd RUNTIME DESTINATION bin )
@@ -209,6 +193,3 @@ if (UNIX)
 endif()


-
-
- 
--- a/autotest/exotic
+++ b/autotest/exotic
@@ -0,0 +1,372 @@
+#!/usr/bin/perl -w
+# exotic 0.4
+# Copyright (c) 2007-2012, Jan Vidar Krey
+
+use strict;
+
+my $program = $0;
+my $file;
+my $line;
+my @tests;
+my $found;
+my $test;
+my @files;
+
+if ($#ARGV == -1)
+{
+	die "Usage: $program files\n";
+}
+
+my $version = "0.4";
+
+foreach my $arg (@ARGV)
+{
+	push(@files, $arg);
+}
+
+
+print "/* THIS FILE IS AUTOMATICALLY GENERATED BY EXOTIC - DO NOT EDIT THIS FILE! */\n";
+print "/* exotic/$version (Mon Nov  7 11:15:31 CET 2011) */\n\n";
+
+print "#define __EXOTIC__STANDALONE__\n";
+standalone_include_exotic_h();
+
+if ($#ARGV >= 0)
+{
+	foreach $file (@ARGV)
+	{
+		$found = 0;
+		open( FILE, "$file") || next;
+		my @data = <FILE>;
+		my $comment = 0;
+	
+		foreach $line (@data) {
+			chomp($line);
+		
+			if ($comment == 1)
+			{
+				if ($line =~ /^(.*\*\/)(.*)/)
+				{
+					$line = $2;
+					$comment = 0;
+				}
+				else
+				{
+					next; # ignore comment data
+				}
+			}
+		
+			if ($line =~ /^(.*)\/\*(.*)\*\/(.*)$/)
+			{
+				$line = $1 . " " . $3; # exclude comment stuff in between "/*" and "*/".
+			}
+	
+			if ($line =~ /^(.*)(\/\/.*)$/) {
+				$line = $1; # exclude stuff after "//" (FIXME: does not work if they are inside a string)
+			}
+		
+			if ($line =~ /\/\*/) {
+				$comment = 1;
+				next;
+			}
+	
+			if ($line =~ /^\s*EXO_TEST\(\s*(\w+)\s*,/)
+			{
+				$found++;
+				push(@tests, $1);
+			}
+		}
+	
+		if ($found > 0) {
+			print "#include \"" . $file . "\"\n";
+		}
+	
+		close(FILE);
+	}
+	print "\n";
+}
+
+# Write a main() that will start the test run
+print "int main(int argc, char** argv)\n{\n";
+print "\tstruct exotic_handle handle;\n\n";
+print "\tif (exotic_initialize(&handle, argc, argv) == -1)\n\t\treturn -1;\n\n";
+
+if ($#tests > 0)
+{
+	print "\t/* Register the tests to be run */\n";
+	foreach $test (@tests)
+	{
+		print "\texotic_add_test(&handle, &exotic_test_" . $test . ", \"" . $test . "\");\n";
+	}
+}
+else
+{
+	print "\t/* No tests are found! */\n";
+}
+
+print "\n";
+print "\treturn exotic_run(&handle);\n";
+print "}\n\n";
+
+
+standalone_include_exotic_c();
+
+sub standalone_include_exotic_h {
+print '
+/*
+ * Exotic (EXtatic.Org Test InfrastuCture)
+ * Copyright (c) 2007, Jan Vidar Krey
+ */
+
+#ifndef EXO_TEST
+#define EXO_TEST(NAME, block) int exotic_test_ ## NAME (void) block
+#endif
+
+#ifndef HAVE_EXOTIC_AUTOTEST_H
+#define HAVE_EXOTIC_AUTOTEST_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef int(*exo_test_t)();
+
+enum exo_toggle { cfg_default, cfg_off, cfg_on };
+
+struct exotic_handle
+{
+	enum exo_toggle config_show_summary;
+	enum exo_toggle config_show_pass;
+	enum exo_toggle config_show_fail;
+	unsigned int fail;
+	unsigned int pass;
+	struct exo_test_data* first;
+	struct exo_test_data* current;
+};
+
+extern int  exotic_initialize(struct exotic_handle* handle, int argc, char** argv);
+extern void exotic_add_test(struct exotic_handle* handle, exo_test_t, const char* name);
+extern int  exotic_run(struct exotic_handle* handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* HAVE_EXOTIC_AUTOTEST_H */
+
+'; }
+sub standalone_include_exotic_c {
+print '
+/*
+ * Exotic - C/C++ source code testing
+ * Copyright (c) 2007, Jan Vidar Krey
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static void exotic_version();
+
+#ifndef __EXOTIC__STANDALONE__
+#include "autotest.h"
+static void exotic_version()
+{
+	printf("Extatic.org Test Infrastructure: exotic " "${version}" "\n\n");
+	printf("Copyright (C) 2007 Jan Vidar Krey, janvidar@extatic.org\n");
+	printf("This is free software with ABSOLUTELY NO WARRANTY.\n\n");
+}
+#endif
+
+struct exo_test_data
+{
+	exo_test_t test;
+	char* name;
+	struct exo_test_data* next;
+};
+
+
+static void exotic_summary(struct exotic_handle* handle)
+{
+	int total     = handle->pass + handle->fail;
+	int pass_rate = total ? (100*handle->pass / total) : 0;
+	int fail_rate = total ? (100*handle->fail / total) : 0;
+	
+	printf("\n");
+	printf("--------------------------------------------\n");
+	printf("Results:\n");
+	printf(" * Total tests run:  %8d\n", total);
+	printf(" * Tests passed:     %8d (~%d%%)\n", (int) handle->pass, pass_rate);
+	printf(" * Tests failed:     %8d (~%d%%)\n", (int) handle->fail, fail_rate);
+	printf("--------------------------------------------\n");
+}
+
+
+static void exotic_help(const char* program)
+{
+	printf("Usage: %s [OPTIONS]\n\n", program);
+	printf("Options:\n");
+	printf("  --help      -h    Show this message\n");
+	printf("  --version   -v    Show version\n");
+	printf("  --summary   -s    show only summary)\n");
+	printf("  --fail      -f    show only test failures\n");
+	printf("  --pass      -p    show only test passes\n");
+	printf("\nExamples:\n");
+	printf("  %s -s -f\n\n", program);
+}
+
+
+int exotic_initialize(struct exotic_handle* handle, int argc, char** argv)
+{
+	int n;
+	if (!handle || !argv) return -1;
+	
+	memset(handle, 0, sizeof(struct exotic_handle));
+	
+	for (n = 1; n < argc; n++)
+	{
+		if (!strcmp(argv[n], "-h") || !strcmp(argv[n], "--help"))
+		{
+			exotic_help(argv[0]);
+			exit(0);
+		}
+		
+		if (!strcmp(argv[n], "-v") || !strcmp(argv[n], "--version"))
+		{
+			exotic_version();
+			exit(0);
+		}
+		
+		if (!strcmp(argv[n], "-s") || !strcmp(argv[n], "--summary"))
+		{
+			handle->config_show_summary = cfg_on;
+			continue;
+		}
+		
+		if (!strcmp(argv[n], "-f") || !strcmp(argv[n], "--fail"))
+		{
+			handle->config_show_fail = cfg_on;
+			continue;
+		}
+		
+		if (!strcmp(argv[n], "-p") || !strcmp(argv[n], "--pass"))
+		{
+			handle->config_show_pass = cfg_on;
+			continue;
+		}
+		
+		fprintf(stderr, "Unknown argument: %s\n\n", argv[n]);
+		exotic_help(argv[0]);
+		exit(0);
+	}
+	
+	if (handle->config_show_summary == cfg_on)
+	{
+		if (handle->config_show_pass == cfg_default) handle->config_show_pass = cfg_off;
+		if (handle->config_show_fail == cfg_default) handle->config_show_fail = cfg_off;
+	
+	}
+	else if (handle->config_show_pass == cfg_on)
+	{
+		if (handle->config_show_summary == cfg_default) handle->config_show_summary = cfg_off;
+		if (handle->config_show_fail    == cfg_default) handle->config_show_fail = cfg_off;
+	}
+	else if (handle->config_show_fail == cfg_on)
+	{
+		if (handle->config_show_summary == cfg_default) handle->config_show_summary = cfg_off;
+		if (handle->config_show_fail    == cfg_default) handle->config_show_fail = cfg_off;
+	}
+	else
+	{
+		if (handle->config_show_summary == cfg_default) handle->config_show_summary = cfg_on;
+		if (handle->config_show_fail    == cfg_default) handle->config_show_fail = cfg_on;
+		if (handle->config_show_pass    == cfg_default) handle->config_show_pass = cfg_on;
+	}
+	return 0;
+}
+
+
+void exotic_add_test(struct exotic_handle* handle, exo_test_t func, const char* name)
+{
+	struct exo_test_data* test;
+	if (!handle)
+	{
+		fprintf(stderr, "exotic_add_test: failed, no handle!\n");
+		exit(-1);
+	}
+	
+	test = (struct exo_test_data*) malloc(sizeof(struct exo_test_data));
+	if (!test)
+	{
+		fprintf(stderr, "exotic_add_test: out of memory!\n");
+		exit(-1);
+	}
+	
+	/* Create the test */
+	memset(test, 0, sizeof(struct exo_test_data));
+	test->test = func;
+	test->name = strdup(name);
+	
+	/* Register the test in the handle */
+	if (!handle->first)
+	{
+		handle->first = test;
+		handle->current = test;
+	}
+	else
+	{
+		handle->current->next = test;
+		handle->current = test;
+	}
+}
+
+
+int exotic_run(struct exotic_handle* handle)
+{
+	struct exo_test_data* tmp = NULL;
+	
+	if (!handle)
+	{
+		fprintf(stderr, "Error: exotic is not initialized\n");
+		return -1;
+	}
+
+	handle->current = handle->first;
+	while (handle->current)
+	{
+		tmp = handle->current;
+		
+		if (handle->current->test()) {
+			if (handle->config_show_pass == cfg_on) printf("* PASS test \'%s\'\n", tmp->name);
+			handle->pass++;
+		} else {
+			if (handle->config_show_fail == cfg_on) printf("* FAIL test \'%s\'\n", tmp->name);
+			handle->fail++;
+		}
+		
+		handle->current = handle->current->next;
+		
+		free(tmp->name);
+		free(tmp);
+	}
+	
+	if (!handle->first)
+	{
+		printf("(No tests added)\n");
+	}
+	
+	if (handle->config_show_summary == cfg_on)
+		exotic_summary(handle);
+
+	return (handle->fail) ? handle->fail : 0;
+}
+
+
+static void exotic_version() {
+	printf("exotic 0.4-standalone\n\n");
+	printf("Copyright (C) 2007 Jan Vidar Krey, janvidar@extatic.org\n");
+	printf("This is free software with ABSOLUTELY NO WARRANTY.\n\n");
+}
+'; }
+
--- a/autotest/test.c
+++ b/autotest/test.c
--- a/autotest/test_inf.tcc
+++ b/autotest/test_inf.tcc
@@ -12,6 +12,7 @@ extern int hub_handle_info_login(struct hub_info* hub, struct hub_user* user, st

 static void inf_create_hub()
 {
+	net_initialize();
 	inf_hub = (struct hub_info*) hub_malloc_zero(sizeof(struct hub_info));
 	inf_hub->users = (struct hub_user_manager*) hub_malloc_zero(sizeof(struct hub_user_manager));
 	inf_hub->users->list = list_create();
@@ -35,6 +36,7 @@ static void inf_destroy_hub()
 	hub_free(inf_hub->acl);
 	hub_free(inf_hub->config);
 	hub_free(inf_hub);
+	net_destroy();
 }


@@ -63,13 +65,14 @@ EXO_TEST(inf_create_setup,

 /* FIXME: MEMORY LEAK - Need to fix hub_handle_info_login */
 #define CHECK_INF(MSG, EXPECT) \
-	struct adc_message* msg = adc_msg_parse_verify(inf_user, MSG, strlen(MSG)); \
-	int ok = hub_handle_info_login(inf_hub, inf_user, msg); /* FIXME: MEMORY LEAK */ \
-	adc_msg_free(msg); \
-	if (ok == EXPECT) \
-		user_set_info(inf_user, 0); \
-	return ok == EXPECT;
-	
+	do { \
+		struct adc_message* msg = adc_msg_parse_verify(inf_user, MSG, strlen(MSG)); \
+		int ok = hub_handle_info_login(inf_hub, inf_user, msg); /* FIXME: MEMORY LEAK */ \
+		adc_msg_free(msg); \
+		if (ok == EXPECT) \
+			user_set_info(inf_user, 0); \
+		return ok == EXPECT; \
+	} while(0)

 EXO_TEST(inf_ok_1,  { CHECK_INF("BINF AAAB NIFriend IDGNSSMURMD7K466NGZIHU65TP3S3UZSQ6MN5B2RI PD3A4545WFVGZLSGUXZLG7OS6ULQUVG3HM2T63I7Y\n", 0); });

@@ -107,12 +110,15 @@ EXO_TEST(inf_nick_08, { CHECK_INF("BINF AAAB NIa\\nc IDGNSSMURMD7K466NGZIHU65TP3
 EXO_TEST(inf_nick_09, { CHECK_INF("BINF AAAB NIabc NIdef IDGNSSMURMD7K466NGZIHU65TP3S3UZSQ6MN5B2RI PD3A4545WFVGZLSGUXZLG7OS6ULQUVG3HM2T63I7Y\n", status_msg_inf_error_nick_multiple); });
 EXO_TEST(inf_nick_10, {
 	const char* line = "BINF AAAB IDGNSSMURMD7K466NGZIHU65TP3S3UZSQ6MN5B2RI PD3A4545WFVGZLSGUXZLG7OS6ULQUVG3HM2T63I7Y\n";
+	int ok;
 	char nick[10];
+	struct adc_message* msg;
+
 	nick[0] = 0xf7; nick[1] = 0x80; nick[2] = 0x7f; nick[3] = 0x81; nick[4] = 0x98; nick[5] = 0x00;
-	struct adc_message* msg = adc_msg_parse_verify(inf_user, line, strlen(line));
+	msg = adc_msg_parse_verify(inf_user, line, strlen(line));
 	
 	adc_msg_add_named_argument(msg, "NI", nick);
-	int ok = hub_handle_info_login(inf_hub, inf_user, msg);
+	ok = hub_handle_info_login(inf_hub, inf_user, msg);
 	adc_msg_free(msg);
 	if (ok != status_msg_inf_error_nick_not_utf8)
 		printf("Expected %d, got %d\n", status_msg_inf_error_nick_not_utf8, ok);
--- a/autotest/test_ipfilter.tcc
+++ b/autotest/test_ipfilter.tcc
@@ -429,44 +429,51 @@ EXO_TEST(check_ban_ipv4_5, {
 });

 EXO_TEST(check_ban_ipv6_1, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:0", &addr);
+	ip_convert_to_binary("2001::201:2ff:fefa:0", &addr);
 	return ip_in_range(&addr, &ban6);
 });

 EXO_TEST(check_ban_ipv6_2, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:1", &addr);
+	ip_convert_to_binary("2001::201:2ff:fefa:1", &addr);
 	return ip_in_range(&addr, &ban6);
 });

 EXO_TEST(check_ban_ipv6_3, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:fffe", &addr);
+	ip_convert_to_binary("2001::201:2ff:fefa:fffe", &addr);
 	return ip_in_range(&addr, &ban6);
 });

 EXO_TEST(check_ban_ipv6_4, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:ffff", &addr);
+	ip_convert_to_binary("2001::201:2ff:fefa:ffff", &addr);
 	return ip_in_range(&addr, &ban6);
 });

 EXO_TEST(check_ban_ipv6_5, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefb:0", &addr);
+	ip_convert_to_binary("2001::201:2ff:fefb:0", &addr);
 	return !ip_in_range(&addr, &ban6);
 });

 EXO_TEST(check_ban_ipv6_6, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fef9:ffff", &addr);
+	ip_convert_to_binary("2001::201:2ff:fef9:ffff", &addr);
 	return !ip_in_range(&addr, &ban6);
 });

 EXO_TEST(check_ban_afmix_1, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fef9:ffff", &addr);
+	ip_convert_to_binary("2001::201:2ff:fef9:ffff", &addr);
 	return !ip_in_range(&addr, &ban4);
 });

@@ -610,8 +617,10 @@ EXO_TEST(ip_range_3, {
 });

 EXO_TEST(ip_range_4, {
-	struct ip_range range1; memset(&range1, 0, sizeof(range1));
-	struct ip_range range2; memset(&range2, 0, sizeof(range2));
+	struct ip_range range1;
+	struct ip_range range2;
+	memset(&range1, 0, sizeof(range1));
+	memset(&range2, 0, sizeof(range2));
 	return ip_convert_address_to_range("192.168.0.0/16", &range1) && ip_convert_address_to_range("192.168.0.0-192.168.255.255", &range2) && memcmp(&range1, &range2, sizeof(struct ip_range)) == 0;
 });

--- a/autotest/test_message.tcc
+++ b/autotest/test_message.tcc
@@ -174,91 +174,102 @@ EXO_TEST(adc_message_parse_24, {


 EXO_TEST(adc_message_add_arg_1, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_add_argument(msg, "XXwtf?");
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat XXwtf?\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat XXwtf?\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_add_arg_2, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_add_named_argument(msg, "XX", "wtf?");
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat XXwtf?\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat XXwtf?\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_remove_arg_1, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "AA");
-	int ok = strcmp(msg->cache, "IINF BBbar CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF BBbar CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_remove_arg_2, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "BB");
-	int ok = strcmp(msg->cache, "IINF AAfoo CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_remove_arg_3, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "CC");
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_remove_arg_4, {
 	/* this ensures we can remove the last element also */
+	int ok;
 	struct adc_message* msg = adc_msg_parse_verify(g_user, test_string3, strlen(test_string3));
 	adc_msg_remove_named_argument(msg, "AW");
-	int ok = strcmp(msg->cache, "BINF AAAB IDAN7ZMSLIEBL53OPTM7WXGSTXUS3XOY6KQS5LBGX NIFriend DEstuff SL3 SS0 SF0 VEQuickDC/0.4.17 US6430 SUADC0,TCP4,UDP4 I4127.0.0.1 HO5 HN1\n") == 0;
+	ok = strcmp(msg->cache, "BINF AAAB IDAN7ZMSLIEBL53OPTM7WXGSTXUS3XOY6KQS5LBGX NIFriend DEstuff SL3 SS0 SF0 VEQuickDC/0.4.17 US6430 SUADC0,TCP4,UDP4 I4127.0.0.1 HO5 HN1\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_replace_arg_1, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "AA");
-	int ok = strcmp(msg->cache, "IINF BBbar CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF BBbar CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_replace_arg_2, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "BB");
-	int ok = strcmp(msg->cache, "IINF AAfoo CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_replace_arg_3, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "CC");
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_get_arg_1, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	char* c = adc_msg_get_argument(msg, 0);
-	int ok = strcmp(c, "AAfoo") == 0;
+	ok = strcmp(c, "AAfoo") == 0;
 	adc_msg_free(msg);
 	hub_free(c);
 	return ok;
 });

 EXO_TEST(adc_message_get_arg_2, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	char* c = adc_msg_get_argument(msg, 1);
-	int ok = strcmp(c, "BBbar") == 0;
+	ok = strcmp(c, "BBbar") == 0;
 	adc_msg_free(msg);
 	hub_free(c);
 	return ok;
@@ -340,28 +351,31 @@ EXO_TEST(adc_message_has_named_arg_3, {
 });

 EXO_TEST(adc_message_has_named_arg_4, {
+	int n;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_add_argument(msg, "XXwtf?");
-	int n = adc_msg_has_named_argument(msg, "XX");
+	n = adc_msg_has_named_argument(msg, "XX");
 	adc_msg_free(msg);
 	return n == 1;
 });

 EXO_TEST(adc_message_has_named_arg_5, {
+	int n;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_add_argument(msg, "XXone");
 	adc_msg_add_argument(msg, "XXtwo");
-	int n = adc_msg_has_named_argument(msg, "XX");
+	n = adc_msg_has_named_argument(msg, "XX");
 	adc_msg_free(msg);
 	return n == 2;
 });

 EXO_TEST(adc_message_has_named_arg_6, {
+	int n;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_add_argument(msg, "XXone");
 	adc_msg_add_argument(msg, "XXtwo");
 	adc_msg_add_argument(msg, "XXthree");
-	int n = adc_msg_has_named_argument(msg, "XX");
+	n = adc_msg_has_named_argument(msg, "XX");
 	adc_msg_free(msg);
 	return n == 3;
 });
@@ -374,63 +388,70 @@ EXO_TEST(adc_message_has_named_arg_7, {
 });

 EXO_TEST(adc_message_terminate_1, {
+	int ok;
 	struct adc_message* msg = adc_msg_create("IINF AAfoo BBbar CCwhat");
 	adc_msg_unterminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_terminate_2, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_unterminate(msg);
 	adc_msg_terminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_terminate_3, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_unterminate(msg);
 	adc_msg_terminate(msg);
 	adc_msg_unterminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_terminate_4, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_unterminate(msg);
 	adc_msg_terminate(msg);
 	adc_msg_terminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_terminate_5, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_terminate(msg);
 	adc_msg_terminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_terminate_6, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_unterminate(msg);
 	adc_msg_unterminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
 	adc_msg_free(msg);
 	return ok;
 });

 EXO_TEST(adc_message_escape_1, {
+	int ok;
 	char* s = adc_msg_escape(test_string1);
-	int ok = strcmp(s, "IINF\\sAAfoo\\sBBbar\\sCCwhat\\n") == 0;
+	ok = strcmp(s, "IINF\\sAAfoo\\sBBbar\\sCCwhat\\n") == 0;
 	hub_free(s);
 	return ok;
 });
--- a/autotest/test_misc.tcc
+++ b/autotest/test_misc.tcc
@@ -97,15 +97,25 @@ EXO_TEST(base32_invalid_31, { return !is_valid_base32_char('@'); });
 EXO_TEST(utf8_valid_1, { return is_valid_utf8("abcdefghijklmnopqrstuvwxyz"); });
 EXO_TEST(utf8_valid_2, { return is_valid_utf8("ABCDEFGHIJKLMNOPQRSTUVWXYZ"); });
 EXO_TEST(utf8_valid_3, { return is_valid_utf8("0123456789"); });
-EXO_TEST(utf8_valid_4, { return is_valid_utf8( (char[]) { 0x65, 0x00} ); });
-EXO_TEST(utf8_valid_5, { return !is_valid_utf8( (char[]) { 0xD8, 0x00} ); });

-EXO_TEST(utf8_valid_6, { return is_valid_utf8( (char[]) { 0x24, 0x00} ); });
-EXO_TEST(utf8_valid_7, { return !is_valid_utf8( (char[]) { 0xC2, 0x24, 0x00} ); });
-EXO_TEST(utf8_valid_8, { return is_valid_utf8( (char[]) { 0xC2, 0xA2, 0x00} ); });
-EXO_TEST(utf8_valid_9, { return is_valid_utf8( (char[]) { 0xE2, 0x82, 0xAC, 0x00} ); });
-EXO_TEST(utf8_valid_10, { return !is_valid_utf8( (char[]) { 0xC2, 0x32, 0x00} ); });
-EXO_TEST(utf8_valid_11, { return !is_valid_utf8( (char[]) { 0xE2, 0x82, 0x32, 0x00} ); });
-EXO_TEST(utf8_valid_12, { return !is_valid_utf8( (char[]) { 0xE2, 0x32, 0x82, 0x00} ); });
+static const char test_utf_seq_1[] = { 0x65, 0x00 }; // valid
+static const char test_utf_seq_2[] = { 0xD8, 0x00 }; // invalid
+static const char test_utf_seq_3[] = { 0x24, 0x00 }; // valid
+static const char test_utf_seq_4[] = { 0xC2, 0x24, 0x00}; // invalid
+static const char test_utf_seq_5[] = { 0xC2, 0xA2, 0x00}; // valid
+static const char test_utf_seq_6[] = { 0xE2, 0x82, 0xAC, 0x00}; // valid
+static const char test_utf_seq_7[] = { 0xC2, 0x32, 0x00}; // invalid
+static const char test_utf_seq_8[] = { 0xE2, 0x82, 0x32, 0x00}; // invalid
+static const char test_utf_seq_9[] = { 0xE2, 0x32, 0x82, 0x00}; // invalid
+
+EXO_TEST(utf8_valid_4, { return is_valid_utf8(test_utf_seq_1); });
+EXO_TEST(utf8_valid_5, { return !is_valid_utf8(test_utf_seq_2); });
+EXO_TEST(utf8_valid_6, { return is_valid_utf8(test_utf_seq_3); });
+EXO_TEST(utf8_valid_7, { return !is_valid_utf8(test_utf_seq_4); });
+EXO_TEST(utf8_valid_8, { return is_valid_utf8(test_utf_seq_5); });
+EXO_TEST(utf8_valid_9, { return is_valid_utf8(test_utf_seq_6); });
+EXO_TEST(utf8_valid_10, { return !is_valid_utf8(test_utf_seq_7); });
+EXO_TEST(utf8_valid_11, { return !is_valid_utf8(test_utf_seq_8); });
+EXO_TEST(utf8_valid_12, { return !is_valid_utf8(test_utf_seq_9); });


--- a/autotest/test_rbtree.tcc
+++ b/autotest/test_rbtree.tcc
@@ -0,0 +1,144 @@
+#include <uhub.h>
+#include <util/rbtree.h>
+
+#define MAX_NODES 10000
+
+static struct rb_tree* tree = NULL;
+
+int test_tree_compare(const void* a, const void* b)
+{
+	return strcmp((const char*) a, (const char*) b);
+}
+
+
+EXO_TEST(rbtree_create_destroy, {
+	int ok = 0;
+	struct rb_tree* atree;
+	atree = rb_tree_create(test_tree_compare, &hub_malloc, &hub_free);
+	if (atree) ok = 1;
+	rb_tree_destroy(atree);
+	return ok;
+});
+
+EXO_TEST(rbtree_create_1, {
+	tree = rb_tree_create(test_tree_compare, &hub_malloc, &hub_free);
+	return tree != NULL;
+});
+
+EXO_TEST(rbtree_size_0, { return rb_tree_size(tree) == 0; });
+
+EXO_TEST(rbtree_insert_1, {
+	return rb_tree_insert(tree, "one", "1");
+});
+
+EXO_TEST(rbtree_insert_2, {
+	return rb_tree_insert(tree, "two", "2");
+});
+
+EXO_TEST(rbtree_insert_3, {
+	return rb_tree_insert(tree, "three", "3");
+});
+
+EXO_TEST(rbtree_insert_3_again, {
+	return !rb_tree_insert(tree, "three", "3-again");
+});
+
+EXO_TEST(rbtree_size_1, { return rb_tree_size(tree) == 3; });
+
+static int test_check_search(const char* key, const char* expect)
+{
+	const char* value = (const char*) rb_tree_get(tree, key);
+	if (!value) return !expect;
+	if (!expect) return 0;
+	return strcmp(value, expect) == 0;
+}
+
+EXO_TEST(rbtree_search_1, { return test_check_search("one", "1"); });
+EXO_TEST(rbtree_search_2, { return test_check_search("two", "2"); });
+EXO_TEST(rbtree_search_3, { return test_check_search("three", "3"); });
+EXO_TEST(rbtree_search_4, { return test_check_search("four", NULL); });
+
+
+EXO_TEST(rbtree_remove_1, {
+	return rb_tree_remove(tree, "one");
+});
+
+EXO_TEST(rbtree_size_2, { return rb_tree_size(tree) == 2; });
+
+EXO_TEST(rbtree_remove_2, {
+	return rb_tree_remove(tree, "two");
+});
+
+EXO_TEST(rbtree_remove_3, {
+	return rb_tree_remove(tree, "three");
+});
+
+EXO_TEST(rbtree_remove_3_again, {
+	return !rb_tree_remove(tree, "three");
+});
+
+EXO_TEST(rbtree_search_5, { return test_check_search("one", NULL); });
+EXO_TEST(rbtree_search_6, { return test_check_search("two", NULL); });
+EXO_TEST(rbtree_search_7, { return test_check_search("three", NULL); });
+EXO_TEST(rbtree_search_8, { return test_check_search("four", NULL); });
+
+EXO_TEST(rbtree_size_3, { return rb_tree_size(tree) == 0; });
+
+EXO_TEST(rbtree_insert_10000, {
+	int i;
+	for (i = 0; i < MAX_NODES ; i++)
+	{
+		const char* key = strdup(uhub_itoa(i));
+		const char* val = strdup(uhub_itoa(i + 16384));
+		if (!rb_tree_insert(tree, key, val))
+			return 0;
+	}
+	return 1;
+});
+
+EXO_TEST(rbtree_size_4, { return rb_tree_size(tree) == MAX_NODES ; });
+
+EXO_TEST(rbtree_check_10000, {
+	int i;
+	for (i = 0; i < MAX_NODES ; i++)
+	{
+		char* key = strdup(uhub_itoa(i));
+		const char* expect = uhub_itoa(i + 16384);
+		if (!test_check_search(key, expect))
+			return 0;
+		hub_free(key);
+	}
+	return 1;
+});
+
+EXO_TEST(rbtree_iterate_10000, {
+	int i = 0;
+	struct rb_node* n = (struct rb_node*) rb_tree_first(tree);
+	while (n)
+	{
+		struct rb_node* p = n;
+		n = (struct rb_node*) rb_tree_next(tree);
+		i++;
+	}
+	return i == MAX_NODES ;
+});
+
+
+static void free_node(struct rb_node* n)
+{
+	hub_free((void*) n->key);
+	hub_free((void*) n->value);
+}
+
+EXO_TEST(rbtree_remove_5000, {
+	int i = 0;
+	struct rb_node* n = (struct rb_node*) rb_tree_first(tree);
+	for (i = 0; i < MAX_NODES ; i += 2)
+	{
+		const char* key = uhub_itoa(i);
+		rb_tree_remove_node(tree, key, &free_node);
+	}
+	return 1;
+});
+
+
--- a/autotest/test_tokenizer.tcc
+++ b/autotest/test_tokenizer.tcc
@@ -7,13 +7,15 @@
 static int match_str(const char* str1, char* str2)
 {
 	size_t i;
+	int ret;
+
 	for (i = 0; i < strlen(str2); i++)
 		if (str2[i] == '_')
 			str2[i] = ' ';
 		else if (str2[i] == '|')
 			str2[i] = '\t';

-	int ret = strcmp(str1, str2);
+	ret = strcmp(str1, str2);
 	if (ret) {
 		fprintf(stderr, "\n    Mismatch: \"%s\" != \"%s\"\n", str1, str2);
 	}
@@ -29,10 +31,11 @@ static int count(const char* STR, size_t EXPECT) {

 static int compare(const char* str, const char* ref) {
 	size_t i, max;
+	int pass;
 	struct linked_list* compare = list_create();
 	SETUP(tokens, str);
 	split_string(ref, " ", compare, 0);
-	int pass = cfg_token_count(tokens) == list_size(compare);
+	pass = cfg_token_count(tokens) == list_size(compare);
 	if (pass) {
 		max = cfg_token_count(tokens);
 		for (i = 0; i < max; i++) {
--- a/autotest/update.sh
+++ b/autotest/update.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+./exotic *.tcc > test.c
+
--- a/doc/plugins.conf
+++ b/doc/plugins.conf
@@ -11,7 +11,7 @@
 # Parameters:
 # file: path/filename for database.
 #
-plugin /var/lib/uhub/mod_auth_sqlite.so "file=/etc/uhub/users.db"
+plugin /usr/lib/uhub/mod_auth_sqlite.so "file=/etc/uhub/users.db"


 # Log file writer
@@ -19,10 +19,10 @@ plugin /var/lib/uhub/mod_auth_sqlite.so "file=/etc/uhub/users.db"
 # Parameters:
 # file: path/filename for log file.
 # syslog: if true then syslog is used instead of writing to a file (Unix only)
-plugin /var/lib/uhub/mod_logging.so "file=/var/log/uhub.log"
+plugin /usr/lib/uhub/mod_logging.so "file=/var/log/uhub.log"

 # A simple example plugin
-# plugin /var/lib/uhub/mod_example.so
+# plugin /usr/lib/uhub/mod_example.so
 # A plugin sending a welcome message.
 #
 # This plugin provides the following commands:
@@ -46,7 +46,7 @@ plugin /var/lib/uhub/mod_logging.so "file=/var/log/uhub.log"
 # %p - 'am' or 'pm'
 # %M - Minutes (00-59) (Hub local time)
 # %S - Seconds (00-60) (Hub local time)
-plugin /var/lib/uhub/mod_welcome.so "motd=/etc/uhub/motd.txt rules=/etc/uhub/rules.txt"
+plugin /usr/lib/uhub/mod_welcome.so "motd=/etc/uhub/motd.txt rules=/etc/uhub/rules.txt"

 # Load the chat history plugin.
 #
@@ -58,5 +58,5 @@ plugin /var/lib/uhub/mod_welcome.so "motd=/etc/uhub/motd.txt rules=/etc/uhub/rul
 # history_max:     the maximum number of messages to keep in history
 # history_default: when !history is provided without arguments, then this default number of messages are returned.
 # history_connect: the number of chat history messages to send when users connect (0 = do not send any history)
-plugin /var/lib/uhub/mod_chat_history.so "history_max=200 history_default=10 history_connect=5"
+plugin /usr/lib/uhub/mod_chat_history.so "history_max=200 history_default=10 history_connect=5"

--- a/doc/uhub.spec
+++ b/doc/uhub.spec
@@ -41,7 +41,7 @@ mkdir -p $RPM_BUILD_ROOT/etc/init.d
 mkdir -p $RPM_BUILD_ROOT/etc/logrotate.d
 mkdir -p $RPM_BUILD_ROOT/etc/sysconfig
 mkdir -p $RPM_BUILD_ROOT/usr/share/man/man1
-mkdir -p $RPM_BUILD_ROOT/var/lib/uhub
+mkdir -p $RPM_BUILD_ROOT/usr/lib/uhub

 install uhub $RPM_BUILD_ROOT/usr/bin/
 install uhub-passwd $RPM_BUILD_ROOT/usr/bin/
@@ -52,7 +52,7 @@ install -m644 doc/init.d.RedHat/etc/sysconfig/uhub  $RPM_BUILD_ROOT/etc/sysconfi
 install -m644 doc/init.d.RedHat/etc/logrotate.d/uhub $RPM_BUILD_ROOT/etc/logrotate.d/
 /bin/gzip -9c doc/uhub.1 > doc/uhub.1.gz &&
 install -m644 doc/uhub.1.gz $RPM_BUILD_ROOT/usr/share/man/man1
-install -m644 mod_*.so $RPM_BUILD_ROOT/var/lib/uhub
+install -m644 mod_*.so $RPM_BUILD_ROOT/usr/lib/uhub


 %files
--- a/src/core/main.c
+++ b/src/core/main.c
@@ -136,7 +136,13 @@ int main_loop()
 		{
 			hub = hub_start_service(&configuration);
 			if (!hub)
+			{
+				acl_shutdown(&acl);
+				free_config(&configuration);
+				net_destroy();
+				hub_log_shutdown();
 				return -1;
+			}
 #if !defined(WIN32)
 			setup_signal_handlers(hub);
 #endif
--- a/src/network/backend.c
+++ b/src/network/backend.c
@@ -146,6 +146,9 @@ int net_backend_process()
 		return 0;
 	}

+	// Process pending DNS results
+	net_dns_process();
+
 	g_backend->handler.backend_process(g_backend->data, res);

 	net_cleanup_process(g_backend->cleaner);
--- a/src/network/connection.c
+++ b/src/network/connection.c
@@ -20,11 +20,6 @@
 #include "uhub.h"
 #include "network/common.h"

-#ifdef SSL_SUPPORT
-void net_stats_add_tx(size_t bytes);
-void net_stats_add_rx(size_t bytes);
-#endif
-
 static int is_blocked_or_interrupted()
 {
 	int err = net_error();
--- a/src/network/dnsresolver.c
+++ b/src/network/dnsresolver.c
@@ -0,0 +1,386 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * 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 "uhub.h"
+
+static struct net_dns_job* find_and_remove_job(struct net_dns_job* job);
+static struct net_dns_result* find_and_remove_result(struct net_dns_job* job);
+
+struct net_dns_job
+{
+	net_dns_job_cb callback;
+	void* ptr;
+
+	char* host;
+	int af;
+
+#ifdef DEBUG_LOOKUP_TIME
+	struct timeval time_start;
+	struct timeval time_finish;
+#endif
+
+	uhub_thread_t* thread_handle;
+};
+
+struct net_dns_result
+{
+	struct linked_list* addr_list;
+	struct net_dns_job* job;
+};
+
+static void free_job(struct net_dns_job* job)
+{
+	if (job)
+	{
+		hub_free(job->host);
+		hub_free(job);
+	}
+}
+
+static void shutdown_free_jobs(void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) ptr;
+	uhub_thread_cancel(job->thread_handle);
+	uhub_thread_join(job->thread_handle);
+	free_job(job);
+}
+
+static void shutdown_free_results(void* ptr)
+{
+	struct net_dns_result* result = (struct net_dns_result*) ptr;
+	uhub_thread_join(result->job->thread_handle);
+	net_dns_result_free(result);
+}
+
+
+// NOTE: Any job manipulating the members of this
+// struct must lock the mutex!
+struct net_dns_subsystem
+{
+	struct linked_list* jobs;    // currently running jobs
+	struct linked_list* results; // queue of results that are awaiting being delivered to callback.
+	uhub_mutex_t mutex;
+};
+
+static struct net_dns_subsystem* g_dns = NULL;
+
+void net_dns_initialize()
+{
+	LOG_TRACE("net_dns_initialize()");
+	g_dns = (struct net_dns_subsystem*) hub_malloc_zero(sizeof(struct net_dns_subsystem));
+	g_dns->jobs = list_create();
+	g_dns->results = list_create();
+	uhub_mutex_init(&g_dns->mutex);
+}
+
+void net_dns_destroy()
+{
+	struct net_dns_job* job;
+	struct net_dns_result* result;
+
+	uhub_mutex_lock(&g_dns->mutex);
+	LOG_TRACE("net_dns_destroy(): jobs=%d", (int) list_size(g_dns->jobs));
+	list_clear(g_dns->jobs, &shutdown_free_jobs);
+
+	LOG_TRACE("net_dns_destroy(): results=%d", (int) list_size(g_dns->results));
+	list_clear(g_dns->results, &shutdown_free_results);
+	uhub_mutex_unlock(&g_dns->mutex);
+
+	list_destroy(g_dns->jobs);
+	list_destroy(g_dns->results);
+	uhub_mutex_destroy(&g_dns->mutex);
+	hub_free(g_dns);
+	g_dns = NULL;
+}
+
+static void dummy_free(void* ptr)
+{
+}
+
+
+void net_dns_process()
+{
+	struct net_dns_result* result;
+	uhub_mutex_lock(&g_dns->mutex);
+	LOG_DUMP("net_dns_process(): jobs=%d, results=%d", (int) list_size(g_dns->jobs), (int) list_size(g_dns->results));
+
+	for (result = (struct net_dns_result*) list_get_first(g_dns->results); result; result = (struct net_dns_result*) list_get_next(g_dns->results))
+	{
+		struct net_dns_job* job = result->job;
+#ifdef DEBUG_LOOKUP_TIME
+		struct timeval time_result;
+		timersub(&result->job->time_finish, &result->job->time_start, &time_result);
+		LOG_TRACE("DNS lookup took %d ms", (time_result.tv_sec * 1000) + (time_result.tv_usec / 1000));
+#endif
+
+		// wait for the work thread to finish
+		uhub_thread_join(job->thread_handle);
+
+		// callback - should we delete the data immediately?
+		if (job->callback(job, result))
+		{
+			net_dns_result_free(result);
+		}
+		else
+		{
+			/* Caller wants to keep the result data, and
+			 * thus needs to call net_dns_result_free() to release it later.
+			 * We only clean up the job data here and keep the results intact.
+			 */
+			result->job = NULL;
+			free_job(job);
+		}
+	}
+
+	list_clear(g_dns->results, &dummy_free);
+	uhub_mutex_unlock(&g_dns->mutex);
+}
+
+static void* job_thread_resolve_name(void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) ptr;
+	struct addrinfo hints, *result, *it;
+	struct net_dns_result* dns_results;
+	int ret;
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = job->af;
+	hints.ai_protocol = IPPROTO_TCP;
+
+	ret = getaddrinfo(job->host, NULL, &hints, &result);
+	if (ret != 0 && ret != EAI_NONAME)
+	{
+		LOG_TRACE("getaddrinfo() failed: %s", gai_strerror(ret));
+		return NULL;
+	}
+
+	dns_results = (struct net_dns_result*) hub_malloc(sizeof(struct net_dns_result));
+	dns_results->addr_list = list_create();
+	dns_results->job = job;
+
+	if (ret != EAI_NONAME)
+	{
+		for (it = result; it; it = it->ai_next)
+		{
+			struct ip_addr_encap* ipaddr = hub_malloc_zero(sizeof(struct ip_addr_encap));
+			ipaddr->af = it->ai_family;
+
+			if (it->ai_family == AF_INET)
+			{
+				struct sockaddr_in* addr4 = (struct sockaddr_in*) it->ai_addr;
+				memcpy(&ipaddr->internal_ip_data.in, &addr4->sin_addr, sizeof(struct in_addr));
+			}
+			else if (it->ai_family == AF_INET6)
+			{
+				struct sockaddr_in6* addr6 = (struct sockaddr_in6*) it->ai_addr;
+				memcpy(&ipaddr->internal_ip_data.in6, &addr6->sin6_addr, sizeof(struct in6_addr));
+			}
+			else
+			{
+				LOG_TRACE("getaddrinfo() returned result with unknown address family: %d", it->ai_family);
+				hub_free(ipaddr);
+				continue;
+			}
+
+			LOG_DUMP("getaddrinfo() - Address (%d) %s for \"%s\"", ret++, ip_convert_to_string(ipaddr), job->host);
+			list_append(dns_results->addr_list, ipaddr);
+		}
+		freeaddrinfo(result);
+	}
+	else
+	{
+		/* hm */
+	}
+
+#ifdef DEBUG_LOOKUP_TIME
+	gettimeofday(&job->time_finish, NULL);
+#endif
+
+	uhub_mutex_lock(&g_dns->mutex);
+	list_remove(g_dns->jobs, job);
+	list_append(g_dns->results, dns_results);
+	uhub_mutex_unlock(&g_dns->mutex);
+
+	return dns_results;
+}
+
+
+extern struct net_dns_job* net_dns_gethostbyname(const char* host, int af, net_dns_job_cb callback, void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) hub_malloc_zero(sizeof(struct net_dns_job));
+	job->host = strdup(host);
+	job->af = af;
+	job->callback = callback;
+	job->ptr = ptr;
+
+#ifdef DEBUG_LOOKUP_TIME
+	gettimeofday(&job->time_start, NULL);
+#endif
+
+	// FIXME - scheduling - what about a max number of threads?
+	uhub_mutex_lock(&g_dns->mutex);
+	job->thread_handle = uhub_thread_create(job_thread_resolve_name, job);
+	if (!job->thread_handle)
+	{
+		LOG_WARN("Unable to create thread");
+		free_job(job);
+		job = NULL;
+	}
+	else
+	{
+		list_append(g_dns->jobs, job);
+	}
+	uhub_mutex_unlock(&g_dns->mutex);
+	return job;
+}
+
+
+
+extern struct net_dns_job* net_dns_gethostbyaddr(struct ip_addr_encap* ipaddr, net_dns_job_cb callback, void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) hub_malloc_zero(sizeof(struct net_dns_job));
+// 	job->host = strdup(addr);
+	job->af = ipaddr->af;
+	job->callback = callback;
+	job->ptr = ptr;
+
+
+// 	if (pthread_create(&job->thread_handle, NULL, start_job, job))
+// 	{
+// 		free_job(job);
+// 		return NULL;
+// 	}
+	return job;
+}
+
+// NOTE: mutex must be locked first!
+static struct net_dns_job* find_and_remove_job(struct net_dns_job* job)
+{
+	struct net_dns_job* it;
+	for (it = (struct net_dns_job*) list_get_first(g_dns->jobs); it; it = (struct net_dns_job*) list_get_next(g_dns->jobs))
+	{
+		if (it == job)
+		{
+			list_remove(g_dns->jobs, it);
+			return job;
+		}
+	}
+	return NULL;
+}
+
+// NOTE: mutex must be locked first!
+static struct net_dns_result* find_and_remove_result(struct net_dns_job* job)
+{
+	struct net_dns_result* it;
+	for (it = (struct net_dns_result*) list_get_first(g_dns->results); it; it = (struct net_dns_result*) list_get_next(g_dns->results))
+	{
+		if (it->job == job)
+		{
+			list_remove(g_dns->results, it);
+			return it;
+		}
+	}
+	return NULL;
+}
+
+
+extern int net_dns_job_cancel(struct net_dns_job* job)
+{
+	int retval = 0;
+	struct net_dns_result* res;
+
+	LOG_TRACE("net_dns_job_cancel(): job=%p, name=%s", job, job->host);
+
+	/*
+	 * This function looks up the job in the jobs queue (which contains only active jobs)
+	 * If that is found then the thread is cancelled, and the object is deleted.
+	 * If the job was not found, that is either because it was an invalid job, or because
+	 * it was already finished. At which point it was not deleted.
+	 * If the job is already finished, but the result has not been delivered, then this
+	 * deletes the result and the job.
+	 */
+	uhub_mutex_lock(&g_dns->mutex);
+	if (find_and_remove_job(job))
+	{
+		// job still active - cancel it, then close it.
+		uhub_thread_cancel(job->thread_handle);
+		uhub_thread_join(job->thread_handle);
+		free_job(job);
+		retval = 1;
+	}
+	else if ((res = find_and_remove_result(job)))
+	{
+		// job already finished - close it.
+		uhub_thread_join(job->thread_handle);
+		net_dns_result_free(res);
+	}
+	uhub_mutex_unlock(&g_dns->mutex);
+	return retval;
+}
+
+extern struct net_dns_result* net_dns_job_sync_wait(struct net_dns_job* job)
+{
+	struct net_dns_result* res = NULL;
+
+	// Wait for job to finish (if not already)
+	// This should make sure the job is removed from jobs and a result is
+	// present in results.
+	uhub_thread_join(job->thread_handle);
+
+	// Remove the result in order to prevent the callback from being called.
+	uhub_mutex_lock(&g_dns->mutex);
+	res = find_and_remove_result(job);
+	uhub_assert(res != NULL);
+	res->job = NULL;
+	free_job(job);
+	uhub_mutex_unlock(&g_dns->mutex);
+	return res;
+}
+
+void* net_dns_job_get_ptr(const struct net_dns_job* job)
+{
+	return job->ptr;
+}
+
+extern size_t net_dns_result_size(const struct net_dns_result* res)
+{
+	return list_size(res->addr_list);
+}
+
+extern struct ip_addr_encap* net_dns_result_first(const struct net_dns_result* res)
+{
+	struct ip_addr_encap* ipaddr = list_get_first(res->addr_list);
+	LOG_TRACE("net_dns_result_first() - Address: %s", ip_convert_to_string(ipaddr));
+	return ipaddr;
+}
+
+extern struct ip_addr_encap* net_dns_result_next(const struct net_dns_result* res)
+{
+	struct ip_addr_encap* ipaddr = list_get_next(res->addr_list);
+	LOG_TRACE("net_dns_result_next() - Address: %s", ip_convert_to_string(ipaddr));
+	return ipaddr;
+}
+
+extern void net_dns_result_free(struct net_dns_result* res)
+{
+	list_clear(res->addr_list, &hub_free);
+	list_destroy(res->addr_list);
+	free_job(res->job);
+	hub_free(res);
+}
--- a/src/network/dnsresolver.h
+++ b/src/network/dnsresolver.h
@@ -0,0 +1,119 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * 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/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_NETWORK_DNS_RESOLVER_H
+#define HAVE_UHUB_NETWORK_DNS_RESOLVER_H
+
+struct net_dns_job;
+struct net_dns_result;
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+/// Initialize the DNS subsystem
+void net_dns_initialize();
+
+/// Shutdown and destroy the DNS subsystem. This will cancel any pending DNS jobs.
+void net_dns_destroy();
+
+/// Process finished DNS lookups.
+void net_dns_process();
+
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+/**
+ * Callback to be called when the DNS job has finished.
+ * If the name or address could not be resolved to an IP address (host not found, or found but has no address)
+ * then 'result' contains an empty list (@see net_dns_result_size()).
+ * If resolving caused an error then result is NULL.
+ *
+ * After this callback is called the job is considered done, and is freed.
+ *
+ * @param If 1 is returned then result is deleted immediately after the callback,
+ * otherwise the callback becomes owner of the result data which must be freed with net_dns_result_free().
+ */
+typedef int (*net_dns_job_cb)(struct net_dns_job*, const struct net_dns_result* result);
+
+/**
+ * Resolve a hostname.
+ *
+ * @param host the hostname to be resolved.
+ * @param af the indicated address family. Should be AF_INET, AF_INET6 (or AF_UNSPEC - which means both AF_INET and AF_INET6.
+ * @param callback the callback to be called when the hostname has been resolved.
+ * @param ptr A user-defined pointer value.
+ *
+ * @return A resolve job handle if the job has successfully started or NULL if unable to start resolving.
+ */
+extern struct net_dns_job* net_dns_gethostbyname(const char* host, int af, net_dns_job_cb callback, void* ptr);
+
+/**
+ * Perform a reverse DNS lookup for a given IP address.
+ *
+ * @see net_dns_gethostbyname()
+ * @return A resolve job handle if the job has successfully started or NULL if unable to start resolving.
+ */
+extern struct net_dns_job* net_dns_gethostbyaddr(struct ip_addr_encap* ipaddr, net_dns_job_cb callback, void* ptr);
+
+/**
+ * Cancel a DNS lookup job.
+ *
+ * It is only allowed to call this once after a job has been started (@see net_dns_gethostbyname(), @see net_dns_gethostbyaddr())
+ * but before it has finished and delivered a to the callback address (@see net_dns_job_cb).
+ *
+ * @returns 1 if cancelled, or 0 if not cancelled (because the job was not found!)
+ */
+extern int net_dns_job_cancel(struct net_dns_job* job);
+
+/**
+ * Wait in a synchronous manner for a running DNS job to finished and
+ * return the result here.
+ * The job must be started with net_dns_gethostbyaddr/net_dns_gethostbyname
+ * and not finished or cancelled.
+ *
+ * If this function is invoked then the callback function will not be called and
+ * can therefore be NULL.
+ *
+ * <code>
+ *    struct net_dns_job* job = net_dns_gethostbyname("www.example.com", AF_INET, NULL, NULL);
+ *    struct net_dns_result* net_dns_job_sync_wait(job);
+ * </code>
+ */
+extern struct net_dns_result* net_dns_job_sync_wait(struct net_dns_job* job);
+
+/**
+ * Returns the user specified pointer assigned to the resolving job
+*/
+extern void* net_dns_job_get_ptr(const struct net_dns_job* job);
+
+/// Returns the number of results provided. This is 0 if the host could not be found (or has no matching IP address).
+extern size_t net_dns_result_size(const struct net_dns_result*);
+
+/// Returns the first result (if net_dns_result_size > 0), or NULL if not first result exists.
+extern struct ip_addr_encap* net_dns_result_first(const struct net_dns_result*);
+
+/// Returns the next result or NULL if no next result exists.
+extern struct ip_addr_encap* net_dns_result_next(const struct net_dns_result*);
+
+/// When finished with the results
+extern void net_dns_result_free(struct net_dns_result*);
+
+#endif /* HAVE_UHUB_NETWORK_DNS_RESOLVER_H */
--- a/src/network/network.c
+++ b/src/network/network.c
@@ -1,6 +1,6 @@
 /*
 * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
 *
 * 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
@@ -49,23 +49,21 @@ int net_initialize()
 		}
 #endif /* WINSOCK */

-		if (!net_backend_init())
+		if (!net_backend_init()
+#ifdef SSL_SUPPORT
+			|| !net_ssl_library_init()
+#endif
+			)
 		{
 #ifdef WINSOCK
 			WSACleanup();
 #endif
 			return -1;
 		}
+
+		net_dns_initialize();
+
 		net_stats_initialize();
-
-#ifdef SSL_SUPPORT
-#ifdef SSL_USE_OPENSSL
-		LOG_TRACE("Initializing OpenSSL...");
-		SSL_library_init();
-		SSL_load_error_strings();
-#endif /* SSL_USE_OPENSSL */
-#endif /*  SSL_SUPPORT */
-
 		net_initialized = 1;
 		return 0;
 	}
@@ -99,14 +97,12 @@ int net_destroy()
 	{
 		LOG_TRACE("Shutting down network monitor");

+		net_dns_destroy();
+
 		net_backend_shutdown();
-		
+
 #ifdef SSL_SUPPORT
-#ifdef SSL_USE_OPENSSL
-		ERR_free_strings();
-		EVP_cleanup();
-		CRYPTO_cleanup_all_ex_data();
-#endif /* SSL_USE_OPENSSL */
+		net_ssl_library_shutdown();
 #endif /* SSL_SUPPORT */

 #ifdef WINSOCK
@@ -499,7 +495,6 @@ int net_socket_create(int af, int type, int protocol)
 		}
 	}
 #endif
-
 	return sd;
 }

--- a/src/network/network.h
+++ b/src/network/network.h
@@ -1,6 +1,6 @@
 /*
 * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
 *
 * 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
--- a/src/network/openssl.c
+++ b/src/network/openssl.c
@@ -24,15 +24,17 @@
 #ifdef SSL_SUPPORT
 #ifdef SSL_USE_OPENSSL

-#define NETWORK_DUMP_DEBUG
+void net_stats_add_tx(size_t bytes);
+void net_stats_add_rx(size_t bytes);

 struct net_ssl_openssl
 {
 	SSL* ssl;
+	BIO* bio;
 	enum ssl_state state;
 	uint32_t flags;
-	BIO* biow;
-	BIO* bior;
+	size_t bytes_rx;
+	size_t bytes_tx;
 };

 struct net_context_openssl
@@ -52,6 +54,44 @@ const char* net_ssl_get_provider()
 	return OPENSSL_VERSION_TEXT;
 }

+int net_ssl_library_init()
+{
+	LOG_TRACE("Initializing OpenSSL...");
+	SSL_library_init();
+	SSL_load_error_strings();
+	return 1;
+}
+
+int net_ssl_library_shutdown()
+{
+	ERR_clear_error();
+	ERR_remove_state(0);
+
+	ENGINE_cleanup();
+	CONF_modules_unload(1);
+
+        ERR_free_strings();
+	EVP_cleanup();
+        CRYPTO_cleanup_all_ex_data();
+	
+	// sk_SSL_COMP_free(SSL_COMP_get_compression_methods());
+	return 1;
+}
+
+static void add_io_stats(struct net_ssl_openssl* handle)
+{
+	if (handle->bio->num_read > handle->bytes_rx)
+	{
+		net_stats_add_rx(handle->bio->num_read - handle->bytes_rx);
+		handle->bytes_rx = handle->bio->num_read;
+	}
+
+	if (handle->bio->num_write > handle->bytes_tx)
+	{
+		net_stats_add_tx(handle->bio->num_write - handle->bytes_tx);
+		handle->bytes_tx = handle->bio->num_write;
+	}
+}

 /**
 * Create a new SSL context.
@@ -65,6 +105,13 @@ struct ssl_context_handle* net_ssl_context_create()

 	/* Disable SSLv2 */
 	SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_SSLv2);
+
+#ifdef SSL_OP_NO_COMPRESSION
+	/* Disable compression? */
+	LOG_TRACE("Disabling SSL compression."); /* "CRIME" attack */
+	SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_COMPRESSION);
+#endif
+
 	SSL_CTX_set_quiet_shutdown(ctx->ssl_ctx, 1);

 	return (struct ssl_context_handle*) ctx;
@@ -161,9 +208,7 @@ ssize_t net_con_ssl_connect(struct net_connection* con)
 	handle->state = tls_st_connecting;

 	ret = SSL_connect(handle->ssl);
-#ifdef NETWORK_DUMP_DEBUG
 	LOG_PROTO("SSL_connect() ret=%d", ret);
-#endif /* NETWORK_DUMP_DEBUG */

 	if (ret > 0)
 	{
@@ -190,8 +235,7 @@ ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode
 			return -1;
 		}
 		SSL_set_fd(handle->ssl, con->sd);
-		handle->bior = SSL_get_rbio(handle->ssl);
-		handle->biow = SSL_get_wbio(handle->ssl);
+		handle->bio = SSL_get_rbio(handle->ssl);
 		con->ssl = (struct ssl_handle*) handle;
 		return net_con_ssl_accept(con);
 	}
@@ -199,8 +243,7 @@ ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode
 	{
 		handle->ssl = SSL_new(SSL_CTX_new(TLSv1_method()));
 		SSL_set_fd(handle->ssl, con->sd);
-		handle->bior = SSL_get_rbio(handle->ssl);
-		handle->biow = SSL_get_wbio(handle->ssl);
+		handle->bio = SSL_get_rbio(handle->ssl);
 		con->ssl = (struct ssl_handle*) handle;
 		return net_con_ssl_connect(con);
 	}
@@ -215,6 +258,7 @@ ssize_t net_ssl_send(struct net_connection* con, const void* buf, size_t len)

 	ERR_clear_error();
 	ssize_t ret = SSL_write(handle->ssl, buf, len);
+	add_io_stats(handle);
 	LOG_PROTO("SSL_write(con=%p, buf=%p, len=" PRINTF_SIZE_T ") => %d", con, buf, len, ret);
 	if (ret > 0)
 	{
@@ -237,6 +281,7 @@ ssize_t net_ssl_recv(struct net_connection* con, void* buf, size_t len)
 	ERR_clear_error();

 	ret = SSL_read(handle->ssl, buf, len);
+	add_io_stats(handle);
 	LOG_PROTO("SSL_read(con=%p, buf=%p, len=" PRINTF_SIZE_T ") => %d", con, buf, len, ret);
 	if (ret > 0)
 	{
@@ -302,4 +347,5 @@ void net_ssl_callback(struct net_connection* con, int events)


 #endif /* SSL_USE_OPENSSL */
-#endif /* SSL_SUPPORT */
+#endif /* SSL_SUPPORT */
+
--- a/src/network/tls.h
+++ b/src/network/tls.h
@@ -50,6 +50,12 @@ struct ssl_context_handle;
 */
 extern const char* net_ssl_get_provider();

+/**
+ * return 0 if error, 1 on success.
+ */
+extern int net_ssl_library_init();
+extern int net_ssl_library_shutdown();
+
 /**
 * Create a new SSL context.
 */
@@ -91,11 +97,8 @@ extern void net_ssl_callback(struct net_connection* con, int events);


 extern ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode, struct ssl_context_handle* ssl_ctx);
-extern SSL* net_con_get_ssl(struct net_connection* con);
-#ifdef SSL_USE_OPENSSL
-extern void net_con_set_ssl(struct net_connection* con, SSL*);
-#endif // SSL_USE_OPENSSL
 extern int   net_con_is_ssl(struct net_connection* con);

 #endif /* SSL_SUPPORT */
-#endif /* HAVE_UHUB_NETWORK_TLS_H */
+#endif /* HAVE_UHUB_NETWORK_TLS_H */
+
--- a/src/system.h
+++ b/src/system.h
@@ -34,6 +34,7 @@
 #ifndef WINSOCK
 #define WINSOCK
 #endif
+#define WINTHREAD_SUPPORT 1
 #endif

 #if defined(__CYGWIN__) || defined(__MINGW32__)
@@ -113,11 +114,13 @@
 #define uhub_assert assert

 #ifdef __linux__
+#define POSIX_THREAD_SUPPORT
 #define USE_EPOLL
 #include <sys/epoll.h>
 #endif

 #ifdef BSD_LIKE
+#define POSIX_THREAD_SUPPORT
 /*
 #define USE_KQUEUE
 #include <sys/event.h>
@@ -129,7 +132,7 @@
 #include <sys/select.h>
 #endif

-#if defined(BSD_LIKE) || defined(__sun__)
+#if ( defined(BSD_LIKE) && !defined(__FreeBSD_kernel__) ) || defined(__sun__)
 #undef HAVE_STRNDUP
 #undef HAVE_MEMMEM
 #endif
@@ -279,6 +282,10 @@ typedef unsigned __int64 uint64_t;
 #define NEED_GETOPT
 #endif

+#ifdef POSIX_THREAD_SUPPORT
+#include <pthread.h>
+#endif
+
 #if defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER)
 #define PLUGIN_API __declspec(dllexport)
 #else
--- a/src/tools/adcclient.c
+++ b/src/tools/adcclient.c
@@ -30,6 +30,7 @@
 enum ADC_client_state
 {
 	ps_none, /* Not connected */
+	ps_dns,  /* looking up name */
 	ps_conn, /* Connecting... */
 	ps_conn_ssl, /* SSL handshake */
 	ps_protocol, /* Have sent HSUP */
@@ -46,6 +47,13 @@ enum ADC_client_flags
 	cflag_pipe = 4,
 };

+struct ADC_client_address
+{
+	enum Protocol { ADC, ADCS } protocol;
+	char* hostname;
+	uint16_t port;
+};
+
 struct ADC_client
 {
 	sid_t sid;
@@ -59,8 +67,9 @@ struct ADC_client
 	size_t timeout;
 	struct net_connection* con;
 	struct net_timer* timer;
-	struct sockaddr_in addr;
-	char* hub_address;
+	struct sockaddr_storage addr;
+	struct net_dns_job* dns_job;
+	struct ADC_client_address address;
 	char* nick;
 	char* desc;
 	int flags;
@@ -100,6 +109,7 @@ static void ADC_client_debug(struct ADC_client* client, const char* format, ...)
 static const char* ADC_client_state_string[] =
 {
 	"ps_none",
+	"ps_dns",
 	"ps_conn",
 	"ps_conn_ssl",
 	"ps_protocol",
@@ -154,6 +164,9 @@ static void event_callback(struct net_connection* con, int events, void *arg)

 	switch (client->state)
 	{
+		case ps_dns:
+			break;
+
 		case ps_conn:
 			if (events == NET_EVENT_TIMEOUT)
 			{
@@ -162,7 +175,7 @@ static void event_callback(struct net_connection* con, int events, void *arg)
 			}

 			if (events & NET_EVENT_WRITE)
-				ADC_client_connect(client, 0);
+				ADC_client_connect_internal(client);
 			break;

 #ifdef SSL_SUPPORT
@@ -493,7 +506,8 @@ void ADC_client_send(struct ADC_client* client, struct adc_message* msg)
 void ADC_client_send_info(struct ADC_client* client)
 {
 	ADC_TRACE;
-	client->info = adc_msg_construct_source(ADC_CMD_BINF, client->sid, 64);
+	client->info = adc_msg_construct_source(ADC_CMD_BINF, client->sid, 96);
+

 	adc_msg_add_named_argument_string(client->info, ADC_INF_FLAG_NICK, client->nick);

@@ -502,9 +516,20 @@ void ADC_client_send_info(struct ADC_client* client)
 		adc_msg_add_named_argument_string(client->info, ADC_INF_FLAG_DESCRIPTION, client->desc);
 	}

-	adc_msg_add_named_argument_string(client->info, ADC_INF_FLAG_USER_AGENT, PRODUCT "/" VERSION);
+	adc_msg_add_named_argument_string(client->info, ADC_INF_FLAG_USER_AGENT, PRODUCT " " VERSION);
+	adc_msg_add_named_argument_int(client->info, ADC_INF_FLAG_UPLOAD_SLOTS, 0);
+	adc_msg_add_named_argument_int(client->info, ADC_INF_FLAG_SHARED_SIZE, 0);
+	adc_msg_add_named_argument_int(client->info, ADC_INF_FLAG_SHARED_FILES, 0);
+
+	adc_msg_add_named_argument_int(client->info, ADC_INF_FLAG_COUNT_HUB_NORMAL, 1);
+	adc_msg_add_named_argument_int(client->info, ADC_INF_FLAG_COUNT_HUB_REGISTER, 0);
+	adc_msg_add_named_argument_int(client->info, ADC_INF_FLAG_COUNT_HUB_OPERATOR, 0);
+
+	adc_msg_add_named_argument_int(client->info, ADC_INF_FLAG_DOWNLOAD_SPEED, 5 * 1024 * 1024);
+	adc_msg_add_named_argument_int(client->info, ADC_INF_FLAG_UPLOAD_SPEED, 10 * 1024 * 1024);

 	adc_cid_pid(client);
+
 	ADC_client_send(client, client->info);
 }

@@ -541,21 +566,34 @@ void ADC_client_destroy(struct ADC_client* client)
 	adc_msg_free(client->info);
 	hub_free(client->nick);
 	hub_free(client->desc);
-	hub_free(client->hub_address);
+	hub_free(client->address.hostname);
+	hub_free(client);
 }

 int ADC_client_connect(struct ADC_client* client, const char* address)
 {
 	ADC_TRACE;
-	if (!client->hub_address)
+	if (client->state == ps_none)
 	{
+		// Parse address and start name resolving!
 		if (!ADC_client_parse_address(client, address))
 			return 0;
-	
+		return 1;
+	}
+	return ADC_client_connect_internal(client);
+}
+
+int ADC_client_connect_internal(struct ADC_client* client)
+{
+	int ret;
+	if (client->state == ps_dns)
+	{
+		// Done name resolving!
 		client->callback(client, ADC_CLIENT_CONNECTING, 0);
+		ADC_client_set_state(client, ps_conn);
 	}

-	int ret = net_connect(net_con_get_sd(client->con), (struct sockaddr*) &client->addr, sizeof(struct sockaddr_in));
+	ret = net_connect(net_con_get_sd(client->con), (struct sockaddr*) &client->addr, sizeof(struct sockaddr_in));
 	if (ret == 0 || (ret == -1 && net_error() == EISCONN))
 	{
 		ADC_client_on_connected(client);
@@ -588,10 +626,12 @@ static void ADC_client_on_connected(struct ADC_client* client)
 	else
 #endif
 	{
+		struct adc_message* handshake = adc_msg_create(ADC_HANDSHAKE);
 		net_con_update(client->con, NET_EVENT_READ);
 		client->callback(client, ADC_CLIENT_CONNECTED, 0);
-		ADC_client_send(client, adc_msg_create(ADC_HANDSHAKE));
+		ADC_client_send(client, handshake);
 		ADC_client_set_state(client, ps_protocol);
+		adc_msg_free(handshake);
 	}
 }

@@ -599,11 +639,13 @@ static void ADC_client_on_connected(struct ADC_client* client)
 static void ADC_client_on_connected_ssl(struct ADC_client* client)
 {
 	ADC_TRACE;
+	struct adc_message* handshake = adc_msg_create(ADC_HANDSHAKE);
 	client->callback(client, ADC_CLIENT_SSL_OK, 0);
 	client->callback(client, ADC_CLIENT_CONNECTED, 0);
 	net_con_update(client->con, NET_EVENT_READ);
-	ADC_client_send(client, adc_msg_create(ADC_HANDSHAKE));
+	ADC_client_send(client, handshake);
 	ADC_client_set_state(client, ps_protocol);
+	adc_msg_free(handshake);
 }
 #endif

@@ -632,19 +674,53 @@ void ADC_client_disconnect(struct ADC_client* client)
 	}
 }

+int ADC_client_dns_callback(struct net_dns_job* job, const struct net_dns_result* result)
+{
+	struct ADC_client* client = (struct ADC_client*) net_dns_job_get_ptr(job);
+	struct ip_addr_encap* ipaddr;
+	LOG_WARN("ADC_client_dns_callback(): result=%p (%d)", result, net_dns_result_size(result));
+
+	memset(&client->addr, 0, sizeof(client->addr));
+
+	ipaddr = net_dns_result_first(result);
+	switch (ipaddr->af)
+	{
+		case AF_INET:
+		{
+			struct sockaddr_in* addr4 = (struct sockaddr_in*) &client->addr;
+			addr4->sin_family = AF_INET;
+			addr4->sin_port = htons(client->address.port);
+			memcpy(&addr4->sin_addr, &ipaddr->internal_ip_data.in, sizeof(struct in_addr));
+			break;
+		}
+
+		case AF_INET6:
+		{
+			struct sockaddr_in6* addr6 = (struct sockaddr_in6*) &client->addr;
+			addr6->sin6_family = AF_INET6;
+			addr6->sin6_port = htons(client->address.port);
+			memcpy(&addr6->sin6_addr, &ipaddr->internal_ip_data.in6, sizeof(struct in6_addr));
+			break;
+		}
+
+		default:
+			LOG_WARN("Unknown ipaddr!");
+	}
+
+	ADC_client_connect_internal(client);
+	return 1;
+}
+
 static int ADC_client_parse_address(struct ADC_client* client, const char* arg)
 {
 	ADC_TRACE;
+	const char* hub_address = arg;
 	char* split;
 	int ssl = 0;
-	struct hostent* dns;
-	struct in_addr* addr;

 	if (!arg)
 		return 0;

-	client->hub_address = hub_strdup(arg);
-
 	/* Minimum length of a valid address */
 	if (strlen(arg) < 9)
 		return 0;
@@ -653,39 +729,33 @@ static int ADC_client_parse_address(struct ADC_client* client, const char* arg)
 	if (!strncmp(arg, "adc://", 6))
 	{
 		client->flags &= ~cflag_ssl;
+		client->address.protocol = ADC;
 	}
 	else if (!strncmp(arg, "adcs://", 7))
 	{
 		client->flags |= cflag_ssl;
 		ssl = 1;
+		client->address.protocol = ADCS;
 	}
 	else
 		return 0;

 	/* Split hostname and port (if possible) */
-	split = strrchr(client->hub_address + 6 + ssl, ':');
+	hub_address = arg + 6 + ssl;
+	split = strrchr(hub_address, ':');
 	if (split == 0 || strlen(split) < 2 || strlen(split) > 6)
 		return 0;

 	/* Ensure port number is valid */
-	int port = strtol(split+1, NULL, 10);
-	if (port <= 0 || port > 65535)
+	client->address.port = strtol(split+1, NULL, 10);
+	if (client->address.port <= 0 || client->address.port > 65535)
 		return 0;

-	split[0] = 0;
+	client->address.hostname = strndup(hub_address, &split[0] - &hub_address[0]);

-	/* Resolve IP address (FIXME: blocking call) */
-	dns = gethostbyname(client->hub_address + 6 + ssl);
-	if (dns)
-	{
-		addr = (struct in_addr*) dns->h_addr_list[0];
-	}
-
-	// Initialize the sockaddr struct.
-	memset(&client->addr, 0, sizeof(client->addr));
-	client->addr.sin_family = AF_INET;
-	client->addr.sin_port   = htons(port);
-	memcpy(&client->addr.sin_addr, addr, sizeof(struct in_addr));
+	client->callback(client, ADC_CLIENT_NAME_LOOKUP, 0);
+	ADC_client_set_state(client, ps_dns);
+	client->dns_job = net_dns_gethostbyname(client->address.hostname, AF_UNSPEC, ADC_client_dns_callback, client);
 	return 1;
 }

--- a/src/tools/adcclient.h
+++ b/src/tools/adcclient.h
@@ -28,6 +28,7 @@ struct ADC_client;

 enum ADC_client_callback_type
 {
+	ADC_CLIENT_NAME_LOOKUP      = 1000,
 	ADC_CLIENT_CONNECTING       = 1001,
 	ADC_CLIENT_CONNECTED        = 1002,
 	ADC_CLIENT_DISCONNECTED     = 1003,
--- a/src/tools/admin.c
+++ b/src/tools/admin.c
@@ -35,7 +35,6 @@ static struct ADC_user* user_get(sid_t sid)
 	return user;
 }

-
 static void user_remove(const struct ADC_client_quit_reason* quit)
 {
 	struct ADC_user* user = user_get(quit->sid);
@@ -91,6 +90,10 @@ static int handle(struct ADC_client* client, enum ADC_client_callback_type type,
 {
 	switch (type)
 	{
+		case ADC_CLIENT_NAME_LOOKUP:
+			status("Looking up hostname...");
+			break;
+
 		case ADC_CLIENT_CONNECTING:
 			status("Connecting...");
 			break;
@@ -107,6 +110,9 @@ static int handle(struct ADC_client* client, enum ADC_client_callback_type type,
 			status("SSL handshake.");
 			break;

+		case ADC_CLIENT_SSL_OK:
+			break;
+
 		case ADC_CLIENT_LOGGING_IN:
 			status("Logging in...");
 			break;
@@ -155,6 +161,68 @@ static int handle(struct ADC_client* client, enum ADC_client_callback_type type,

 static int running = 1;

+#if !defined(WIN32)
+void adm_handle_signal(int sig)
+{
+	switch (sig)
+	{
+		case SIGINT:
+			LOG_INFO("Interrupted. Shutting down...");
+			running = 0;
+			break;
+
+		case SIGTERM:
+			LOG_INFO("Terminated. Shutting down...");
+			running = 0;
+			break;
+
+		case SIGPIPE:
+			break;
+
+		case SIGHUP:
+			break;
+
+		default:
+			LOG_TRACE("hub_handle_signal(): caught unknown signal: %d", signal);
+			running = 0;
+			break;
+	}
+}
+
+static int signals[] =
+{
+	SIGINT,  /* Interrupt the application */
+	SIGTERM, /* Terminate the application */
+	SIGPIPE, /* prevent sigpipe from kills the application */
+	SIGHUP,  /* reload configuration */
+	0
+};
+
+void adm_setup_signal_handlers()
+{
+	sigset_t sig_set;
+	struct sigaction act;
+	int i;
+
+	sigemptyset(&sig_set);
+	act.sa_mask = sig_set;
+	act.sa_flags = SA_ONSTACK | SA_RESTART;
+	act.sa_handler = adm_handle_signal;
+
+	for (i = 0; signals[i]; i++)
+	{
+		if (sigaction(signals[i], &act, 0) != 0)
+		{
+			LOG_ERROR("Error setting signal handler %d", signals[i]);
+		}
+	}
+}
+
+void adm_shutdown_signal_handlers()
+{
+}
+#endif /* !WIN32 */
+
 int main(int argc, char** argv)
 {
 	if (argc < 2)
@@ -163,6 +231,9 @@ int main(int argc, char** argv)
 		return 1;
 	}

+	hub_set_log_verbosity(5);
+	adm_setup_signal_handlers();
+
 	struct ADC_client* client;
 	net_initialize();

@@ -176,6 +247,7 @@ int main(int argc, char** argv)

 	ADC_client_destroy(client);
 	net_destroy();
+	adm_shutdown_signal_handlers();
 	return 0;
 }

--- a/src/uhub.h
+++ b/src/uhub.h
@@ -68,12 +68,14 @@ extern "C" {
 #include "util/memory.h"
 #include "util/misc.h"
 #include "util/tiger.h"
+#include "util/threads.h"

 #include "adc/sid.h"
 #include "adc/message.h"

 #include "network/network.h"
 #include "network/connection.h"
+#include "network/dnsresolver.h"
 #include "network/ipcalc.h"
 #include "network/timeout.h"

--- a/src/util/rbtree.c
+++ b/src/util/rbtree.c
@@ -1,6 +1,6 @@
 /*
 * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
 *
 * 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
@@ -17,84 +17,141 @@
 *
 */

-#if 0
-
-#include <sys/types.h>
+#include "uhub.h"
 #include "rbtree.h"

-#define RED   0
-#define BLACK 1
-
-struct rb_node
-{
-	const void* key;
-	const void* value; /* data */
-	int color;
-	struct rb_node* parent;
-	struct rb_node* left;
-	struct rb_node* right;
-};
-
-struct rb_tree
-{
-	struct rb_node* root;
-	size_t elements;
-	rb_tree_alloc alloc;
-	rb_tree_free free;
-	rb_tree_compare compare;
-};
-
-/* returns the grandparent of a node, if it exits */
-static inline struct rb_node* get_grandparent(struct rb_node* n)
-{
-	if (n->parent)
-		return n->parent->parent;
-	return 0;
-}
-
-static struct rb_node* get_uncle(struct rb_node* n)
-{
-	struct rb_node* gparent = n->parent ? n->parent->parent : 0;
-	if (gparent)
-		return (n->parent == gparent->left) ? gparent->right : gparent->left;
-	return 0;
-}
+// #define RB_TREE_CHECKS

 static struct rb_node* tree_search(struct rb_tree* tree, const void* key)
 {
 	struct rb_node* node = tree->root;
 	while (node)
 	{
-		int res = tree->compare(key, node->key);
-		if (res < 0)      node = node->left;
-		else if (res > 0) node = node->right;
-		else              return node;
+		int res = tree->compare(node->key, key);
+		if (!res)
+			break;
+		node = node->link[res < 0];
 	}
-	return 0;
+	return node;
 }

-static struct rb_node* tree_insert(struct rb_tree* tree, const void* key, const void* value)
+static struct rb_node* create_node(struct rb_tree* tree, const void* key, const void* value)
 {
-	struct rb_node* node = tree->root;
-	struct rb_node* newnode = tree->alloc(sizeof(struct rb_node));
-	newnode->key = key;
-	newnode->value = value;
-	newnode->color = RED;
-	
+	struct rb_node* node = tree->alloc(sizeof(struct rb_node));
+	node->key = key;
+	node->value = value;
+	node->red = 1;
+	node->link[0] = 0;
+	node->link[1] = 0;
+	return node;
+}

-	while (node)
+static int is_red(struct rb_node* node)
+{
+	return node && node->red;
+}
+
+#ifdef RB_TREE_CHECKS
+int rb_tree_check(struct rb_tree* tree, struct rb_node* node)
+{
+	int lh, rh;
+
+	if (node == NULL)
+		return 1;
+	else
 	{
-		int res = tree->compare(key, node->key);
-		if (res < 0)      node = node->left;
-		else if (res > 0) node = node->right;
-		else
+		struct rb_node *ln = node->link[0];
+		struct rb_node *rn = node->link[1];
+
+		/* Consecutive red links */
+		if (is_red(node)) {
+			if (is_red(ln) || is_red(rn))
+			{
+				puts("Red violation");
+				return 0;
+			}
+		}
+
+		lh = rb_tree_check(tree, ln);
+		rh = rb_tree_check(tree, rn);
+
+		/* Invalid binary search tree - not sorted correctly */
+		if ((ln && tree->compare(ln->key, node->key) >= 0) || (rn && tree->compare(rn->key, node->key) <= 0))
 		{
-			/* key already exists in tree */
-			return node;
+			puts("Binary tree violation");
+			return 0;
+		}
+
+		/* Black height mismatch */
+		if ( lh != 0 && rh != 0 && lh != rh ) {
+			puts ( "Black violation" );
+			return 0;
+		}
+
+		/* Only count black links */
+		if (lh != 0 && rh != 0)
+			return is_red(node) ? lh : lh + 1;
+		else
+			return 0;
+	}
+}
+#endif // RB_TREE_CHECKS
+
+static struct rb_node* rb_tree_rotate_single(struct rb_node* node, int dir)
+{
+	struct rb_node* other = node->link[!dir];
+
+	node->link[!dir] = other->link[dir];
+	other->link[dir] = node;
+
+	node->red = 1;
+	other->red = 0;
+	return other;
+}
+
+static struct rb_node* rb_tree_rotate_double(struct rb_node* node, int dir)
+{
+	node->link[!dir] = rb_tree_rotate_single(node->link[!dir], !dir);
+	return rb_tree_rotate_single(node, dir);
+}
+
+static struct rb_node* rb_tree_insert_r(struct rb_tree* tree, struct rb_node* node, const void* key, const void* value)
+{
+	int res;
+	if (!node)
+		return create_node(tree, key, value);
+
+	res = tree->compare(node->key, key);
+	if (!res)
+	{
+		puts("Node already exists!");
+		return NULL;
+	}
+	else
+	{
+		int dir = res < 0;
+		node->link[dir] = rb_tree_insert_r(tree, node->link[dir], key, value);
+
+		if (is_red(node->link[dir]))
+		{
+			if (is_red(node->link[!dir]))
+			{
+				/* Case 1 */
+				node->red = 1;
+				node->link[0]->red = 0;
+				node->link[1]->red = 0;
+			}
+			else
+			{
+				/* Cases 2 & 3 */
+				if (is_red(node->link[dir]->link[dir]))
+					node = rb_tree_rotate_single(node, !dir);
+				else if (is_red(node->link[dir]->link[!dir]))
+					node = rb_tree_rotate_double(node, !dir);
+			}
 		}
 	}
-
-	return newnode;
+	return node;
 }


@@ -102,36 +159,224 @@ struct rb_tree* rb_tree_create(rb_tree_compare compare, rb_tree_alloc a, rb_tree
 {
 	struct rb_tree* tree = a(sizeof(struct rb_tree));
 	tree->compare = compare;
-	tree->alloc = a;
-	tree->free = f;
+	tree->alloc = a ? a : hub_malloc;
+	tree->free = f ? f : hub_free;
+	tree->root = NULL;
+	tree->elements = 0;
+	tree->iterator.node = NULL;
+	tree->iterator.stack = list_create();
 	return tree;
 }

+
 void rb_tree_destroy(struct rb_tree* tree)
 {
-	rb_tree_free f = tree->free;
-	f(tree);
+	list_destroy(tree->iterator.stack);
+	tree->free(tree);
 }

-void* rb_tree_insert(struct rb_tree* tree, const void* key, const void* value)
+int rb_tree_insert(struct rb_tree* tree, const void* key, const void* value)
 {
-	struct rb_node* node = tree_insert(tree, key, value);
-	if (node)
-		return (void*) node->value;
-	return 0;
+	struct rb_node* node;
+	if (tree_search(tree, key))
+		return 0;
+	node = rb_tree_insert_r(tree, tree->root, key, value);
+	tree->root = node;
+	tree->root->red = 0;
+	tree->elements++;
+#ifdef RB_TREE_CHECKS
+	rb_tree_check(tree, node);
+#endif
+	return 1;
 }

-void* rb_tree_remove(struct rb_tree* tree, const void* key)
-{
+void null_node_free(struct rb_node* n) { }

+int rb_tree_remove(struct rb_tree* tree, const void* key)
+{
+	return rb_tree_remove_node(tree, key, &null_node_free);
+}
+
+int rb_tree_remove_node(struct rb_tree* tree, const void* key, rb_tree_free_node freecb)
+{
+	struct rb_node head = {0}; /* False tree root */
+	struct rb_node *q, *p, *g; /* Helpers */
+	struct rb_node *f = NULL;  /* Found item */
+	int dir = 1;
+
+	if (!tree->root)
+		return 0;
+
+	/* Set up helpers */
+	q = &head;
+	g = p = NULL;
+	q->link[1] = tree->root;
+
+	/* Search and push a red down */
+	while (q->link[dir])
+	{
+		int last = dir;
+		int res;
+
+		/* Update helpers */
+		g = p, p = q;
+		q = q->link[dir];
+		res = tree->compare(q->key, key);
+		dir = res < 0;
+
+		/* Save found node */
+		if (!res)
+			f = q;
+
+		/* Push the red node down */
+		if (!is_red(q) && !is_red(q->link[dir]))
+		{
+			if (is_red(q->link[!dir]))
+				p = p->link[last] = rb_tree_rotate_single(q, dir);
+			else if (!is_red(q->link[!dir]))
+			{
+				struct rb_node* s = p->link[!last];
+				if (s)
+				{
+					if (!is_red(s->link[!last]) && !is_red (s->link[last]))
+					{
+						/* Color flip */
+						p->red = 0;
+						s->red = 1;
+						q->red = 1;
+					}
+					else
+					{
+						int dir2 = g->link[1] == p;
+						if (is_red(s->link[last]))
+							g->link[dir2] = rb_tree_rotate_double(p, last);
+						else if (is_red(s->link[!last]))
+							g->link[dir2] = rb_tree_rotate_single(p, last);
+
+						/* Ensure correct coloring */
+						q->red = g->link[dir2]->red = 1;
+						g->link[dir2]->link[0]->red = 0;
+						g->link[dir2]->link[1]->red = 0;
+					}
+				}
+			}
+		}
+	}
+
+	/* Replace and remove if found */
+	if (f)
+	{
+		freecb(f);
+		f->key = q->key;
+		f->value = q->value;
+		p->link[p->link[1] == q] = q->link[q->link[0] == NULL];
+		tree->free(q);
+		tree->elements--;
+	 }
+
+	/* Update root and make it black */
+	tree->root = head.link[1];
+	if (tree->root != NULL)
+		tree->root->red = 0;
+
+#ifdef RB_TREE_CHECKS
+	rb_tree_check(tree, tree->root);
+#endif
+
+	return f != NULL;
 }

 void* rb_tree_get(struct rb_tree* tree, const void* key)
 {
 	struct rb_node* node = tree_search(tree, key);
 	if (node)
-		return node->value;
+		return (void*) node->value;
 	return 0;
 }

-#endif
+size_t rb_tree_size(struct rb_tree* tree)
+{
+	return tree->elements;
+}
+
+static void push(struct rb_tree* tree, struct rb_node* n)
+{
+	list_append(tree->iterator.stack, n);
+}
+
+static struct rb_node* pop(struct rb_tree* tree)
+{
+	struct rb_node* n = list_get_last(tree->iterator.stack);
+	if (n)
+		list_remove(tree->iterator.stack, n);
+	return n;
+}
+
+static struct rb_node* rb_it_set(struct rb_tree* tree, struct rb_node* n)
+{
+	tree->iterator.node = n;
+	return n;
+}
+
+static void null_free(void* ptr) { }
+
+struct rb_node* rb_tree_first(struct rb_tree* tree)
+{
+	struct rb_node* n = tree->root;
+	list_clear(tree->iterator.stack, &null_free);
+	while (n->link[0])
+	{
+		push(tree, n);
+		n = n->link[0];
+	}
+	return rb_it_set(tree, n);
+};
+
+
+static struct rb_node* rb_tree_traverse(struct rb_tree* tree, int dir)
+{
+	struct rb_node* n = tree->iterator.node;
+	struct rb_node* p; /* parent */
+
+	if (n->link[dir])
+	{
+		push(tree, n);
+		n = n->link[dir];
+		while (n->link[!dir])
+		{
+			list_append(tree->iterator.stack, n);
+			n = n->link[!dir];
+		}
+		return rb_it_set(tree, n);
+	}
+
+	// Need to walk upwards to the parent node.
+	p = pop(tree);
+	if (p)
+	{
+		// walk up in opposite direction
+		if (p->link[!dir] == n)
+			return rb_it_set(tree, p);
+
+		// walk up in hte current direction
+		while (p->link[dir] == n)
+		{
+			n = p;
+			p = pop(tree);
+			if (!p)
+				return rb_it_set(tree, NULL);
+		}
+		return rb_it_set(tree, p);
+	}
+	return rb_it_set(tree, NULL);
+}
+
+struct rb_node* rb_tree_next(struct rb_tree* tree)
+{
+	return rb_tree_traverse(tree, 1);
+}
+
+struct rb_node* rb_tree_prev(struct rb_tree* tree)
+{
+	return rb_tree_traverse(tree, 0);
+}
--- a/src/util/rbtree.h
+++ b/src/util/rbtree.h
@@ -1,6 +1,6 @@
 /*
 * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
 *
 * 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
@@ -20,18 +20,121 @@
 #ifndef HAVE_UHUB_RED_BLACK_TREE_H
 #define HAVE_UHUB_RED_BLACK_TREE_H

-struct rb_tree;
+struct rb_node
+{
+	const void* key;
+	const void* value; /* data */
+	int red;
+	struct rb_node* link[2];
+};
+
 typedef int (*rb_tree_compare)(const void* a, const void* b);
 typedef void* (*rb_tree_alloc)(size_t);
 typedef void (*rb_tree_free)(void*);
+typedef void (*rb_tree_free_node)(struct rb_node*);
+
+struct rb_iterator
+{
+	struct rb_node* node; // current node.
+	struct linked_list* stack; // stack from the top -- needed since we don't have parent pointers.
+};
+
+struct rb_tree
+{
+	struct rb_node* root;
+	size_t elements;
+	rb_tree_alloc alloc;
+	rb_tree_free free;
+	rb_tree_compare compare;
+	struct rb_iterator iterator;
+};


-extern struct rb_tree* rb_tree_create(rb_tree_compare, rb_tree_alloc, rb_tree_free);
+
+/**
+ * Create a tree.
+ *
+ * @param compare Comparison function
+ * @param alloc Allocator (if NULL then hub_malloc() is used)
+ * @param dealloc Deallocator (if NULL then hub_free() is used)
+ * @return a tree handle.
+ */
+extern struct rb_tree* rb_tree_create(rb_tree_compare compare, rb_tree_alloc alloc, rb_tree_free dealloc);
+
+/**
+ * Deletes the tree and all the nodes.
+ * But not the content inside the nodes.
+ */
 extern void rb_tree_destroy(struct rb_tree*);

-extern void* rb_tree_insert(struct rb_tree* tree, const void* key, const void* data);
-extern void* rb_tree_remove(struct rb_tree* tree, const void* key);
-extern void* rb_tree_get(struct rb_tree* tree, const void* key); 
+/**
+ * Insert a key into the tree, returns 1 if successful,
+ * or 0 if the key already existed.
+ */
+extern int rb_tree_insert(struct rb_tree* tree, const void* key, const void* data);
+
+/**
+ * Remove a key from the tree.
+ * Returns 1 if the node was removed, or 0 if it was not removed (i.e. not found!)
+ *
+ * NOTE: the content of the node is not freed if it needs to be then use rb_tree_remove_node
+ * where you can specify a callback cleanup function.
+ */
+extern int rb_tree_remove(struct rb_tree* tree, const void* key);
+
+/**
+ * Remove the node, but call the free callback before the node is removed.
+ * This is useful in cases where you need to deallocate the key and/or value from the node.
+ * Returns 1 if the node was removed, or 0 if not found.
+ */
+extern int rb_tree_remove_node(struct rb_tree* tree, const void* key, rb_tree_free_node free);
+
+/**
+ * Returns NULL if the key was not found in the tree.
+ */
+extern void* rb_tree_get(struct rb_tree* tree, const void* key);
+
+/**
+ * Returns the number of elements inside the tree.
+ */
+extern size_t rb_tree_size(struct rb_tree* tree);
+
+/**
+ * Returns the first node in the tree.
+ * (leftmost, or lowest value in sorted order).
+ *
+ * Example:
+ *
+ * <code>
+ * struct rb_node* it;
+ * for (it = rb_tree_first(tree); it; it = rb_tree_next())
+ * {
+ *    void* key = rb_iterator_key(it);
+ * 	  void* value = rb_iterator_value(it);
+ * }
+ * </code>
+ */
+extern struct rb_node* rb_tree_first(struct rb_tree* tree);
+
+/**
+ * Points the iterator at the next node.
+ * If the next node is NULL then the iterator becomes NULL too.
+ */
+extern struct rb_node* rb_tree_next(struct rb_tree* tree);
+extern struct rb_node* rb_tree_prev(struct rb_tree* tree);
+
+/**
+ * Returnst the key of the node pointed to by the iterator.
+ * If this iterator is the same as rb_tree_end() then NULL is returned.
+ */
+extern void* rb_iterator_key(struct rb_iterator* it);
+
+/**
+ * Returnst the value of the node pointed to by the iterator.
+ * If this iterator is the same as rb_tree_end() then the behavior is undefined.
+ */
+extern void* rb_iterator_value(struct rb_iterator* it);
+


 #endif /* HAVE_UHUB_RED_BLACK_TREE_H */
--- a/src/util/threads.c
+++ b/src/util/threads.c
@@ -0,0 +1,149 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * 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 "uhub.h"
+
+#ifdef POSIX_THREAD_SUPPORT
+
+struct pthread_data
+{
+	pthread_t handle;
+};
+
+void uhub_mutex_init(uhub_mutex_t* mutex)
+{
+	pthread_mutex_init(mutex, NULL);
+}
+
+void uhub_mutex_destroy(uhub_mutex_t* mutex)
+{
+	pthread_mutex_destroy(mutex);
+}
+
+void uhub_mutex_lock(uhub_mutex_t* mutex)
+{
+	pthread_mutex_lock(mutex);
+}
+
+void uhub_mutex_unlock(uhub_mutex_t* mutex)
+{
+	pthread_mutex_unlock(mutex);
+}
+
+int uhub_mutex_trylock(uhub_mutex_t* mutex)
+{
+	int ret = pthread_mutex_trylock(mutex);
+	return (ret == 0);
+}
+
+uhub_thread_t* uhub_thread_create(uhub_thread_start start, void* arg)
+{
+	struct pthread_data* thread = (struct pthread_data*) hub_malloc_zero(sizeof(struct pthread_data));
+	int ret = pthread_create(&thread->handle, NULL, start, arg);
+	if (ret != 0)
+	{
+		hub_free(thread);
+		thread = NULL;
+	}
+	return thread;
+}
+
+void uhub_thread_cancel(uhub_thread_t* thread)
+{
+	pthread_cancel(thread->handle);
+}
+
+void* uhub_thread_join(uhub_thread_t* thread)
+{
+	void* ret = NULL;
+	pthread_join(thread->handle, &ret);
+	hub_free(thread);
+	return ret;
+}
+
+
+#endif /* POSIX_THREAD_SUPPORT */
+
+#ifdef WINTHREAD_SUPPORT
+
+struct winthread_data
+{
+	uhub_thread_t* handle;
+	uhub_thread_start start;
+	void* arg;
+};
+
+static DWORD WINAPI uhub_winthread_start(void* ptr)
+{
+	struct winthread_data* data = (struct winthread_data*) ptr;
+	DWORD ret = (DWORD) data->start(data->arg);
+	return ret;
+}
+
+void uhub_mutex_init(uhub_mutex_t* mutex)
+{
+	InitializeCriticalSection(mutex);
+}
+
+void uhub_mutex_destroy(uhub_mutex_t* mutex)
+{
+	DeleteCriticalSection(mutex);
+}
+
+void uhub_mutex_lock(uhub_mutex_t* mutex)
+{
+	EnterCriticalSection(mutex);
+}
+
+void uhub_mutex_unlock(uhub_mutex_t* mutex)
+{
+	LeaveCriticalSection(mutex);
+}
+
+int uhub_mutex_trylock(uhub_mutex_t* mutex)
+{
+	return TryEnterCriticalSection(mutex);
+}
+
+uhub_thread_t* uhub_thread_create(uhub_thread_start start, void* arg)
+{
+	struct winthread_data* thread = (struct winthread_data*) hub_malloc_zero(sizeof(struct winthread_data));
+	thread->start = start;
+	thread->arg = arg;
+	thread->handle = CreateThread(NULL, 0, uhub_winthread_start, thread, 0, 0);
+	return thread;
+}
+
+void uhub_thread_cancel(uhub_thread_t* thread)
+{
+	TerminateThread(thread->handle, 0);
+}
+
+void* uhub_thread_join(uhub_thread_t* thread)
+{
+	void* ret = NULL;
+	DWORD exitCode;
+	WaitForSingleObject(thread->handle, INFINITE);
+	GetExitCodeThread(thread->handle, &exitCode);
+	ret = &exitCode;
+	CloseHandle(thread->handle);
+	hub_free(thread);
+	return ret;
+}
+#endif /* WINTHREAD_SUPPORT */
--- a/src/util/threads.h
+++ b/src/util/threads.h
@@ -0,0 +1,49 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * 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/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_UTIL_THREADS_H
+#define HAVE_UHUB_UTIL_THREADS_H
+
+typedef void*(*uhub_thread_start)(void*) ;
+
+#ifdef POSIX_THREAD_SUPPORT
+typedef struct pthread_data uhub_thread_t;
+typedef pthread_mutex_t uhub_mutex_t;
+#endif
+
+#ifdef WINTHREAD_SUPPORT
+struct winthread_data;
+typedef struct winthread_data uhub_thread_t;
+typedef CRITICAL_SECTION uhub_mutex_t;
+#endif
+
+// Mutexes
+extern void uhub_mutex_init(uhub_mutex_t* mutex);
+extern void uhub_mutex_destroy(uhub_mutex_t* mutex);
+extern void uhub_mutex_lock(uhub_mutex_t* mutex);
+extern void uhub_mutex_unlock(uhub_mutex_t* mutex);
+extern int uhub_mutex_trylock(uhub_mutex_t* mutex);
+
+// Threads
+uhub_thread_t* uhub_thread_create(uhub_thread_start start, void* arg);
+void uhub_thread_cancel(uhub_thread_t* thread);
+void* uhub_thread_join(uhub_thread_t* thread);
+
+#endif /* HAVE_UHUB_UTIL_THREADS_H */
+
Author	SHA1	Message	Date
Jan Vidar Krey	594801df46	Fix windows compile issues.	2012-11-01 21:52:33 +01:00
Jan Vidar Krey	3dcbb63a31	Implemented a simlpe red-black tree which should give better performance for certain lookups. The rb_tree will act as a general purpose key/value storage, and also give a performance boost in the cases where the other simple alternative would be to use a linked_list. On average this should give on average O(log n) lookups, while the linked_list would be O(n) at worst.	2012-11-01 21:46:44 +01:00
Jan Vidar Krey	5d6184961b	Fix a failing test on Windows.	2012-11-01 21:18:49 +01:00
Jan Vidar Krey	b17e88573e	Fixed Windows VC compile issues with autotests.	2012-11-01 21:10:51 +01:00
Jan Vidar Krey	2d2ccc0039	Merge branch 'async_dns_api'	2012-11-01 10:42:19 +01:00
Jan Vidar Krey	0a2f9c4b79	Merge branch 'autotest'	2012-11-01 10:40:51 +01:00
Jan Vidar Krey	ae62c35cb9	Disable SSL compression.	2012-11-01 10:39:31 +01:00
Jan Vidar Krey	2ec2e73f16	Make sure we always build the autotests. Caveat, need to run the update script manually after changing the tests (adding or removing tests). However, modifying existing tests does not require running the update script. Added a copy of exotic in the repository exotic automatically generates the skeleton code around the autotests in order to schedule the tests.	2012-10-25 17:27:45 +02:00
Jan Vidar Krey	d4763e54db	Fixed memory leaks.	2012-10-25 04:13:45 +02:00
Jan Vidar Krey	38b19f633d	Fix memory leaks and report "host is not found" correctly.	2012-10-25 04:13:05 +02:00
Jan Vidar Krey	d106ecdc65	Bugfixes for pthreads.	2012-10-25 04:10:42 +02:00
Jan Vidar Krey	99a2307d1d	Simple compile fix.	2012-10-25 00:44:21 +02:00
Jan Vidar Krey	470c936e63	Converted the DNS resolver to work with the new threading API abstraction.	2012-10-25 00:40:16 +02:00
Jan Vidar Krey	168fc5bfcc	Abstracted the threading code so that it works with Winthreads and pthreads.	2012-10-25 00:39:44 +02:00
Jan Vidar Krey	b34b90f95a	Start using the async DNS API.	2012-10-24 23:22:10 +02:00
Jan Vidar Krey	793790d089	Initial implementation of an async DNS client API with getaddrinfo + pthreads.	2012-10-24 23:19:14 +02:00
Jan Vidar Krey	19559f4974	Make sure we count OpenSSL traffic for the byte IO statistics.	2012-10-18 11:40:18 +02:00
Jan Vidar Krey	b999068555	Use OpenSSL by default.	2012-10-17 19:02:32 +00:00
Jan Vidar Krey	4385266bb7	Free all memory in case the hub does not start because of port already in use.	2012-10-17 20:54:46 +02:00
Jan Vidar Krey	c50eb90bee	Removed the last bits of OpenSSL code called directly	2012-10-17 20:53:05 +02:00
Jan Vidar Krey	1e0927f510	Update copyright year.	2012-10-17 20:00:52 +02:00
Jan Vidar Krey	b9d43c784c	Merge branch 'master' of github.com:janvidar/uhub Conflicts: CMakeLists.txt	2012-10-17 19:59:02 +02:00
Jan Vidar Krey	46d365cafe	Merge branch 'gnutls_work'	2012-10-17 15:47:16 +02:00
Jan Vidar Krey	3a8c91004e	fixup! Add possibility to specify UHUB_REVISION manually.	2012-10-15 20:27:43 +02:00
Boris Pek	deaadd053b	Add possibility to specify UHUB_REVISION manually.	2012-10-15 20:24:42 +02:00
Jan Vidar Krey	c28a5d3a9b	Merge branch 'master' of github.com:janvidar/uhub	2012-10-15 20:20:17 +02:00
Jan Vidar Krey	8b06a75d8e	Revert "Add possibility to specify UHUB_REVISION manually." This reverts commit `dcfcf3110d`.	2012-10-15 00:24:59 +02:00
Jan Vidar Krey	e6cb7a7e10	Revert "Add possibility to specify UHUB_REVISION manually." This reverts commit `dcfcf3110d`.	2012-10-14 22:24:33 +00:00
Jan Vidar Krey	82caa6b81f	Merge pull request #14 from tehnick/fix-build-on-kfreebsd-any Fix build in Debian GNU/kFreeBSD.	2012-10-14 15:19:21 -07:00
Boris Pek	ddfbb919a7	Fix build in Debian GNU/kFreeBSD.	2012-10-14 02:13:10 +03:00
Jan Vidar Krey	7fae42aa4d	Merge pull request #12 from tehnick/fix-version Add possibility to specify UHUB_REVISION manually.	2012-10-13 10:34:39 -07:00
Jan Vidar Krey	ba59e1a00e	Merge pull request #13 from tehnick/cmake-up Simplify CMakeLists.txt	2012-10-13 10:34:23 -07:00
Jan Vidar Krey	4fcfee8e82	Merge pull request #11 from tehnick/fix-plugins-location Use directory /usr/lib/uhub/ instead of /var/lib/uhub/	2012-10-13 10:33:09 -07:00
Boris Pek	63171b0ce2	Simplify CMakeLists.txt	2012-10-13 20:13:15 +03:00
Boris Pek	dcfcf3110d	Add possibility to specify UHUB_REVISION manually.	2012-10-13 19:46:44 +03:00
Boris Pek	53a5f5a243	Use directory /usr/lib/uhub/ instead of /var/lib/uhub/ in according with FHS (Filesystem Hierarchy Standard).	2012-10-13 18:48:24 +03:00
Jan Vidar Krey	af083efb0c	fixup! Don't compile the utils files multiple times.	2012-10-09 22:14:38 +02:00
Jan Vidar Krey	e7aa63f3bd	Don't compile the utils files multiple times.	2012-10-09 22:09:25 +02:00
Jan Vidar Krey	279c932b67	fixup! Add install make rule.	2012-10-09 19:31:54 +02:00