Fix crash if unable to load plugin.

Related to https://github.com/janvidar/uhub/pull/28

.gitignore

@@ -21,4 +21,5 @@ debian/uhub.postrm.debhelper
 debian/uhub.prerm.debhelper
 debian/uhub.substvars
 uhub-passwd
-src/version.h
+src/version.h
+src/system.h

.travis.yml

@@ -0,0 +1,11 @@
+language: cpp
+compiler:
+  - gcc
+  - clang
+env:
+  - CONFIG=minimal
+  - CONFIG=full
+install:
+  - autotest/travis/install-build-depends.sh
+script:
+  - autotest/travis/build-and-test.sh

AUTHORS

@@ -4,7 +4,7 @@ Authors of uhub
 Jan Vidar Krey, Design and implementation
 E_zombie, Centos/RedHat customization scripts and heavy load testing
 FleetCommand, Hub topic plugin code
-MiMic, Implemented user commands
+MiMic, Implemented user commands, and plugins
 Boris Pek (tehnick), Debian/Ubuntu packaging
 Tillmann Karras (Tilka), Misc. bug fixes
 Yoran Heling (Yorhel), TLS/SSL handshake detection bugfixes

BUGS

@@ -1,2 +1 @@
-Bugs are tracked on: http://bugs.extatic.org/
-
+Bugs are tracked on: https://github.com/janvidar/uhub/issues

CMakeLists.txt

@@ -1,6 +1,6 @@
  ##
 ## Makefile for uhub
-## Copyright (C) 2007-2012, Jan Vidar Krey <janvidar@extatic.org>
+## Copyright (C) 2007-2013, Jan Vidar Krey <janvidar@extatic.org>
  #
 
 cmake_minimum_required (VERSION 2.8.2)
@@ -9,14 +9,14 @@ project (uhub NONE)
 enable_language(C)
 
 set (UHUB_VERSION_MAJOR 0)
-set (UHUB_VERSION_MINOR 4)
+set (UHUB_VERSION_MINOR 5)
 set (UHUB_VERSION_PATCH 1)
 
 set (PROJECT_SOURCE_DIR "${CMAKE_SOURCE_DIR}/src")
 set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake/Modules)
 
 option(RELEASE "Release build, debug build if disabled" ON)
-option(LINK_SUPPORT "Allow hub linking" OFF)
+option(LOWLEVEL_DEBUG, "Enable low level debug messages." OFF)
 option(SSL_SUPPORT "Enable SSL support" ON)
 option(USE_OPENSSL "Use OpenSSL's SSL support" ON )
 option(SYSTEMD_SUPPORT "Enable systemd notify and journal logging" OFF)
@@ -25,6 +25,24 @@ option(ADC_STRESS "Enable the stress tester client" OFF)
 find_package(Git)
 find_package(Sqlite3)
 
+include(TestBigEndian)
+include(CheckSymbolExists) 
+include(CheckIncludeFile)
+include(CheckTypeSize)
+
+#Some functions need this to be found
+add_definitions(-D_GNU_SOURCE)
+set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} -D_GNU_SOURCE")
+
+TEST_BIG_ENDIAN(BIGENDIAN)
+if (BIGENDIAN)
+	add_definitions(-DARCH_BIGENDIAN)
+endif()
+
+if (NOT RELEASE)
+        add_definitions(-DDEBUG)
+endif()
+
 if (SSL_SUPPORT)
 	if (USE_OPENSSL)
 		find_package(OpenSSL)
@@ -32,22 +50,35 @@ if (SSL_SUPPORT)
 		find_package(GnuTLS)
 	endif()
 	if (NOT GNUTLS_FOUND AND NOT OPENSSL_FOUND)
-		message(FATAL_ERROR "Neither OpenSSL nor GnuTLS are not found!")
+		message(FATAL_ERROR "Neither OpenSSL nor GnuTLS were found!")
 	endif()
 endif()
 
+if (NOT SQLITE3_FOUND)
+    message(FATAL_ERROR "SQLite3 is not found!")
+endif()
+
 if (SYSTEMD_SUPPORT)
         INCLUDE(FindPkgConfig)
-        pkg_search_module(SD_DAEMON REQUIRED libsystemd-daemon)
-        pkg_search_module(SD_JOURNAL REQUIRED libsystemd-journal)
+        pkg_search_module(SD REQUIRED libsystemd)
 endif()
 
 if (MSVC)
 	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
+check_include_file(stdint.h HAVE_STDINT_H)
+check_include_file(sys/types.h HAVE_SYS_TYPES_H)
+if (HAVE_SYS_TYPES_H)
+set (CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES} "sys/types.h")
+endif()
+check_type_size( ssize_t SSIZE_T )
+check_symbol_exists(memmem string.h HAVE_MEMMEM)
+check_symbol_exists(strndup string.h HAVE_STRNDUP)
+
 include_directories("${PROJECT_SOURCE_DIR}")
 include_directories(${SQLITE3_INCLUDE_DIRS})
+link_directories(${SQLITE3_LIBRARY_DIRS})
 
 file (GLOB uhub_SOURCES ${PROJECT_SOURCE_DIR}/core/*.c)
 list (REMOVE_ITEM uhub_SOURCES
@@ -67,7 +98,7 @@ 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)
+if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
 	set_target_properties(utils PROPERTIES COMPILE_FLAGS -fPIC)
 	set_target_properties(network PROPERTIES COMPILE_FLAGS -fPIC)
 endif()
@@ -76,7 +107,7 @@ 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_executable(autotest-bin ${CMAKE_SOURCE_DIR}/autotest/test.c ${uhub_SOURCES} )
 add_executable(uhub-passwd ${PROJECT_SOURCE_DIR}/tools/uhub-passwd.c)
 
 add_library(mod_example MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_example.c)
@@ -84,6 +115,7 @@ 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_history_sqlite MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_chat_history_sqlite.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)
 add_library(mod_no_guest_downloads MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_no_guest_downloads.c)
@@ -91,7 +123,7 @@ add_library(mod_auth_sqlite MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_auth_sqlite
 
 if(WIN32)
 	target_link_libraries(uhub ws2_32)
-	target_link_libraries(test ws2_32)
+	target_link_libraries(autotest-bin ws2_32)
 	target_link_libraries(mod_logging ws2_32)
 	target_link_libraries(mod_welcome ws2_32)
 endif()
@@ -103,6 +135,7 @@ set_target_properties(
 	mod_auth_simple
 	mod_auth_sqlite
 	mod_chat_history
+	mod_chat_history_sqlite
 	mod_chat_only
 	mod_no_guest_downloads
 	mod_topic
@@ -110,12 +143,13 @@ set_target_properties(
 
 target_link_libraries(uhub ${CMAKE_DL_LIBS} adc network utils)
 target_link_libraries(uhub-passwd ${SQLITE3_LIBRARIES} utils)
-target_link_libraries(test ${CMAKE_DL_LIBS} adc network utils)
+target_link_libraries(autotest-bin ${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_auth_sqlite ${SQLITE3_LIBRARIES} utils)
 target_link_libraries(mod_chat_history utils)
+target_link_libraries(mod_chat_history_sqlite ${SQLITE3_LIBRARIES} utils)
 target_link_libraries(mod_no_guest_downloads utils)
 target_link_libraries(mod_chat_only utils)
 target_link_libraries(mod_logging utils)
@@ -130,7 +164,7 @@ if(UNIX)
 	add_executable(uhub-admin ${PROJECT_SOURCE_DIR}/tools/admin.c)
 	target_link_libraries(uhub-admin adcclient adc network utils pthread)
 	target_link_libraries(uhub pthread)
-	target_link_libraries(test pthread)
+	target_link_libraries(autotest-bin pthread)
 
 	if (ADC_STRESS)
 		add_executable(adcrush ${PROJECT_SOURCE_DIR}/tools/adcrush.c ${adcclient_SOURCES})
@@ -169,7 +203,7 @@ endif()
 
 if(SSL_SUPPORT)
 	target_link_libraries(uhub ${SSL_LIBS})
-	target_link_libraries(test ${SSL_LIBS})
+	target_link_libraries(autotest-bin ${SSL_LIBS})
 	if(UNIX)
 		target_link_libraries(uhub-admin ${SSL_LIBS})
 	endif()
@@ -181,31 +215,33 @@ if(SSL_SUPPORT)
 endif()
 
 if (SYSTEMD_SUPPORT)
-        target_link_libraries(uhub ${SD_DAEMON_LIBRARIES})
-        target_link_libraries(uhub ${SD_JOURNAL_LIBRARIES})
-        target_link_libraries(test ${SD_DAEMON_LIBRARIES})
-        target_link_libraries(test ${SD_JOURNAL_LIBRARIES})
-        target_link_libraries(uhub-passwd ${SD_JOURNAL_LIBRARIES})
-        target_link_libraries(uhub-admin ${SD_JOURNAL_LIBRARIES})
-        include_directories(${SD_DAEMON_INCLUDE_DIRS})
-        include_directories(${SD_JOURNAL_INCLUDE_DIRS})
+        target_link_libraries(uhub ${SD_LIBRARIES})
+        target_link_libraries(autotest-bin ${SD_LIBRARIES})
+        target_link_libraries(uhub-passwd ${SD_LIBRARIES})
+        target_link_libraries(uhub-admin ${SD_LIBRARIES})
+        include_directories(${SD_INCLUDE_DIRS})
         add_definitions(-DSYSTEMD)
 endif()
 
 configure_file ("${PROJECT_SOURCE_DIR}/version.h.in" "${PROJECT_SOURCE_DIR}/version.h")
+configure_file ("${PROJECT_SOURCE_DIR}/system.h.in" "${PROJECT_SOURCE_DIR}/system.h")
 
-mark_as_advanced(FORCE CMAKE_BUILD_TYPE)
-if (RELEASE)
-	set(CMAKE_BUILD_TYPE Release)
-	add_definitions(-DNDEBUG)
-else()
-	set(CMAKE_BUILD_TYPE Debug)
-	# add_definitions(-DDEBUG)
+# mark_as_advanced(FORCE CMAKE_BUILD_TYPE)
+# if (RELEASE)
+#	set(CMAKE_BUILD_TYPE Release)
+#	add_definitions(-DNDEBUG)
+#else()
+#	set(CMAKE_BUILD_TYPE Debug)
+#	add_definitions(-DDEBUG)
+#endif()
+
+if (LOWLEVEL_DEBUG)
+	add_definitions(-DLOWLEVEL_DEBUG)
 endif()
 
 if (UNIX)
 	install( TARGETS uhub uhub-passwd 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 mod_no_guest_downloads DESTINATION /usr/lib/uhub/ OPTIONAL )
+	install( TARGETS mod_example mod_welcome mod_logging mod_auth_simple mod_auth_sqlite mod_chat_history mod_chat_history_sqlite mod_chat_only mod_topic mod_no_guest_downloads 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 )
 endif()
 

ChangeLog

@@ -1,3 +1,23 @@
+0.5.0:
+- Use TLS 1.2 and strong ciphers by default, but made this configurable.
+- Fix TLS event handling which caused some busy loops
+- TLS: Support certificate chains
+- Fix bug #211: Better Hublist pinger support by adding the AP flag of the INF message.
+- Fix bug #198:  Timers could cause infinite loops
+- Sqlite3 is now mandatory
+- Added mod_chat_history_sqlite and mod_chat_is_privileged.
+- Support for systemd notify and journal logging
+- Improved flood control counting to strictly not allow more than the given amount of messages in the configured interval.
+- Optimize lookups by CID and nick.
+- Added an NMDC and ADC hub redirectors written in Python.
+- Fix all Clang compile warnings.
+- Install uhub-passwd also.
+- Add support for detecting HTTP connections to the hub. Enough to tell browsers to stop calling.
+- Compile fixes for OpenBSD, including warnings about strcat.
+- Fix crashing autotest due to wrong initialization of the usermanager.
+- mod_topic: check argument for NULL
+- rename !cleartopic to !resettopic
+
 0.4.1:
 - Converted to CMake which replaces Visual Studio project files and GNU makefiles
 - Fix issues with SSL causing excessive CPU usage.

autotest/test.c

@@ -516,6 +516,15 @@ int main(int argc, char** argv)
 	exotic_add_test(&handle, &exotic_test_list_get_last_prev_2, "list_get_last_prev_2");
 	exotic_add_test(&handle, &exotic_test_list_get_last_prev_next_1, "list_get_last_prev_next_1");
 	exotic_add_test(&handle, &exotic_test_list_clear, "list_clear");
+	exotic_add_test(&handle, &exotic_test_list_remove_first_1_1, "list_remove_first_1_1");
+	exotic_add_test(&handle, &exotic_test_list_remove_first_1_2, "list_remove_first_1_2");
+	exotic_add_test(&handle, &exotic_test_list_remove_first_1_3, "list_remove_first_1_3");
+	exotic_add_test(&handle, &exotic_test_list_remove_first_1_4, "list_remove_first_1_4");
+	exotic_add_test(&handle, &exotic_test_list_remove_first_1_5, "list_remove_first_1_5");
+	exotic_add_test(&handle, &exotic_test_list_append_list_1, "list_append_list_1");
+	exotic_add_test(&handle, &exotic_test_list_append_list_2, "list_append_list_2");
+	exotic_add_test(&handle, &exotic_test_list_append_list_3, "list_append_list_3");
+	exotic_add_test(&handle, &exotic_test_list_clear_list_last, "list_clear_list_last");
 	exotic_add_test(&handle, &exotic_test_list_destroy_1, "list_destroy_1");
 	exotic_add_test(&handle, &exotic_test_list_destroy_2, "list_destroy_2");
 	exotic_add_test(&handle, &exotic_test_test_message_refc_1, "test_message_refc_1");
@@ -697,6 +706,34 @@ int main(int argc, char** argv)
 	exotic_add_test(&handle, &exotic_test_utf8_valid_10, "utf8_valid_10");
 	exotic_add_test(&handle, &exotic_test_utf8_valid_11, "utf8_valid_11");
 	exotic_add_test(&handle, &exotic_test_utf8_valid_12, "utf8_valid_12");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_13, "utf8_valid_13");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_14, "utf8_valid_14");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_15, "utf8_valid_15");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_16, "utf8_valid_16");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_17, "utf8_valid_17");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_18, "utf8_valid_18");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_19, "utf8_valid_19");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_20, "utf8_valid_20");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_21, "utf8_valid_21");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_22, "utf8_valid_22");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_23, "utf8_valid_23");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_24, "utf8_valid_24");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_25, "utf8_valid_25");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_26, "utf8_valid_26");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_27, "utf8_valid_27");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_28, "utf8_valid_28");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_29, "utf8_valid_29");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_30, "utf8_valid_30");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_31, "utf8_valid_31");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_32, "utf8_valid_32");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_33, "utf8_valid_33");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_34, "utf8_valid_34");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_35, "utf8_valid_35");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_36, "utf8_valid_36");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_37, "utf8_valid_37");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_38, "utf8_valid_38");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_39, "utf8_valid_39");
+	exotic_add_test(&handle, &exotic_test_utf8_valid_40, "utf8_valid_40");
 	exotic_add_test(&handle, &exotic_test_rbtree_create_destroy, "rbtree_create_destroy");
 	exotic_add_test(&handle, &exotic_test_rbtree_create_1, "rbtree_create_1");
 	exotic_add_test(&handle, &exotic_test_rbtree_size_0, "rbtree_size_0");
@@ -723,7 +760,8 @@ int main(int argc, char** argv)
 	exotic_add_test(&handle, &exotic_test_rbtree_size_4, "rbtree_size_4");
 	exotic_add_test(&handle, &exotic_test_rbtree_check_10000, "rbtree_check_10000");
 	exotic_add_test(&handle, &exotic_test_rbtree_iterate_10000, "rbtree_iterate_10000");
-	exotic_add_test(&handle, &exotic_test_rbtree_remove_5000, "rbtree_remove_5000");
+	exotic_add_test(&handle, &exotic_test_rbtree_remove_10000, "rbtree_remove_10000");
+	exotic_add_test(&handle, &exotic_test_rbtree_destroy_1, "rbtree_destroy_1");
 	exotic_add_test(&handle, &exotic_test_sid_create_pool, "sid_create_pool");
 	exotic_add_test(&handle, &exotic_test_sid_check_0a, "sid_check_0a");
 	exotic_add_test(&handle, &exotic_test_sid_check_0b, "sid_check_0b");
@@ -761,6 +799,7 @@ int main(int argc, char** argv)
 	exotic_add_test(&handle, &exotic_test_timer_add_5_events_1, "timer_add_5_events_1");
 	exotic_add_test(&handle, &exotic_test_timer_check_5_events_1, "timer_check_5_events_1");
 	exotic_add_test(&handle, &exotic_test_timer_process_5_events_1, "timer_process_5_events_1");
+	exotic_add_test(&handle, &exotic_test_timer_shutdown, "timer_shutdown");
 	exotic_add_test(&handle, &exotic_test_tokenizer_basic_0, "tokenizer_basic_0");
 	exotic_add_test(&handle, &exotic_test_tokenizer_basic_1, "tokenizer_basic_1");
 	exotic_add_test(&handle, &exotic_test_tokenizer_basic_1a, "tokenizer_basic_1a");
@@ -951,7 +990,6 @@ int exotic_initialize(struct exotic_handle* handle, int argc, char** argv)
 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");

autotest/test_commands.tcc

@@ -17,6 +17,8 @@ static int result = 0;
 
 EXO_TEST(setup, {
 	hub = hub_malloc_zero(sizeof(struct hub_info));
+	hub->config = hub_malloc_zero(sizeof(struct hub_config));
+	config_defaults(hub->config);
 	cbase = command_initialize(hub);
 	hub->commands = cbase;
 	hub->users = uman_init();
@@ -246,6 +248,8 @@ EXO_TEST(command_destroy, {
 EXO_TEST(cleanup, {
 	uman_shutdown(hub->users);
 	command_shutdown(hub->commands);
+	free_config(hub->config);
+	hub_free(hub->config);
 	hub_free(hub);
 	return 1;
 });

autotest/test_inf.tcc

@@ -14,10 +14,8 @@ 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();
-	inf_hub->users->sids = sid_pool_create(500);
 	
+	inf_hub->users = uman_init();
 	inf_hub->acl = (struct acl_handle*) hub_malloc_zero(sizeof(struct acl_handle));
 	inf_hub->config = (struct hub_config*) hub_malloc_zero(sizeof(struct hub_config));
 	
@@ -27,12 +25,9 @@ static void inf_create_hub()
 
 static void inf_destroy_hub()
 {
-	/* FIXME */
-	list_destroy(inf_hub->users->list);
-	sid_pool_destroy(inf_hub->users->sids);
+	uman_shutdown(inf_hub->users);
 	acl_shutdown(inf_hub->acl);
 	free_config(inf_hub->config);
-	hub_free(inf_hub->users);
 	hub_free(inf_hub->acl);
 	hub_free(inf_hub->config);
 	hub_free(inf_hub);

autotest/test_list.tcc

@@ -1,10 +1,16 @@
 #include <uhub.h>
 
 static struct linked_list* list = NULL;
+static struct linked_list* list2 = NULL;
 
 static char A[2] = { 'A', 0 };
 static char B[2] = { 'B', 0 };
 static char C[2] = { 'C', 0 };
+static char A2[2] = { 'a', 0 };
+static char B2[2] = { 'b', 0 };
+static char C2[2] = { 'c', 0 };
+
+
 
 static void null_free(void* ptr)
 {
@@ -124,6 +130,83 @@ EXO_TEST(list_clear, {
 	return list->size == 0 && list->first == 0 && list->last == 0 && list->iterator == 0;
 });
 
+static int g_remove_flag = 0;
+static void null_free_inc_flag(void* ptr)
+{
+	(void) ptr;
+	g_remove_flag++;
+}
+
+EXO_TEST(list_remove_first_1_1,
+{
+	list_append(list, A);
+	list_append(list, B);
+	list_append(list, C);
+	return list->size == 3;
+});
+
+EXO_TEST(list_remove_first_1_2,
+{
+	g_remove_flag = 0;
+	list_remove_first(list, null_free_inc_flag);
+	return list->size == 2 && g_remove_flag == 1;
+});
+
+EXO_TEST(list_remove_first_1_3,
+{
+	list_remove_first(list, NULL);
+	return list->size == 1;
+});
+
+EXO_TEST(list_remove_first_1_4,
+{
+	list_remove_first(list, NULL);
+	return list->size == 0;
+});
+
+
+EXO_TEST(list_remove_first_1_5,
+{
+	list_remove_first(list, NULL);
+	return list->size == 0;
+});
+
+
+EXO_TEST(list_append_list_1,
+{
+	list_append(list, A);
+	list_append(list, B);
+	list_append(list, C);
+	list2 = list_create();
+	list_append(list2, A2);
+	list_append(list2, B2);
+	list_append(list2, C2);
+	return list->size == 3 && list2->size == 3;
+});
+
+EXO_TEST(list_append_list_2,
+{
+	list_append_list(list, list2);
+	return list->size == 6 && list2->size == 0;
+});
+
+EXO_TEST(list_append_list_3,
+{
+	list_destroy(list2);
+	return list_get_index(list, 0) == A &&
+			list_get_index(list, 1) == B &&
+			list_get_index(list, 2) == C &&
+			list_get_index(list, 3) == A2 &&
+			list_get_index(list, 4) == B2 &&
+			list_get_index(list, 5) == C2;
+});
+
+EXO_TEST(list_clear_list_last,
+{
+	list_clear(list, &null_free);
+	return 1;
+});
+
 
 EXO_TEST(list_destroy_1, {
 	list_destroy(list);

autotest/test_misc.tcc

@@ -107,6 +107,7 @@ 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
+static const char test_utf_seq_10[] = { 0xF0, 0x9F, 0x98, 0x81, 0x00}; // valid
 
 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); });
@@ -117,5 +118,61 @@ 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); });
+EXO_TEST(utf8_valid_13, { return is_valid_utf8(test_utf_seq_10); });
 
+// Limits of utf-8
+static const char test_utf_seq_11[] = { 0x7F, 0x00 }; // valid last 7-bit character
+static const char test_utf_seq_12[] = { 0x80, 0x00 }; // invalid truncated string
+static const char test_utf_seq_13[] = { 0xBF, 0x00 }; // invalid truncated string
+static const char test_utf_seq_14[] = { 0xC0, 0x80, 0x00 }; // invalid out of 2 bytes range
+static const char test_utf_seq_15[] = { 0xC1, 0x7F, 0x00 }; // invalid out of 2 bytes range
+static const char test_utf_seq_16[] = { 0xC2, 0x00 }; // invalid truncated string
+static const char test_utf_seq_17[] = { 0xC2, 0x80, 0x00 }; // valid
+static const char test_utf_seq_18[] = { 0xDF, 0xBF, 0x00 }; // valid
+static const char test_utf_seq_19[] = { 0xE0, 0x80, 0x80, 0x00 }; // invalid out of 3 bytes range
+static const char test_utf_seq_20[] = { 0xE0, 0x9F, 0xBF, 0x00 }; // invalid out of 3 bytes range
+static const char test_utf_seq_21[] = { 0xE0, 0x00 }; // invalid truncated string
+static const char test_utf_seq_22[] = { 0xE0, 0xA0, 0x00 }; // invalid truncated string
+static const char test_utf_seq_23[] = { 0xE0, 0xA0, 0x80, 0x00 }; // valid
+static const char test_utf_seq_24[] = { 0xEC, 0x9F, 0xBF, 0x00 }; // valid
+static const char test_utf_seq_25[] = { 0xED, 0xA0, 0x80, 0x00 }; // invalid surrogate
+static const char test_utf_seq_26[] = { 0xED, 0xBF, 0xBF, 0x00 }; // invalid surrogate
+static const char test_utf_seq_27[] = { 0xEF, 0x80, 0x80, 0x00 }; // valid
+static const char test_utf_seq_28[] = { 0xEF, 0xBF, 0xBF, 0x00 }; // valid
+static const char test_utf_seq_29[] = { 0xF0, 0x80, 0x80, 0x80, 0x00 }; // invalid out of 4 bytes range
+static const char test_utf_seq_30[] = { 0xF0, 0x8F, 0xBF, 0xBF, 0x00 }; // invalid out of 4 bytes range
+static const char test_utf_seq_31[] = { 0xF0, 0x00 }; // invalid truncated string
+static const char test_utf_seq_32[] = { 0xF0, 0x90, 0x00 }; // invalid truncated string
+static const char test_utf_seq_33[] = { 0xF0, 0x90, 0x80, 0x00 }; // invalid truncated string
+static const char test_utf_seq_34[] = { 0xF0, 0x90, 0x80, 0x80, 0x00 }; // valid
+static const char test_utf_seq_35[] = { 0xF4, 0x8F, 0xBF, 0xBF, 0x00 }; // valid
+static const char test_utf_seq_36[] = { 0xF4, 0x90, 0x80, 0x80, 0x00 }; // invalid out of 4 bytes range
+static const char test_utf_seq_37[] = { 0xFF, 0xBF, 0xBF, 0xBF, 0x00 }; // invalid out of 4 bytes range
 
+EXO_TEST(utf8_valid_14, { return is_valid_utf8(test_utf_seq_11); });
+EXO_TEST(utf8_valid_15, { return !is_valid_utf8(test_utf_seq_12); });
+EXO_TEST(utf8_valid_16, { return !is_valid_utf8(test_utf_seq_13); });
+EXO_TEST(utf8_valid_17, { return !is_valid_utf8(test_utf_seq_14); });
+EXO_TEST(utf8_valid_18, { return !is_valid_utf8(test_utf_seq_15); });
+EXO_TEST(utf8_valid_19, { return !is_valid_utf8(test_utf_seq_16); });
+EXO_TEST(utf8_valid_20, { return is_valid_utf8(test_utf_seq_17); });
+EXO_TEST(utf8_valid_21, { return is_valid_utf8(test_utf_seq_18); });
+EXO_TEST(utf8_valid_22, { return !is_valid_utf8(test_utf_seq_19); });
+EXO_TEST(utf8_valid_23, { return !is_valid_utf8(test_utf_seq_20); });
+EXO_TEST(utf8_valid_24, { return !is_valid_utf8(test_utf_seq_21); });
+EXO_TEST(utf8_valid_25, { return !is_valid_utf8(test_utf_seq_22); });
+EXO_TEST(utf8_valid_26, { return is_valid_utf8(test_utf_seq_23); });
+EXO_TEST(utf8_valid_27, { return is_valid_utf8(test_utf_seq_24); });
+EXO_TEST(utf8_valid_28, { return !is_valid_utf8(test_utf_seq_25); });
+EXO_TEST(utf8_valid_29, { return !is_valid_utf8(test_utf_seq_26); });
+EXO_TEST(utf8_valid_30, { return is_valid_utf8(test_utf_seq_27); });
+EXO_TEST(utf8_valid_31, { return is_valid_utf8(test_utf_seq_28); });
+EXO_TEST(utf8_valid_32, { return !is_valid_utf8(test_utf_seq_29); });
+EXO_TEST(utf8_valid_33, { return !is_valid_utf8(test_utf_seq_30); });
+EXO_TEST(utf8_valid_34, { return !is_valid_utf8(test_utf_seq_31); });
+EXO_TEST(utf8_valid_35, { return !is_valid_utf8(test_utf_seq_32); });
+EXO_TEST(utf8_valid_36, { return !is_valid_utf8(test_utf_seq_33); });
+EXO_TEST(utf8_valid_37, { return is_valid_utf8(test_utf_seq_34); });
+EXO_TEST(utf8_valid_38, { return is_valid_utf8(test_utf_seq_35); });
+EXO_TEST(utf8_valid_39, { return !is_valid_utf8(test_utf_seq_36); });
+EXO_TEST(utf8_valid_40, { return !is_valid_utf8(test_utf_seq_37); });

autotest/test_rbtree.tcc

@@ -86,7 +86,7 @@ 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++)
+	for (i = 0; i < MAX_NODES; i++)
 	{
 		const char* key = strdup(uhub_itoa(i));
 		const char* val = strdup(uhub_itoa(i + 16384));
@@ -96,11 +96,11 @@ EXO_TEST(rbtree_insert_10000, {
 	return 1;
 });
 
-EXO_TEST(rbtree_size_4, { return rb_tree_size(tree) == MAX_NODES ; });
+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++)
+	for (i = 0; i < MAX_NODES; i++)
 	{
 		char* key = strdup(uhub_itoa(i));
 		const char* expect = uhub_itoa(i + 16384);
@@ -116,29 +116,35 @@ EXO_TEST(rbtree_iterate_10000, {
 	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 ;
+	return i == MAX_NODES;
 });
 
-
+static int freed_nodes = 0;
 static void free_node(struct rb_node* n)
 {
 	hub_free((void*) n->key);
 	hub_free((void*) n->value);
+	freed_nodes += 1;
 }
 
-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)
+EXO_TEST(rbtree_remove_10000, {
+	int i;
+	int j;
+	for (j = 0; j < 2; j++)
 	{
-		const char* key = uhub_itoa(i);
-		rb_tree_remove_node(tree, key, &free_node);
+		for (i = j; i < MAX_NODES; i += 2)
+		{
+			const char* key = uhub_itoa(i);
+			rb_tree_remove_node(tree, key, &free_node);
+		}
 	}
-	return 1;
+	return freed_nodes == MAX_NODES;
 });
 
-
+EXO_TEST(rbtree_destroy_1, {
+	rb_tree_destroy(tree);
+	return 1;
+});

autotest/test_timer.tcc

@@ -117,3 +117,9 @@ EXO_TEST(timer_process_5_events_1,{
 	g_now = 4;
 	return timeout_queue_process(g_queue, g_now) == g_triggered;
 });
+
+EXO_TEST(timer_shutdown,{
+	timeout_queue_shutdown(g_queue);
+	hub_free(g_queue);
+	return 1;
+});

autotest/travis/build-and-test.sh

@@ -0,0 +1,43 @@
+#!/bin/sh
+
+set -x
+set -e
+
+export CFLAGS="$(dpkg-buildflags --get CFLAGS) $(dpkg-buildflags --get CPPFLAGS)"
+export LDFLAGS="$(dpkg-buildflags --get LDFLAGS) -Wl,--as-needed"
+
+mkdir -p builddir
+cd builddir
+
+CMAKEOPTS="..
+           -DCMAKE_INSTALL_PREFIX=/usr"
+
+if [ "${CONFIG}" = "full" ]; then
+    CMAKEOPTS="${CMAKEOPTS}
+               -DRELEASE=OFF
+               -DLOWLEVEL_DEBUG=ON
+               -DSSL_SUPPORT=ON
+               -DUSE_OPENSSL=ON
+               -DADC_STRESS=ON"
+else
+    CMAKEOPTS="${CMAKEOPTS}
+               -DRELEASE=ON
+               -DLOWLEVEL_DEBUG=OFF
+               -DSSL_SUPPORT=OFF
+               -DADC_STRESS=OFF"
+fi
+
+
+cmake ${CMAKEOPTS} \
+      -DCMAKE_C_FLAGS="${CFLAGS}" \
+      -DCMAKE_EXE_LINKER_FLAGS="${LDFLAGS}"
+make VERBOSE=1
+
+
+make VERBOSE=1 autotest-bin
+./autotest-bin
+
+
+sudo make install
+du -shc /etc/uhub/ /usr/bin/uhub* /usr/lib/uhub/
+

autotest/travis/install-build-depends.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+sudo apt-get update -qq
+
+sudo apt-get install -qq cmake
+
+if [ "${CONFIG}" = "full" ]; then
+    sudo apt-get install -qq libsqlite3-dev libssl-dev
+fi
+

cmake/Modules/FindSqlite3.cmake

@@ -44,6 +44,7 @@ IF ( NOT SQLITE3_FOUND AND NOT PKG_CONFIG_FOUND )
 		/opt/local/lib
 		/sw/lib
 		/usr/lib
+		/usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}
 		/usr/local/lib
 		/usr/lib64
 		/usr/local/lib64

doc/getstarted.txt

@@ -1,8 +1,6 @@
 Getting started guide
 ---------------------
 
-(This document is maintained at http://www.extatic.org/uhub/getstarted.html )
-
 Unpack your binaries 
 
 Example:
@@ -17,6 +15,7 @@ Create configuration files.
 If no configuration files are created, uhub will use the default parameters, so you can skip this step if you are in a hurry to see it run.
 
 As root, or use sudo.
+
   % mkdir /etc/uhub
   % cp doc/uhub.conf /etc/uhub
   % cp doc/users.conf /etc/uhub
@@ -32,8 +31,11 @@ NOTE: It is important to use the "adc://" prefix, and the port number when using
 
 If you modify the configuration files in /etc/uhub you will have to notify uhub by sending a HUP signal.
 
+  % ps aux | grep uhub
   % kill -HUP <pid of uhub>
+
 Or, for the lazy people
+
   % killall -HUP uhub
 
 In order to run uhub as a daemon, start it with the -f switch which will make it fork into the background.
@@ -41,8 +43,8 @@ In addition, use the -l to specify a log file instead of stdout. One can also sp
 if one wishes to run uhub as a specific user using the -u and -g switches.
 
 Example:
-  % uhub -f -l mylog.txt -u nobody -g nogroup
 
+  % uhub -f -l mylog.txt -u nobody -g nogroup
 
 If you are planning to more than 1024 users on hub, you must increase the max number of file descriptors allowed.
 This limit needs to be higher than the configured max_users in uhub.conf.
@@ -52,6 +54,14 @@ In linux can add the following lines to /etc/security/limits.conf (allows for ~4
       *     hard nofile 4096
 
 Or, you can use (as root):
+
   % ulimit -n 4096
+
+You can interact with uhub in your hub main chat using the `!` prefix, followed by a command:
+
+Example :
+
+      *     to display help and the command you can use:
+            !help 
                      
 Your mileage may vary -- Good luck!

doc/plugins.conf

@@ -13,6 +13,15 @@
 #
 plugin /usr/lib/uhub/mod_auth_sqlite.so "file=/etc/uhub/users.db"
 
+# Topic commands.
+# Note: "topic" == "hub description" (as configured in uhub.conf)
+#
+# !topic      - change the topic (op required)
+# !showtopic  - show the topic
+# !resettopic - reset the topic to the default (op required)
+#
+# This plugins takes no parameters.
+#plugin /usr/lib/uhub/mod_topic.so
 
 # Log file writer
 #
@@ -22,7 +31,8 @@ plugin /usr/lib/uhub/mod_auth_sqlite.so "file=/etc/uhub/users.db"
 plugin /usr/lib/uhub/mod_logging.so "file=/var/log/uhub.log"
 
 # A simple example plugin
-# plugin /usr/lib/uhub/mod_example.so
+#plugin /usr/lib/uhub/mod_example.so
+
 # A plugin sending a welcome message.
 #
 # This plugin provides the following commands:
@@ -31,7 +41,7 @@ plugin /usr/lib/uhub/mod_logging.so "file=/var/log/uhub.log"
 #
 # Parameters:
 # motd: path/filename for the welcome message (message of the day)
-# rules: path/filenam for the rules file
+# rules: path/filename for the rules file
 #
 # NOTE: The files MUST exist, however if you do not wish to provide one then these parameters can be omitted.
 #
@@ -59,4 +69,3 @@ plugin /usr/lib/uhub/mod_welcome.so "motd=/etc/uhub/motd.txt rules=/etc/uhub/rul
 # 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 /usr/lib/uhub/mod_chat_history.so "history_max=200 history_default=10 history_connect=5"
-

doc/uhub-passwd.1

@@ -39,4 +39,4 @@ is one of 'admin', 'super', 'op', 'user'
 This program was written by Jan Vidar Krey <janvidar@extatic.org>
 .SH "BUG REPORTS"
 If you find a bug in uhub please report it to
-.B http://bugs.extatic.org/
+.B https://github.com/janvidar/uhub/issues

doc/uhub.1

@@ -69,4 +69,4 @@ To run uhub as a daemon, and log to a file:
 This program was written by Jan Vidar Krey <janvidar@extatic.org>
 .SH "BUG REPORTS"
 If you find a bug in uhub please report it to
-.B http://bugs.extatic.org/
+.B https://github.com/janvidar/uhub/issues

doc/uhub.conf

@@ -104,11 +104,11 @@ msg_auth_invalid_password      = Password is wrong
 msg_auth_user_not_found        = User not found in password database
 msg_user_share_size_low	       = User is not sharing enough
 msg_user_share_size_high       = User is sharing too much
-msg_user_slots_low	       = User have too few upload slots
-msg_user_slots_high	       = User have too many upload slots
+msg_user_slots_low	       = User has too few upload slots
+msg_user_slots_high	       = User has too many upload slots
 msg_user_hub_limit_low 	       = User is on too few hubs
 msg_user_hub_limit_high	       = User is on too many hubs
-msg_error_no_memory            = No memory
+msg_error_no_memory            = Out of memory
 msg_user_flood_chat            = Chat flood detected, messages are dropped.
 msg_user_flood_connect         = Connect flood detected, connection refused.
 msg_user_flood_search          = Search flood detected, search is stopped.

src/adc/adcconst.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -111,7 +111,10 @@ typedef uint32_t fourcc_t;
 #define ADC_INF_FLAG_CLIENT_ID          "ID" /* client id, aka CID */
 #define ADC_INF_FLAG_NICK               "NI" /* nick name */
 #define ADC_INF_FLAG_DESCRIPTION        "DE" /* user description */
-#define ADC_INF_FLAG_USER_AGENT         "VE" /* software version */
+
+#define ADC_INF_FLAG_USER_AGENT_PRODUCT "AP" /* software name */
+#define ADC_INF_FLAG_USER_AGENT_VERSION "VE" /* software version */
+
 #define ADC_INF_FLAG_SUPPORT            "SU" /* support (extensions, feature cast) */
 #define ADC_INF_FLAG_SHARED_SIZE        "SS" /* size of total files shared in bytes */
 #define ADC_INF_FLAG_SHARED_FILES       "SF" /* number of files shared */
@@ -153,9 +156,10 @@ typedef uint32_t fourcc_t;
 #define ADC_SUP_FLAG_ADD                "AD"
 #define ADC_SUP_FLAG_REMOVE             "RM"
 
-#define ADC_CLIENT_TYPE_BOT             "1"
-#define ADC_CLIENT_TYPE_REGISTERED_USER "2"
-#define ADC_CLIENT_TYPE_OPERATOR        "4"
+#define ADC_CLIENT_TYPE_BOT              "1"
+#define ADC_CLIENT_TYPE_REGISTERED_USER  "2"
+#define ADC_CLIENT_TYPE_OPERATOR         "4"
+#define ADC_CLIENT_TYPE_HUBBOT           "5"  /* 1 + 4 */
 #define ADC_CLIENT_TYPE_SUPER_USER      "12"  /* 8 + 4 */
 #define ADC_CLIENT_TYPE_ADMIN           "20"  /* 16 + 4 = hub owner */
 #define ADC_CLIENT_TYPE_HUB             "32"  /* the hub itself */

src/adc/message.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -24,7 +24,6 @@
 	uhub_assert(X); \
 	uhub_assert(X->cache); \
 	uhub_assert(X->capacity); \
-	uhub_assert(X->length); \
 	uhub_assert(X->length <= X->capacity); \
 	uhub_assert(X->references > 0); \
 	uhub_assert(X->length == strlen(X->cache));
@@ -168,24 +167,24 @@ int adc_msg_get_arg_offset(struct adc_message* msg)
 {
 	if (!msg || !msg->cache)
 		return -1;
-	
+
 	switch (msg->cache[0])
 	{
 		/* These *SHOULD* never be seen on a hub */
 		case 'U':
 		case 'C':
 			return 4; /* Actually: 4 + strlen(cid). */
-		
+
 		case 'I':
 		case 'H':
 			return 4;
-			
+
 		case 'B':
 			return  9;
-			
+
 		case 'F':
 			return (10 + (list_size(msg->feature_cast_include)*5) + (list_size(msg->feature_cast_exclude)*5));
-			
+
 		case 'D':
 		case 'E':
 			return 14;
@@ -200,10 +199,10 @@ int adc_msg_is_empty(struct adc_message* msg)
 
 	if (offset == -1)
 		return -1;
-	
+
 	if ((msg->length - 1) == (size_t) offset)
 		return 1;
-		
+
 	return 0;
 }
 
@@ -283,23 +282,19 @@ struct adc_message* adc_msg_copy(const struct adc_message* cmd)
 	if (cmd->feature_cast_include)
 	{
 		copy->feature_cast_include = list_create();
-		tmp = list_get_first(cmd->feature_cast_include);
-		while (tmp)
+		LIST_FOREACH(char*, tmp, cmd->feature_cast_include,
 		{
 			list_append(copy->feature_cast_include, hub_strdup(tmp));
-			tmp = list_get_next(cmd->feature_cast_include);
-		}
+		});
 	}
 
 	if (cmd->feature_cast_exclude)
 	{
 		copy->feature_cast_exclude = list_create();
-		tmp = list_get_first(cmd->feature_cast_exclude);
-		while (tmp)
+		LIST_FOREACH(char*, tmp, cmd->feature_cast_exclude,
 		{
 			list_append(copy->feature_cast_exclude, hub_strdup(tmp));
-			tmp = list_get_next(cmd->feature_cast_exclude);
-		}
+		});
 	}
 
 	ADC_MSG_ASSERT(copy);
@@ -311,17 +306,17 @@ struct adc_message* adc_msg_copy(const struct adc_message* cmd)
 struct adc_message* adc_msg_parse_verify(struct hub_user* u, const char* line, size_t length)
 {
 	struct adc_message* command = adc_msg_parse(line, length);
-	
+
 	if (!command)
 		return 0;
-	
-	if (command->source && (!u || command->source != u->id.sid))
+
+	if (command->source && (!u || (command->source != u->id.sid && !auth_cred_is_unrestricted(u->credentials))))
 	{
 		LOG_DEBUG("Command does not match user's SID (command->source=%d, user->id.sid=%d)", command->source, (u ? u->id.sid : 0));
 		adc_msg_free(command);
 		return 0;
 	}
-	
+
 	return command;
 }
 
@@ -335,7 +330,7 @@ struct adc_message* adc_msg_parse(const char* line, size_t length)
 	int ok = 1;
 	int need_terminate = 0;
 	struct linked_list* feature_cast_list;
-	
+
 	if (command == NULL)
 		return NULL; /* OOM */
 
@@ -599,14 +594,14 @@ int adc_msg_remove_named_argument(struct adc_message* cmd, const char prefix_[2]
 	int found = 0;
 	int arg_offset = adc_msg_get_arg_offset(cmd);
 	size_t temp_len = 0;
-	
+
 	adc_msg_unterminate(cmd);
-	
+
 	start = memmem(&cmd->cache[arg_offset], (cmd->length - arg_offset), prefix, 3);
 	while (start)
 	{
 		endInfo = &cmd->cache[cmd->length];
-	
+
 		if  (&start[0] < &endInfo[0])
 		{
 			end = memchr(&start[1], ' ', &endInfo[0]-&start[1]);
@@ -615,13 +610,13 @@ int adc_msg_remove_named_argument(struct adc_message* cmd, const char prefix_[2]
 		{
 			end = NULL;
 		}
-		
+
 		if (end)
 		{
-			
+
 			temp_len = &end[0] - &start[0]; // strlen(start);
 			endlen = strlen(end);
-			
+
 			memmove(start, end, endlen);
 			start[endlen] = '\0';
 			found++;
@@ -636,9 +631,9 @@ int adc_msg_remove_named_argument(struct adc_message* cmd, const char prefix_[2]
 		}
 		start = memmem(&cmd->cache[arg_offset], (cmd->length - arg_offset), prefix, 3);
 	}
-	
+
 	adc_msg_terminate(cmd);
-	
+
 	return found;
 }
 
@@ -687,7 +682,7 @@ char* adc_msg_get_named_argument(struct adc_message* cmd, const char prefix_[2])
 	length = &end[0] - &start[0];
 
 	argument = hub_strndup(start, length);
-	
+
 	if (length > 0 && argument[length-1] == '\n')
 	{
 		argument[length-1] = 0;

src/adc/message.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -229,7 +229,7 @@ void adc_msg_unterminate(struct adc_message* cmd);
 /**
  * @return the offset for the first command argument in msg->cache.
  * or -1 if the command is not understood.
- * NOTE: for 'U' and 'C' commands (normally not seen by hubs), 
+ * NOTE: for 'U' and 'C' commands (normally not seen by hubs),
  * this returns 4. Should be 4 + lengthOf(cid).
  */
 int adc_msg_get_arg_offset(struct adc_message* msg);

src/adc/sid.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -47,7 +47,7 @@ sid_t string_to_sid(const char* sid)
 	sid_t nsid = 0;
 	sid_t n, x;
 	sid_t factors[] = { 32768, 1024, 32, 1};
-	
+
 	if (!sid || strlen(sid) != 4) return 0;
 
 	for (n = 0; n < 4; n++) {

src/adc/sid.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/auth.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -26,20 +26,20 @@
 static int check_cmd_bool(const char* cmd, struct linked_list* list, char* line, int line_count)
 {
 	char* data;
-	
+
 	if (!strncmp(line, cmd, strlen(cmd)))
 	{
 		data = &line[strlen(cmd)];
 		data[0] = '\0';
 		data++;
-		
+
 		data = strip_white_space(data);
 		if (!*data)
 		{
 			LOG_FATAL("ACL parse error on line %d", line_count);
 			return -1;
 		}
-		
+
 		list_append(list, hub_strdup(data));
 		LOG_DEBUG("ACL: Deny access for: '%s' (%s)", data, cmd);
 		return 1;
@@ -170,6 +170,9 @@ static int acl_parse_line(char* line, int line_count, void* ptr_data)
 	LOG_DEBUG("acl_parse_line: '%s'", line);
 
 	ACL_ADD_USER("bot",        handle->users, auth_cred_bot);
+	ACL_ADD_USER("ubot",        handle->users, auth_cred_ubot);
+	ACL_ADD_USER("opbot",        handle->users, auth_cred_opbot);
+	ACL_ADD_USER("opubot",        handle->users, auth_cred_opubot);
 	ACL_ADD_USER("user_admin", handle->users, auth_cred_admin);
 	ACL_ADD_USER("user_super", handle->users, auth_cred_super);
 	ACL_ADD_USER("user_op",    handle->users, auth_cred_operator);
@@ -190,18 +193,18 @@ int acl_initialize(struct hub_config* config, struct acl_handle* handle)
 {
 	int ret;
 	memset(handle, 0, sizeof(struct acl_handle));
-	
+
 	handle->users        = list_create();
 	handle->users_denied = list_create();
 	handle->users_banned = list_create();
 	handle->cids         = list_create();
 	handle->networks     = list_create();
 	handle->nat_override = list_create();
-	
+
 	if (!handle->users || !handle->cids || !handle->networks || !handle->users_denied || !handle->users_banned || !handle->nat_override)
 	{
 		LOG_FATAL("acl_initialize: Out of memory");
-		
+
 		list_destroy(handle->users);
 		list_destroy(handle->users_denied);
 		list_destroy(handle->users_banned);
@@ -210,11 +213,11 @@ int acl_initialize(struct hub_config* config, struct acl_handle* handle)
 		list_destroy(handle->nat_override);
 		return -1;
 	}
-	
+
 	if (config)
 	{
 		if (!*config->file_acl) return 0;
-		
+
 		ret = file_read_lines(config->file_acl, handle, &acl_parse_line);
 		if (ret == -1)
 			return -1;
@@ -249,26 +252,26 @@ int acl_shutdown(struct acl_handle* handle)
 		list_clear(handle->users, &acl_free_access_info);
 		list_destroy(handle->users);
 	}
-	
+
 	if (handle->users_denied)
 	{
 		list_clear(handle->users_denied, &hub_free);
 		list_destroy(handle->users_denied);
 	}
-	
+
 	if (handle->users_banned)
 	{
 		list_clear(handle->users_banned, &hub_free);
 		list_destroy(handle->users_banned);
 	}
-	
-	
+
+
 	if (handle->cids)
 	{
 		list_clear(handle->cids, &hub_free);
 		list_destroy(handle->cids);
 	}
-	
+
 	if (handle->networks)
 	{
 		list_clear(handle->networks, &acl_free_ip_info);
@@ -330,13 +333,11 @@ struct auth_info* acl_get_access_info(struct hub_info* hub, const char* name)
 }
 
 #define STR_LIST_CONTAINS(LIST, STR) \
-		str = (char*) list_get_first(LIST); \
-		while (str) \
+		LIST_FOREACH(char*, str, LIST, \
 		{ \
 			if (strcasecmp(str, STR) == 0) \
 				return 1; \
-			str = (char*) list_get_next(LIST); \
-		} \
+		}); \
 		return 0
 
 int acl_is_cid_banned(struct acl_handle* handle, const char* data)
@@ -400,34 +401,28 @@ int acl_user_unban_cid(struct acl_handle* handle, const char* cid)
 int acl_is_ip_banned(struct acl_handle* handle, const char* ip_address)
 {
 	struct ip_addr_encap raw;
-	struct ip_range* info = (struct ip_range*) list_get_first(handle->networks);
+	struct ip_range* info;
+
 	ip_convert_to_binary(ip_address, &raw);
-	
-	while (info)
+	LIST_FOREACH(struct ip_range*, info, handle->networks,
 	{
 		if (ip_in_range(&raw, info))
-		{
 			return 1;
-		}
-		info = (struct ip_range*) list_get_next(handle->networks);
-	}
+	});
 	return 0;
 }
 
 int acl_is_ip_nat_override(struct acl_handle* handle, const char* ip_address)
 {
 	struct ip_addr_encap raw;
-	struct ip_range* info = (struct ip_range*) list_get_first(handle->nat_override);
+	struct ip_range* info;
+
 	ip_convert_to_binary(ip_address, &raw);
-	
-	while (info)
+	LIST_FOREACH(struct ip_range*, info, handle->nat_override,
 	{
 		if (ip_in_range(&raw, info))
-		{
 			return 1;
-		}
-		info = (struct ip_range*) list_get_next(handle->nat_override);
-	}
+	});
 	return 0;
 }
 
@@ -476,10 +471,10 @@ int acl_password_verify(struct hub_info* hub, struct hub_user* user, const char*
 	base32_decode(challenge, (unsigned char*) raw_challenge, MAX_CID_LEN);
 
 	password_len = strlen(access->password);
-	
+
 	memcpy(&buf[0], access->password, password_len);
 	memcpy(&buf[password_len], raw_challenge, TIGERSIZE);
-	
+
 	tiger((uint64_t*) buf, TIGERSIZE+password_len, (uint64_t*) tiger_res);
 	base32_encode((unsigned char*) tiger_res, TIGERSIZE, password_calc);
 	password_calc[MAX_CID_LEN] = 0;

src/core/auth.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/command_parser.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -26,7 +26,7 @@ static void hub_command_args_free(struct hub_command* cmd)
 	if (!cmd->args)
 		return;
 
-	for (data = (struct hub_command_arg_data*) list_get_first(cmd->args); data; data = (struct hub_command_arg_data*) list_get_next(cmd->args))
+	LIST_FOREACH(struct hub_command_arg_data*, data, cmd->args,
 	{
 		switch (data->type)
 		{
@@ -39,7 +39,7 @@ static void hub_command_args_free(struct hub_command* cmd)
 			default:
 				break;
 		}
-	}
+	});
 
 	list_clear(cmd->args, hub_free);
 	list_destroy(cmd->args);
@@ -64,6 +64,7 @@ static enum command_parse_status command_extract_arguments(struct hub_info* hub,
 	char* token = NULL;
 	char* tmp = NULL;
 	size_t size = 0;
+	size_t offset = 0;
 	struct hub_command_arg_data* data = NULL;
 	enum command_parse_status status = cmd_status_ok;
 
@@ -77,15 +78,15 @@ static enum command_parse_status command_extract_arguments(struct hub_info* hub,
 		if (greedy)
 		{
 			size = 1;
-			for (tmp = (char*) list_get_first(tokens); tmp; tmp = (char*) list_get_next(tokens))
-				size += (strlen(tmp) + 1);
+			LIST_FOREACH(char*, tmp, tokens, { size += (strlen(tmp) + 1); });
 			token = hub_malloc_zero(size);
 
 			while ((tmp = list_get_first(tokens)))
 			{
-				if (*token)
-					strcat(token, " ");
-				strcat(token, tmp);
+				if (offset > 0)
+					token[offset++] = ' ';
+				memcpy(token + offset, tmp, strlen(tmp));
+				offset += strlen(tmp);
 				list_remove(tokens, tmp);
 				hub_free(tmp);
 			}

src/core/command_parser.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/commands.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -31,8 +31,6 @@ static int send_command_not_found(struct command_base* cbase, struct hub_user* u
 static int send_command_syntax_error(struct command_base* cbase, struct hub_user* user);
 static int send_command_missing_arguments(struct command_base* cbase, struct hub_user* user, struct hub_command* cmd);
 
-static void null_free(void* ptr) { }
-
 struct command_base
 {
 	struct hub_info* hub;
@@ -98,14 +96,14 @@ struct command_handle* command_handler_lookup(struct command_base* cbase, const
 	struct command_handle* handler = NULL;
 	size_t prefix_len = strlen(prefix);
 
-	for (handler = (struct command_handle*) list_get_first(cbase->handlers); handler; handler = (struct command_handle*) list_get_next(cbase->handlers))
+	LIST_FOREACH(struct command_handle*, handler, cbase->handlers,
 	{
 		if (prefix_len != handler->length)
 			continue;
 
 		if (!memcmp(prefix, handler->prefix, handler->length))
 			return handler;
-	}
+	});
 	return NULL;
 }
 
@@ -292,7 +290,7 @@ static int command_help(struct command_base* cbase, struct hub_user* user, struc
 	{
 		cbuf_append(buf, "Available commands:\n");
 
-		for (command = (struct command_handle*) list_get_first(cbase->handlers); command; command = (struct command_handle*) list_get_next(cbase->handlers))
+		LIST_FOREACH(struct command_handle*, command, cbase->handlers,
 		{
 			if (command_is_available(command, user->credentials))
 			{
@@ -301,7 +299,7 @@ static int command_help(struct command_base* cbase, struct hub_user* user, struc
 					cbuf_append(buf, " ");
 				cbuf_append_format(buf, " - %s\n", command->description);
 			}
-		}
+		});
 	}
 	else
 	{
@@ -424,7 +422,7 @@ static int command_whoip(struct command_base* cbase, struct hub_user* user, stru
 	ret = uman_get_user_by_addr(cbase->hub->users, users, arg->data.range);
 	if (!ret)
 	{
-		list_clear(users, &null_free);
+		list_clear(users, NULL);
 		list_destroy(users);
 		return command_status(cbase, user, cmd, cbuf_create_const("No users found."));
 	}
@@ -432,16 +430,14 @@ static int command_whoip(struct command_base* cbase, struct hub_user* user, stru
 	buf = cbuf_create(128 + ((MAX_NICK_LEN + INET6_ADDRSTRLEN + 5) * ret));
 	cbuf_append_format(buf, "*** %s: Found %d match%s:\n", cmd->prefix, ret, ((ret != 1) ? "es" : ""));
 
-	u = (struct hub_user*) list_get_first(users);
-	while (u)
+	LIST_FOREACH(struct hub_user*, u, users,
 	{
 		cbuf_append_format(buf, "%s (%s)\n", u->id.nick, user_get_address(u));
-		u = (struct hub_user*) list_get_next(users);
-	}
+	});
 	cbuf_append(buf, "\n");
 
 	send_message(cbase, user, buf);
-	list_clear(users, &null_free);
+	list_clear(users, NULL);
 	list_destroy(users);
 	return 0;
 }
@@ -462,8 +458,7 @@ static int command_broadcast(struct command_base* cbase, struct hub_user* user,
 	memcpy(from_sid, sid_to_string(user->id.sid), sizeof(from_sid));
 	memcpy(pm_flag + 2, from_sid, sizeof(from_sid));
 
-	target = (struct hub_user*) list_get_first(cbase->hub->users->list);
-	while (target)
+	LIST_FOREACH(struct hub_user*, target, cbase->hub->users->list,
 	{
 		if (target != user)
 		{
@@ -480,8 +475,7 @@ static int command_broadcast(struct command_base* cbase, struct hub_user* user,
 			route_to_user(cbase->hub, target, command);
 			adc_msg_free(command);
 		}
-		target = (struct hub_user*) list_get_next(cbase->hub->users->list);
-	}
+	});
 
 	cbuf_append_format(buf, "*** %s: Delivered to " PRINTF_SIZE_T " user%s", cmd->prefix, recipients, (recipients != 1 ? "s" : ""));
 	send_message(cbase, user, buf);
@@ -513,8 +507,7 @@ static int command_log(struct command_base* cbase, struct hub_user* user, struct
 	command_status(cbase, user, cmd, buf);
 
 	buf = cbuf_create(MAX_HELP_LINE);
-	log = (struct hub_logout_info*) list_get_first(messages);
-	while (log)
+	LIST_FOREACH(struct hub_logout_info*, log, messages,
 	{
 		const char* address = ip_convert_to_string(&log->addr);
 		int show = 0;
@@ -538,8 +531,7 @@ static int command_log(struct command_base* cbase, struct hub_user* user, struct
 			send_message(cbase, user, buf);
 			buf = cbuf_create(MAX_HELP_LINE);
 		}
-		log = (struct hub_logout_info*) list_get_next(messages);
-	}
+	});
 
 	if (search_len)
 	{
@@ -582,6 +574,33 @@ static int command_stats(struct command_base* cbase, struct hub_user* user, stru
 	return command_status(cbase, user, cmd, buf);
 }
 
+static int command_register_self(struct command_base* cbase, struct hub_user* user, struct hub_command* cmd)
+{
+	if (user_is_registered(user))
+		return command_status(cbase, user, cmd, cbuf_create_const("You are already registered!"));
+
+	struct hub_command_arg_data* arg = hub_command_arg_next(cmd, type_string);
+	char* password = arg->data.string;
+
+	if (!*password || strlen(password) > MAX_PASS_LEN)
+		return command_status(cbase, user, cmd, cbuf_create_const("Invalid password!"));
+
+	struct auth_info info;
+	memset(&info, 0, sizeof(info));
+	memcpy(&info.nickname, user->id.nick, MAX_NICK_LEN);
+	memcpy(&info.password, password, MAX_PASS_LEN);
+	info.credentials = auth_cred_user;
+
+
+	if (acl_register_user(cbase->hub, &info))
+	{
+		return command_status(cbase, user, cmd, cbuf_create_const("You are now registered."));
+	}
+
+	// NOTE: No good reason for this can be given here!
+	return command_status(cbase, user, cmd, cbuf_create_const("Unable to register user."));
+}
+
 static struct command_handle* add_builtin(struct command_base* cbase, const char* prefix, const char* args, enum auth_credentials cred, command_handler handler, const char* description)
 {
 	struct command_handle* handle = (struct command_handle*) hub_malloc_zero(sizeof(struct command_handle));
@@ -609,6 +628,10 @@ void commands_builtin_add(struct command_base* cbase)
 	ADD_COMMAND("myip",       4, "",  auth_cred_guest,     command_myip,     "Show your own IP."            );
 	ADD_COMMAND("reload",     6, "",  auth_cred_admin,     command_reload,   "Reload configuration files."  );
 	ADD_COMMAND("shutdown",   8, "",  auth_cred_admin,     command_shutdown_hub, "Shutdown hub."            );
+
+	if (cbase->hub->config->register_self)
+		ADD_COMMAND("register",   8, "p",  auth_cred_guest, command_register_self,    "Register yourself."  );
+
 	ADD_COMMAND("stats",      5, "",  auth_cred_super,     command_stats,    "Show hub statistics."         );
 	ADD_COMMAND("uptime",     6, "",  auth_cred_guest,     command_uptime,   "Display hub uptime info."     );
 	ADD_COMMAND("version",    7, "",  auth_cred_guest,     command_version,  "Show hub version info."       );

src/core/commands.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/config.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -76,7 +76,7 @@ static int config_parse_line(char* line, int line_count, void* ptr_data)
 	struct hub_config* config = (struct hub_config*) ptr_data;
 
 	strip_off_ini_line_comments(line, line_count);
-	
+
 	if (!*line) return 0;
 
 	LOG_DUMP("config_parse_line(): '%s'", line);

src/core/config.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/config.pl

@@ -1,289 +0,0 @@
-#!/usr/bin/perl -w
-
-use strict;
-use XML::DOM;
-
-sub write_c_header(@);
-sub write_sql_dump(@);
-sub get_data($);
-
-my $dump_to_sql = 0;
-
-# initialize parser and read the file
-my $input = "./config.xml";
-my $parser = new XML::DOM::Parser;
-my $tree = $parser->parsefile($input) || die "Unable to parse XML file.";
-
-# Get data
-my $nodes = $tree->getElementsByTagName("option");
-my @options = ();
-for (my $i = 0; $i < $nodes->getLength; $i++)
-{
-	my @data = get_data($nodes->item($i));
-	push @options, \@data;
-}
-
-write_c_header(@options);
-write_sql_dump(@options) if ($dump_to_sql);
-
-my $config_defaults = "void config_defaults(struct hub_config* config)\n{\n";
-my $config_apply = "static int apply_config(struct hub_config* config, char* key, char* data, int line_count)\n{\n\tint max = 0;\n\tint min = 0;\n\n";
-my $config_free = "void free_config(struct hub_config* config)\n{\n";
-my $config_dump = "void dump_config(struct hub_config* config, int ignore_defaults)\n{\n";
-
-foreach my $option (@options)
-{
-	my ($type, $name, $default, $advanced, $short, $desc, $since, $example, $check, $ifdef) = @$option;
-	my $string = ($type =~ /(string|file|message)/);
-	my $min = undef;
-	my $max = undef;
-	my $regexp = undef;
-
-	if (defined $check)
-	{
-		$min = $check->getAttribute("min");
-		$max = $check->getAttribute("max");
-		$regexp = $check->getAttribute("regexp");
-
-		$max = undef if ($max eq "");
-		$min = undef if ($min eq "");
-		$regexp = undef if ($regexp eq "");
-	}
-
-	$config_defaults .= "#ifdef $ifdef\n" if ($ifdef ne "");
-	$config_defaults .= "\tconfig->$name = ";
-	$config_defaults .= "hub_strdup(\"" if ($string);
-	$config_defaults .= $default;
-	$config_defaults .= "\")" if ($string);
-	$config_defaults .= ";\n";
-	$config_defaults .= "#endif /* $ifdef */\n" if ($ifdef ne "");
-
-	$config_apply .= "#ifdef $ifdef\n" if ($ifdef ne "");
-	$config_apply .= "\tif (!strcmp(key, \"" . $name . "\"))\n\t{\n";
-
-	if ($type eq "int")
-	{
-		$config_apply .= "\t\tmin = $min;\n" if (defined $min);
-		$config_apply .= "\t\tmax = $max;\n" if (defined $max);
-		$config_apply .= "\t\tif (!apply_integer(key, data, &config->$name, ";
-		if (defined $min) { $config_apply .= "&min"; } else { $config_apply .= "0"; }
-		$config_apply .= ", ";
-		if (defined $max) { $config_apply .= "&max"; } else { $config_apply .= "0"; }
-		$config_apply .= "))\n";
-	}
-	elsif ($type eq "boolean")
-	{
-		$config_apply .= "\t\tif (!apply_boolean(key, data, &config->$name))\n";
-	}
-	elsif ($string)
-	{
-		$config_apply .="\t\tif (!apply_string(key, data, &config->$name, (char*) \"\"))\n";
-	}
-
-	$config_apply .= "\t\t{\n" .
-				  "\t\t\tLOG_ERROR(\"Configuration parse error on line %d\", line_count);\n" .
-				  "\t\t\treturn -1;\n" .
-				  "\t\t}\n" .
-				  "\t\treturn 0;\n" .
-				  "\t}\n";
-	$config_apply .= "#endif /* $ifdef */\n" if ($ifdef ne "");
-	$config_apply .= "\n";
-
-	if ($string)
-	{
-		$config_free .= "#ifdef $ifdef\n" if ($ifdef ne "");
-		$config_free .= "\thub_free(config->" . $name . ");\n";
-		$config_free .= "#endif /* $ifdef */\n" if ($ifdef ne "");
-		$config_free .= "\n";
-	}
-
-	my $out = "%s";
-	my $val = "config->$name";
-	my $test = "config->$name != $default";
-
-	$out = "%d" if ($type eq "int");
-	$val = "config->$name ? \"yes\" : \"no\"" if ($type eq "boolean");
-
-	if ($string)
-	{
-		$out = "\\\"%s\\\"";
-		$test = "strcmp(config->$name, \"$default\") != 0";
-	}
-
-	$config_dump .= "#ifdef $ifdef\n" if ($ifdef ne "");
-	$config_dump .= "\tif (!ignore_defaults || $test)\n";
-	$config_dump .= "\t\tfprintf(stdout, \"$name = $out\\n\", $val);\n";
-	$config_dump .= "#endif /* $ifdef */\n" if ($ifdef ne "");
-	$config_dump .= "\n";
-}
-
-$config_apply .= "\t/* Still here -- unknown directive */\n";
-$config_apply .= "\tLOG_ERROR(\"Unknown configuration directive: '%s'\", key);\n";
-$config_apply .= "\treturn -1;\n";
-$config_apply .= "}\n\n";
-$config_defaults .= "}\n\n";
-$config_free .= "}\n\n";
-$config_dump .= "}\n\n";
-
-open GENIMPL, ">gen_config.c" || die "Unable to write source file";
-print GENIMPL "/* THIS FILE IS AUTOGENERATED - DO NOT CHANGE IT! */\n\n";
-print GENIMPL $config_defaults;
-print GENIMPL $config_apply;
-print GENIMPL $config_free;
-print GENIMPL $config_dump;
-
-
-sub get_data($)
-{
-	my $p = shift;
-
-	my $short = "";
-	my $example = "";
-	my $description = "";
-	my $since = "";
-	my $ifdef = "";
-
-	$short = $p->getElementsByTagName("short")->item(0)->getFirstChild()->getData() if ($p->getElementsByTagName("short")->getLength());
-	$since = $p->getElementsByTagName("since")->item(0)->getFirstChild()->getData() if ($p->getElementsByTagName("since")->getLength());
-	$example = $p->getElementsByTagName("example")->item(0)->getFirstChild()->getData() if ($p->getElementsByTagName("example")->getLength());
-	$description = $p->getElementsByTagName("description")->item(0)->getFirstChild()->getData() if ($p->getElementsByTagName("description")->getLength());
-	my $check = $p->getElementsByTagName("check")->item(0);
-	$ifdef = $p->getElementsByTagName("ifdef")->item(0)->getFirstChild()->getData() if ($p->getElementsByTagName("ifdef")->getLength());
-
-	my @data = (
-			$p->getAttribute("type"),
-			$p->getAttribute("name"),
-			$p->getAttribute("default"),
-			$p->getAttribute("advanced"),
-			$short,
-			$description,
-			$since,
-			$example,
-			$check,
-			$ifdef
-		);
-	return @data;
-}
-
-# Write header file
-sub write_c_header(@)
-{
-	my @data = @_;
-
-	open GENHEAD, ">gen_config.h" || die "Unable to write header file";
-	print GENHEAD "/* THIS FILE IS AUTOGENERATED - DO NOT CHANGE IT! */\n\n";
-	print GENHEAD "struct hub_config\n{\n";
-
-	foreach my $option (@data)
-	{
-		my ($type, $name, $default, $advanced, $short, $desc, $since, $example, $check, $ifdef) = @$option;
-
-		my $string = ($type =~ /(string|file|message)/);
-
-		print GENHEAD "#ifdef $ifdef\n" if ($ifdef ne "");
-
-		print GENHEAD "\t";
-		print GENHEAD "int  " if ($type eq "int");
-		print GENHEAD "int  " if ($type eq "boolean");
-		print GENHEAD "char*" if ($string);
-		print GENHEAD " " . $name . ";";
-
-		my $comment = "";
-		if ($type eq "message")
-		{
-			$comment = "\"" . $default . "\"";
-		}
-		elsif (defined $short && length $short > 0)
-		{
-			$comment = $short;
-			if (defined $default)
-			{
-				$comment .= " (default: ";
-				$comment .= "\"" if ($string);
-				$comment .= $default;
-				$comment .= "\"" if ($string);
-				$comment .= ")";
-			}
-		}
-
-		if (length $comment > 0)
-		{
-			my $pad = "";
-			for (my $i = length $name; $i < 32; $i++)
-			{
-				$pad .= " ";
-			}
-			$comment = $pad . "/*<<< " . $comment . " */";
-		}
-		print GENHEAD $comment . "\n";
-		print GENHEAD "#endif /* $ifdef */\n" if ($ifdef ne "");
-	}
-
-	print GENHEAD "};\n\n";
-}
-
-
-sub write_sql_dump(@)
-{
-	my @data = @_;
-
-	# Write SQL dump code
-	open GENSQL, ">gen_config.sql" || die "Unable to write SQL dump";
-	print GENSQL "START TRANSACTION;\n\n
-		DROP TABLE uhub_config IF EXISTS;\n\n
-		CREATE TABLE uhub_config (
-			name VARCHAR(32) UNIQUE NOT NULL,
-			defaultValue TINYTEXT NOT NULL,
-			description LONGTEXT NOT NULL,
-			type TINYTEXT NOT NULL,
-			advanced BOOLEAN,
-			example LONGTEXT,
-			since TINYTEXT
-		);\n\n";
-
-	foreach my $option (@data)
-	{
-		my ($type, $name, $default, $advanced, $short, $desc, $since, $example, $check, $ifdef) = @$option;
-
-		if ($type =~ /(string|file|message)/ )
-		{
-			$default = "\\\"$default\\\"";
-		}
-
-		$desc =~ s/\"/\\\"/g;
-		$type =~ s/^int$/integer/;
-
-		my $stmt = "INSERT INTO uhub_config VALUES(";
-		$stmt .= "\"$name\", ";
-		$stmt .= "\"$default\", ";
-		$stmt .= "\"$desc\", ";
-		$stmt .= "\"$type\", ";
-
-		if (defined $example)
-		{
-			my $example_str = $example;
-			$example_str =~ s/\\/\\\\/g;
-			$example_str =~ s/\"/\\\"/g;
-			$stmt .= "\"$example_str\", ";
-		} else {
-			$stmt .= "NULL, ";
-		}
-
-		if (defined $since) {
-			$stmt .= "\"$since\", ";
-		} else {
-			$stmt .= "NULL, ";
-		}
-
-		if (defined $advanced) {
-			$stmt .= "\"$advanced\"";
-		} else {
-			$stmt .= "NULL";
-		}
-
-		$stmt .= ");\n";
-
-		print GENSQL $stmt;
-	}
-	print GENSQL "\n\nCOMMIT;\n\n";
-}

src/core/config.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python
+"""
+  uhub - A tiny ADC p2p connection hub
+  Copyright (C) 2007-2013, Jan Vidar Krey
+"""
+
+from xml.dom import minidom, Node
+from datetime import datetime
+import argparse
+
+class OptionParseError(Exception):
+	pass
+
+class Option(object):
+	def _get(self, node, name):
+		self.__dict__[name] = None
+		if (node.getElementsByTagName(name)):
+			self.__dict__[name] = node.getElementsByTagName(name)[0].firstChild.nodeValue
+
+	def _attr(self, node, name, required = False):
+		try:
+			return node.attributes[name].value
+		except Exception:
+			pass
+		if (required):
+			raise OptionParseError("Option %s is required but not found!" % name)
+		return None
+
+	def __init__(self, node):
+		self.otype = self._attr(node, 'type', True)
+
+		# Verify that the type is known
+		if not self.otype in ["int", "boolean", "string", "message", "file"]:
+			raise OptionParseError("Option %s has unknown type" % self.name)
+
+		self.name = self._attr(node, 'name', True)
+		self.default = self._attr(node, 'default', True)
+		self.advanced = self._attr(node, 'advanced', False)
+		self.is_string = self.otype in ["string", "message", "file"]
+
+		self._get(node, "short");
+		self._get(node, "description");
+		self._get(node, "syntax");
+		self._get(node, "since");
+		self._get(node, "example");
+
+		check = node.getElementsByTagName("check")
+		if (check):
+			check = node.getElementsByTagName("check")[0]
+			self.check_min = self._attr(check, 'min', False)
+			self.check_max = self._attr(check, 'max', False)
+			self.check_regexp = self._attr(check, 'regexp', False)
+		else:
+			self.check_min = None
+			self.check_max = None
+			self.check_regexp = None
+
+
+	def c_type(self):
+		if self.otype == "boolean":
+			return "int"
+		elif self.is_string:
+			return "char*"
+		else:
+			return self.otype
+
+	def sql_type(self):
+		if self.otype == "int":
+			return "integer"
+		return self.otype
+
+	def c_comment(self):
+		comment = ""
+		if (self.otype == "message"):
+			comment = self.formatted_default()
+		elif len(self.short):
+			comment = "%s (default: %s)" % (self.short, self.formatted_default())
+		return comment
+
+	def formatted_default(self):
+		if self.is_string:
+			return "\"%s\"" % self.default
+		return self.default
+
+class SourceGenerator(object):
+	def __init__(self, filename, cppStyle = True):
+		print ("Generating %s..." % filename)
+		self.f = open(filename, 'w');
+
+	def write_header(self, Comment = True):
+		if Comment:
+			s =  "/*\n * uhub - A tiny ADC p2p connection hub\n"
+			s += " * Copyright (C) 2007-%s, Jan Vidar Krey\n *\n" % datetime.now().strftime("%Y")
+			s += " * THIS FILE IS AUTOGENERATED - DO NOT MODIFY\n"
+			s += " * Created %s, by config.py\n */\n\n" % datetime.now().strftime("%Y-%m-%d %H:%M")
+			self.f.write(s)
+
+class CHeaderGenerator(SourceGenerator):
+	def __init__(self, filename):
+		super(CHeaderGenerator, self).__init__(filename)
+
+	def _write_declaration(self, option):
+		comment = ' ' * (32 - len(option.name)) + "/*<<< %s */" % option.c_comment()
+		ptype = option.c_type() + (5 - len(option.c_type())) * ' '
+		self.f.write("\t%(type)s %(name)s;%(comment)s\n" % {
+				"type": ptype,
+				"name": option.name,
+				"comment": comment})
+
+	def write(self, options):
+		self.write_header()
+		self.f.write("struct hub_config\n{\n")
+		for option in options:
+			self._write_declaration(option)
+		self.f.write("};\n\n")
+
+class CSourceGenerator(SourceGenerator):
+	def __init__(self, filename):
+		super(CSourceGenerator, self).__init__(filename)
+
+	def _write_default_impl(self, option):
+		s = "\tconfig->%s = " % option.name
+		if option.is_string:
+			s += "hub_strdup(%s);\n" % option.formatted_default()
+		else:
+			s += option.formatted_default() + ";\n"
+		self.f.write(s)
+
+	def _write_apply_impl(self, option):
+		s = "\tif (!strcmp(key, \"%s\"))\n\t{\n" % option.name
+		if option.otype == "int":
+			s_min = "0"
+			s_max = "0"
+			if (option.check_min):
+				s += "\t\tmin = %s;\n" % option.check_min
+				s_min = "&min"
+			if (option.check_max):
+				s += "\t\tmax = %s;\n" % option.check_max
+				s_max = "&max"
+			s+= "\t\tif (!apply_integer(key, data, &config->%s, %s, %s))\n" % (option.name, s_min, s_max)
+		elif option.otype == "boolean":
+			s += "\t\tif (!apply_boolean(key, data, &config->%s))\n" % option.name
+		elif option.is_string:
+			s += "\t\tif (!apply_string(key, data, &config->%s, (char*) \"\"))\n" % option.name
+		s += "\t\t{\n\t\t\tLOG_ERROR(\"Configuration parse error on line %d\", line_count);\n\t\t\treturn -1;\n\t\t}\n\t\treturn 0;\n\t}\n\n"
+		self.f.write(s)
+
+	def _write_free_impl(self, option):
+		if option.is_string:
+			self.f.write("\thub_free(config->%s);\n\n" % option.name)
+
+	def _write_dump_impl(self, option):
+		s = ""
+		fmt = "%s"
+		val = "config->%s" % option.name
+		test = "config->%s != %s" % (option.name, option.default)
+
+		if (option.otype == "int"):
+			fmt = "%d"
+		elif (option.otype == "boolean"):
+			val = "config->%s ? \"yes\" : \"no\"" % option.name
+		elif (option.is_string):
+			fmt = "\\\"%s\\\"";
+			test = "strcmp(config->%s, %s) != 0" % (option.name, option.formatted_default())
+
+		s += "\tif (!ignore_defaults || %s)\n" % test;
+		s += "\t\tfprintf(stdout, \"%s = %s\\n\", %s);\n\n" % (option.name, fmt, val)
+		self.f.write(s)
+
+	def write(self, options):
+		self.write_header()
+		self.f.write("void config_defaults(struct hub_config* config)\n{\n")
+		for option in options:
+			self._write_default_impl(option)
+		self.f.write("}\n\n")
+		self.f.write("static int apply_config(struct hub_config* config, char* key, char* data, int line_count)\n{\n\tint max = 0;\n\tint min = 0;\n\n")
+		for option in options:
+			self._write_apply_impl(option)
+		self.f.write("\t/* Still here -- unknown directive */\n\tLOG_ERROR(\"Unknown configuration directive: '%s'\", key);\n\treturn -1;\n}\n\n")
+		self.f.write("void free_config(struct hub_config* config)\n{\n")
+		for option in options:
+			self._write_free_impl(option)
+		self.f.write("}\n\n")
+		self.f.write("void dump_config(struct hub_config* config, int ignore_defaults)\n{\n")
+		for option in options:
+			self._write_dump_impl(option)
+		self.f.write("}\n\n")
+
+class SqlWebsiteDocsGenerator(SourceGenerator):
+	def __init__(self, filename, sqlite_support = False):
+		self.sqlite_support = sqlite_support
+		super(SqlWebsiteDocsGenerator, self).__init__(filename)
+
+	def _sql_escape(self, s):
+		if self.sqlite_support:
+			return s.replace("\"", "\"\"")
+		return s.replace("\"", "\\\"")
+		
+
+	def _write_or_null(self, s):
+		if (not s or len(s) == 0):
+			return "NULL"
+		return "\"%s\"" % self._sql_escape(s)
+
+	def write(self, options):
+		self.write_header(False)
+		table = "uhub_config"
+
+		s = ""
+		if not self.sqlite_support:
+			s += "START TRANSACTION;\n\nDROP TABLE %(table)s IF EXISTS;" % { "table": table }
+		s += "\n\nCREATE TABLE %(table)s (\n\tname VARCHAR(32) UNIQUE NOT NULL,\n\tdefaultValue TINYTEXT NOT NULL,\n\tdescription LONGTEXT NOT NULL,\n\ttype TINYTEXT NOT NULL,\n\tadvanced BOOLEAN,\n\texample LONGTEXT,\n\tsince TINYTEXT\n);\n\n" % { "table": table }
+		self.f.write(s)
+
+		for option in options:
+			s = "INSERT INTO %(table)s VALUES(\"%(name)s\", \"%(default)s\", \"%(description)s\", \"%(type)s\", %(example)s, %(since)s, %(advanced)s);\n" % {
+					"table": table,
+					"name": self._sql_escape(option.name),
+					"default": self._sql_escape(option.formatted_default()),
+					"description": self._sql_escape(option.description),
+					"type": option.sql_type(),
+					"example": self._write_or_null(option.example),
+					"since": self._write_or_null(option.since),
+					"advanced": self._write_or_null(option.example),
+				}
+			self.f.write(s)
+
+		if not self.sqlite_support:
+			self.f.write("\n\nCOMMIT;\n\n")
+
+if __name__ == "__main__":
+	# parser = argparse.ArgumentParser(description = "Configuration file parser and source generator")
+	# parser.add_argument("--in", nargs=1, type=argparse.FileType('r'), default="config.xml", help="Input file (config.xml)", required = True)
+	# parser.add_argument("--c-decl", nargs=1, type=argparse.FileType('w'), default="gen_config.h", help="Output file for C declarations (gen_config.h)")
+	# parser.add_argument("--c-impl", nargs=1, type=argparse.FileType('w'), default="gen_config.c", help="Output file for C implementation (gen_config.c)")
+	# parser.add_argument("--doc-sql", nargs=1, type=argparse.FileType('w'), help="Output file for SQL documentation")
+	# args = parser.parse_args()
+
+	xmldoc = minidom.parse("./config.xml")
+	opt_tags = xmldoc.getElementsByTagName('option')
+	options = []
+	for option in opt_tags:
+		opt = Option(option)
+		options.append(opt)
+
+	header = CHeaderGenerator("./gen_config.h");
+	header.write(options);
+
+	source = CSourceGenerator("./gen_config.c");
+	source.write(options);
+
+	#sql = SqlWebsiteDocsGenerator("./gen_config.sql", True);
+	#sql.write(options);
+
+

src/core/config.xml

@@ -17,7 +17,7 @@
 	</option>
 
 	<option name="server_bind_addr" type="string" default="any">
-		<check regexp="(\d\.\d\.\d\.\d\)|(any)|(loopback)|(.*)" /><!-- FIXME: add better IPv6 regexp in the future! -->
+		<check regexp="[\x:.]+|any|loopback" />
 		<short>Server bind address</short>
 		<description><![CDATA[
 			Specify the IP address the local hub should bind to. This can be an IPv4 or IPv6 address, or one of the special addresses "any" or "loopback". <br />
@@ -58,7 +58,7 @@
 	</option>
 
 	<option name="server_alt_ports" type="string" default="">
-		<check regexp="((\d+)(,(\d+))*)?" />
+		<check regexp="\d+(,\d+)*" />
 		<short>Comma separated list of alternative ports to listen to</short>
 		<description><![CDATA[
 		In addition to the server_port the hub can listen to a list of alternative ports.
@@ -111,7 +111,7 @@
    <option name="register_self" type="boolean" default="0">
 	   <short>Allow users to register themselves on the hub.</short>
 		<description><![CDATA[
-			If this is enabled guests can register their nickname on the hub.
+			If this is enabled guests can register their nickname on the hub using !register command.
 			Otherwise only operators can register users.
 		]]></description>
 		<since>0.4.0</since>
@@ -157,7 +157,7 @@
 	</option>
 
 	<option name="redirect_addr" type="string" default="">
-		<check regexp="(adc|adcs|dchub)://.*" />
+		<check regexp="(adcs?|dchub)://.*" />
 		<short>A common hub redirect address.</short>
 		<description><![CDATA[
 		This is the redirect address used when the hub wants to redirect a client for not fulfilling some requirements.
@@ -419,7 +419,7 @@
 	</option>
 
 	<option name="tls_require_redirect_addr" type="string" default="">
-		<check regexp="(adc|adcs|dchub)://.*" />
+		<check regexp="(adcs?|dchub)://.*" />
 		<short>A redirect address in case a client connects using "adc://" when "adcs://" is required.</short>
 		<description><![CDATA[
 		This is the redirect address used when the hub wants to redirect a client for not using ADCS.
@@ -428,11 +428,10 @@
 		<since>0.3.3</since>
 	</option>
 
-
 	<option name="tls_certificate" type="file" default="">
 		<short>Certificate file</short>
 		<description><![CDATA[
-			Path to a TLS/SSL certificate (PEM format).
+			Path to a TLS/SSL certificate or certificate chain (PEM format).
 		]]></description>
 		<since>0.3.0</since>
 	</option>
@@ -445,6 +444,40 @@
 		<since>0.3.0</since>
 	</option>
 
+	<option name="tls_ciphersuite" type="string" default="ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+3DES:!aNULL:!MD5:!DSS">
+		<short>List of TLS ciphers to use</short>
+		<description><![CDATA[
+			This is a colon separated list of preferred ciphers in the OpenSSL format.
+		]]></description>
+		<since>0.5.0</since>
+		<example><![CDATA[
+			<p>
+			High security with emphasis on forward secrecy:<br />
+			tls_ciphersuite = "ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+3DES:!aNULL:!MD5:!DSS"
+			</p>
+			<p>
+			Allow ChaCha20/Poly1305 which are secure, yet generally faster:<br />
+			tls_ciphersuite = "ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA"
+			</p>
+		]]></example>
+	</option>
+
+	<option name="tls_version" type="string" default="1.2">
+		<short>Specify minimum TLS version supported.</short>
+		<description><![CDATA[
+			<p>
+			This allows you to specify the minimum TLS version the hub requires from connecting clients in order to
+			connect to the hub.
+			</p>
+			<p>
+			TLS version 1.2 is recommended and enabled by default.
+			TLS version 1.1 is acceptable without any known flaws, and allows for older clients to connect.
+			TLS version 1.0 should be avoided, even though it is the most compatible with older ADC clients.
+			</p>
+		]]></description>
+		<since>0.5.0</since>
+	</option>
+
 	<option name="file_acl" type="file" default="">
 		<short>File containing access control lists</short>
 		<description><![CDATA[

src/core/eventid.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/eventqueue.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -32,20 +32,20 @@ int event_queue_initialize(struct event_queue** queue, event_queue_callback call
 	*queue = (struct event_queue*) hub_malloc_zero(sizeof(struct event_queue));
 	if (!(*queue))
 		return -1;
-	
+
 	(*queue)->q1 = list_create();
 	(*queue)->q2 = list_create();
-	
+
 	if (!(*queue)->q1 || !(*queue)->q2)
 	{
 		list_destroy((*queue)->q1);
 		list_destroy((*queue)->q2);
 		return -1;
 	}
-	
+
 	(*queue)->callback = callback;
 	(*queue)->callback_data = ptr;
-	
+
 	return 0;
 }
 
@@ -73,35 +73,27 @@ int event_queue_process(struct event_queue* queue)
 	struct event_data* data;
 	if (queue->locked)
 		return 0;
-	
+
 	/* lock primary queue, and handle the primary queue messages. */
 	queue->locked = 1;
-	
-	data = (struct event_data*) list_get_first(queue->q1);
-	while (data)
+
+	LIST_FOREACH(struct event_data*, data, queue->q1,
 	{
 #ifdef EQ_DEBUG
 		eq_debug("EXEC", data);
 #endif
 		queue->callback(queue->callback_data, data);
-		data = (struct event_data*) list_get_next(queue->q1);
-	}
-	
+	});
+
 	list_clear(queue->q1, event_queue_cleanup_callback);
 	uhub_assert(list_size(queue->q1) == 0);
-		
+
 	/* unlock queue */
 	queue->locked = 0;
-	
+
 	/* transfer from secondary queue to the primary queue. */
-	data = (struct event_data*) list_get_first(queue->q2);
-	while (data)
-	{
-		list_remove(queue->q2, data);
-		list_append(queue->q1, data);
-		data = (struct event_data*) list_get_first(queue->q2);
-	}
-	
+	list_append_list(queue->q1, queue->q2);
+
 	/* if more events exist, schedule it */
 	if (list_size(queue->q1))
 	{
@@ -114,18 +106,18 @@ void event_queue_post(struct event_queue* queue, struct event_data* message)
 {
 	struct linked_list* q = (!queue->locked) ? queue->q1 : queue->q2;
 	struct event_data* data;
-	
+
 	data = (struct event_data*) hub_malloc(sizeof(struct event_data));
 	if (data)
 	{
 		data->id    = message->id;
 		data->ptr   = message->ptr;
 		data->flags = message->flags;
-		
+
 #ifdef EQ_DEBUG
 		eq_debug("POST", data);
 #endif
-		
+
 		list_append(q, data);
 	}
 	else

src/core/eventqueue.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/gen_config.c

@@ -1,4 +1,10 @@
-/* THIS FILE IS AUTOGENERATED - DO NOT CHANGE IT! */
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2014, Jan Vidar Krey
+ *
+ * THIS FILE IS AUTOGENERATED - DO NOT MODIFY
+ * Created 2014-07-29 12:22, by config.py
+ */
 
 void config_defaults(struct hub_config* config)
 {
@@ -45,6 +51,8 @@ void config_defaults(struct hub_config* config)
 	config->tls_require_redirect_addr = hub_strdup("");
 	config->tls_certificate = hub_strdup("");
 	config->tls_private_key = hub_strdup("");
+	config->tls_ciphersuite = hub_strdup("ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+3DES:!aNULL:!MD5:!DSS");
+	config->tls_version = hub_strdup("1.2");
 	config->file_acl = hub_strdup("");
 	config->file_plugins = hub_strdup("");
 	config->msg_hub_full = hub_strdup("Hub is full");
@@ -546,6 +554,26 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 		return 0;
 	}
 
+	if (!strcmp(key, "tls_ciphersuite"))
+	{
+		if (!apply_string(key, data, &config->tls_ciphersuite, (char*) ""))
+		{
+			LOG_ERROR("Configuration parse error on line %d", line_count);
+			return -1;
+		}
+		return 0;
+	}
+
+	if (!strcmp(key, "tls_version"))
+	{
+		if (!apply_string(key, data, &config->tls_version, (char*) ""))
+		{
+			LOG_ERROR("Configuration parse error on line %d", line_count);
+			return -1;
+		}
+		return 0;
+	}
+
 	if (!strcmp(key, "file_acl"))
 	{
 		if (!apply_string(key, data, &config->file_acl, (char*) ""))
@@ -949,6 +977,10 @@ void free_config(struct hub_config* config)
 
 	hub_free(config->tls_private_key);
 
+	hub_free(config->tls_ciphersuite);
+
+	hub_free(config->tls_version);
+
 	hub_free(config->file_acl);
 
 	hub_free(config->file_plugins);
@@ -1158,6 +1190,12 @@ void dump_config(struct hub_config* config, int ignore_defaults)
 	if (!ignore_defaults || strcmp(config->tls_private_key, "") != 0)
 		fprintf(stdout, "tls_private_key = \"%s\"\n", config->tls_private_key);
 
+	if (!ignore_defaults || strcmp(config->tls_ciphersuite, "ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+3DES:!aNULL:!MD5:!DSS") != 0)
+		fprintf(stdout, "tls_ciphersuite = \"%s\"\n", config->tls_ciphersuite);
+
+	if (!ignore_defaults || strcmp(config->tls_version, "1.2") != 0)
+		fprintf(stdout, "tls_version = \"%s\"\n", config->tls_version);
+
 	if (!ignore_defaults || strcmp(config->file_acl, "") != 0)
 		fprintf(stdout, "file_acl = \"%s\"\n", config->file_acl);
 

src/core/gen_config.h

@@ -1,4 +1,10 @@
-/* THIS FILE IS AUTOGENERATED - DO NOT CHANGE IT! */
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2014, Jan Vidar Krey
+ *
+ * THIS FILE IS AUTOGENERATED - DO NOT MODIFY
+ * Created 2014-07-29 12:22, by config.py
+ */
 
 struct hub_config
 {
@@ -45,6 +51,8 @@ struct hub_config
 	char* tls_require_redirect_addr;       /*<<< A redirect address in case a client connects using "adc://" when "adcs://" is required. (default: "") */
 	char* tls_certificate;                 /*<<< Certificate file (default: "") */
 	char* tls_private_key;                 /*<<< Private key file (default: "") */
+	char* tls_ciphersuite;                 /*<<< List of TLS ciphers to use (default: "ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+3DES:!aNULL:!MD5:!DSS") */
+	char* tls_version;                     /*<<< Specify minimum TLS version supported. (default: "1.2") */
 	char* file_acl;                        /*<<< File containing access control lists (default: "") */
 	char* file_plugins;                    /*<<< Plugin configuration file (default: "") */
 	char* msg_hub_full;                    /*<<< "Hub is full" */

src/core/hub.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -23,7 +23,7 @@ struct hub_info* g_hub = 0;
 
 /* FIXME: Flood control should be done in a plugin! */
 #define CHECK_FLOOD(TYPE, WARN) \
-	if (flood_control_check(&u->flood_ ## TYPE , hub->config->flood_ctl_  ## TYPE, hub->config->flood_ctl_interval, net_get_time())) \
+	if (flood_control_check(&u->flood_ ## TYPE , hub->config->flood_ctl_  ## TYPE, hub->config->flood_ctl_interval, net_get_time()) &&  !auth_cred_is_unrestricted(u->credentials)) \
 	{ \
 		if (WARN) \
 		{ \
@@ -731,7 +731,11 @@ static int load_ssl_certificates(struct hub_info* hub, struct hub_config* config
 {
 	if (config->tls_enable)
 	{
-		hub->ctx = net_ssl_context_create();
+		hub->ctx = net_ssl_context_create(config->tls_version, config->tls_ciphersuite);
+
+		if (!hub->ctx)
+		  return 0;
+
 		if (ssl_load_certificate(hub->ctx, config->tls_certificate) &&
 			ssl_load_private_key(hub->ctx, config->tls_private_key) &&
 			ssl_check_private_key(hub->ctx))
@@ -905,7 +909,8 @@ void hub_set_variables(struct hub_info* hub, struct acl_handle* acl)
 	if (hub->command_info)
 	{
 		adc_msg_add_named_argument(hub->command_info, ADC_INF_FLAG_CLIENT_TYPE, ADC_CLIENT_TYPE_HUB);
-		adc_msg_add_named_argument(hub->command_info, ADC_INF_FLAG_USER_AGENT, server);
+		adc_msg_add_named_argument(hub->command_info, ADC_INF_FLAG_USER_AGENT_PRODUCT, PRODUCT);
+		adc_msg_add_named_argument(hub->command_info, ADC_INF_FLAG_USER_AGENT_VERSION, GIT_VERSION);
 
 		tmp = adc_msg_escape(hub->config->hub_name);
 		adc_msg_add_named_argument(hub->command_info, ADC_INF_FLAG_NICK, tmp);
@@ -1320,9 +1325,7 @@ void hub_logout_log(struct hub_info* hub, struct hub_user* user)
 	list_append(hub->logout_info, loginfo);
 	while (list_size(hub->logout_info) > (size_t) hub->config->max_logout_log)
 	{
-		struct hub_logout_info* entry = list_get_first(hub->logout_info);
-		list_remove(hub->logout_info, entry);
-		hub_free(entry);
+		list_remove_first(hub->logout_info, hub_free);
 	}
 }
 

src/core/hub.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -27,7 +27,7 @@ enum status_message
 	status_msg_hub_registered_users_only = -3,  /* hub is for registered users only */
 	status_msg_inf_error_nick_missing    = -4,  /* no nickname given */
 	status_msg_inf_error_nick_multiple   = -5,  /* multiple nicknames given */
-	status_msg_inf_error_nick_invalid    = -6,  /* generic/unkown */
+	status_msg_inf_error_nick_invalid    = -6,  /* generic/unknown */
 	status_msg_inf_error_nick_long       = -7,  /* nickname too long */
 	status_msg_inf_error_nick_short      = -8,  /* nickname too short */
 	status_msg_inf_error_nick_spaces     = -9,  /* nickname cannot start with spaces */
@@ -50,12 +50,12 @@ enum status_message
 	status_msg_user_share_size_high      = -41, /* User is sharing too much. */
 	status_msg_user_slots_low            = -42, /* User has too few slots open. */
 	status_msg_user_slots_high           = -43, /* User has too many slots open. */
-	status_msg_user_hub_limit_low        = -44, /* Use is on too few hubs. */
-	status_msg_user_hub_limit_high       = -45, /* Use is on too many hubs. */
+	status_msg_user_hub_limit_low        = -44, /* User is on too few hubs. */
+	status_msg_user_hub_limit_high       = -45, /* User is on too many hubs. */
 
 	status_msg_proto_no_common_hash      = -50, /* No common hash algorithms */
 	status_msg_proto_obsolete_adc0       = -51, /* Client is using an obsolete protocol version */
-	
+
 
 };
 

src/core/hubevent.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/hubevent.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/inf.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -109,14 +109,14 @@ static int check_cid(struct hub_info* hub, struct hub_user* user, struct adc_mes
 		hub_free(pid);
 		return status_msg_inf_error_cid_invalid;
 	}
-	
+
 	if (strlen(pid) != MAX_CID_LEN)
 	{
 		hub_free(cid);
 		hub_free(pid);
 		return status_msg_inf_error_pid_invalid;
 	}
-	
+
 	for (pos = 0; pos < MAX_CID_LEN; pos++)
 	{
 		if (!is_valid_base32_char(cid[pos]))
@@ -133,18 +133,18 @@ static int check_cid(struct hub_info* hub, struct hub_user* user, struct adc_mes
 			return status_msg_inf_error_pid_invalid;
 		}
 	}
-	
+
 	if (!check_hash_tiger(cid, pid))
 	{
 		hub_free(cid);
 		hub_free(pid);
 		return status_msg_inf_error_cid_invalid;
 	}
-	
+
 	/* Set the cid in the user object */
 	memcpy(user->id.cid, cid, MAX_CID_LEN);
 	user->id.cid[MAX_CID_LEN] = 0;
-	
+
 	hub_free(cid);
 	hub_free(pid);
 	return 0;
@@ -154,7 +154,7 @@ static int check_cid(struct hub_info* hub, struct hub_user* user, struct adc_mes
 static int check_required_login_flags(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
 {
 	int num = 0;
-	
+
 	num = adc_msg_has_named_argument(cmd, ADC_INF_FLAG_CLIENT_ID);
 	if (num != 1)
 	{
@@ -162,7 +162,7 @@ static int check_required_login_flags(struct hub_info* hub, struct hub_user* use
 			return status_msg_inf_error_cid_missing;
 		return status_msg_inf_error_cid_invalid;
 	}
-	
+
 	num = adc_msg_has_named_argument(cmd, ADC_INF_FLAG_PRIVATE_ID);
 	if (num != 1)
 	{
@@ -190,7 +190,7 @@ static int check_required_login_flags(struct hub_info* hub, struct hub_user* use
 static int check_network(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
 {
 	const char* address = user_get_address(user);
-	
+
 	/* Check for NAT override address */
 	if (acl_is_ip_nat_override(hub->acl, address))
 	{
@@ -236,12 +236,12 @@ static int nick_length_ok(const char* nick)
 	{
 		return nick_invalid_short;
 	}
-	
+
 	if (length > MAX_NICK_LEN)
 	{
 		return nick_invalid_long;
 	}
-	
+
 	return nick_ok;
 }
 
@@ -249,16 +249,16 @@ static int nick_length_ok(const char* nick)
 static int nick_bad_characters(const char* nick)
 {
 	const char* tmp;
-	
+
 	/* Nick must not start with a space */
 	if (nick[0] == ' ')
 		return nick_invalid_spaces;
-	
+
 	/* Check for ASCII values below 32 */
 	for (tmp = nick; *tmp; tmp++)
 		if ((*tmp < 32) && (*tmp > 0))
 			return nick_invalid_bad_ascii;
-	
+
 	return nick_ok;
 }
 
@@ -286,7 +286,7 @@ static int check_nick(struct hub_info* hub, struct hub_user* user, struct adc_me
 	nick = adc_msg_unescape(tmp);
 	free(tmp); tmp = 0;
 	if (!nick) return 0;
-	
+
 	status = nick_length_ok(nick);
 	if (status != nick_ok)
 	{
@@ -295,7 +295,7 @@ static int check_nick(struct hub_info* hub, struct hub_user* user, struct adc_me
 			return status_msg_inf_error_nick_short;
 		return status_msg_inf_error_nick_long;
 	}
-	
+
 	status = nick_bad_characters(nick);
 	if (status != nick_ok)
 	{
@@ -304,20 +304,20 @@ static int check_nick(struct hub_info* hub, struct hub_user* user, struct adc_me
 			return status_msg_inf_error_nick_spaces;
 		return status_msg_inf_error_nick_bad_chars;
 	}
-	
+
 	status = nick_is_utf8(nick);
 	if (status != nick_ok)
 	{
 		hub_free(nick);
 		return status_msg_inf_error_nick_not_utf8;
 	}
-	
+
 	if (user_is_connecting(user))
 	{
 		memcpy(user->id.nick, nick, strlen(nick));
 		user->id.nick[strlen(nick)] = 0;
 	}
-	
+
 	hub_free(nick);
 	return 0;
 }
@@ -327,12 +327,12 @@ static int check_logged_in(struct hub_info* hub, struct hub_user* user, struct a
 {
 	struct hub_user* lookup1 = uman_get_user_by_nick(hub->users, user->id.nick);
 	struct hub_user* lookup2 = uman_get_user_by_cid(hub->users, user->id.cid);
-	
+
 	if (lookup1 == user)
 	{
 		return 0;
 	}
-	
+
 	if (lookup1 || lookup2)
 	{
 		if (lookup1 == lookup2)
@@ -366,21 +366,37 @@ static int check_logged_in(struct hub_info* hub, struct hub_user* user, struct a
  */
 static int check_user_agent(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
 {
-	char* ua_encoded = 0;
-	char* ua = 0;
-	
+	char* ua_name_encoded = 0;
+	char* ua_version_encoded = 0;
+	char* str = 0;
+	size_t offset = 0;
+
 	/* Get client user agent version */
-	ua_encoded = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_USER_AGENT);
-	if (ua_encoded)
+	ua_name_encoded = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_USER_AGENT_PRODUCT);
+	ua_version_encoded = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_USER_AGENT_VERSION);
+	if (ua_name_encoded)
 	{
-		ua = adc_msg_unescape(ua_encoded);
-		if (ua)
+		str = adc_msg_unescape(ua_name_encoded);
+		if (str)
 		{
-			memcpy(user->id.user_agent, ua, MIN(strlen(ua), MAX_UA_LEN));
-			hub_free(ua);
+			offset = strlen(str);
+			memcpy(user->id.user_agent, str, MIN(offset, MAX_UA_LEN));
+			hub_free(str);
 		}
 	}
-	hub_free(ua_encoded);
+
+	if (ua_version_encoded)
+	{
+		str = adc_msg_unescape(ua_version_encoded);
+		if (str)
+		{
+			memcpy(user->id.user_agent + offset, str, MIN(strlen(str), MAX_UA_LEN - offset));
+			hub_free(str);
+		}
+	}
+
+	hub_free(ua_name_encoded);
+	hub_free(ua_version_encoded);
 	return 0;
 }
 
@@ -391,7 +407,7 @@ static int check_acl(struct hub_info* hub, struct hub_user* user, struct adc_mes
 	{
 		return status_msg_ban_permanently;
 	}
-	
+
 	if (acl_is_user_banned(hub->acl, user->id.nick))
 	{
 		return status_msg_ban_permanently;
@@ -401,7 +417,7 @@ static int check_acl(struct hub_info* hub, struct hub_user* user, struct adc_mes
 	{
 		return status_msg_inf_error_nick_restricted;
 	}
-	
+
 	return 0;
 }
 
@@ -470,7 +486,7 @@ static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_
 		hub_free(arg);
 		arg = 0;
 	}
-	
+
 	arg = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_UPLOAD_SLOTS);
 	if (arg)
 	{
@@ -534,7 +550,7 @@ static int set_credentials(struct hub_info* hub, struct hub_user* user, struct a
 {
 	int ret = 0;
 	struct auth_info* info = acl_get_access_info(hub, user->id.nick);
-	
+
 	if (info)
 	{
 		user->credentials = info->credentials;
@@ -550,11 +566,15 @@ static int set_credentials(struct hub_info* hub, struct hub_user* user, struct a
 	{
 		case auth_cred_none:
 			break;
-			
+
 		case auth_cred_bot:
 			adc_msg_add_argument(cmd, ADC_INF_FLAG_CLIENT_TYPE ADC_CLIENT_TYPE_BOT);
 			break;
-			
+
+		case auth_cred_ubot:
+			adc_msg_add_argument(cmd, ADC_INF_FLAG_CLIENT_TYPE ADC_CLIENT_TYPE_BOT);
+			break;
+
 		case auth_cred_guest:
 			/* Nothing to be added to the info message */
 			break;
@@ -566,7 +586,15 @@ static int set_credentials(struct hub_info* hub, struct hub_user* user, struct a
 		case auth_cred_operator:
 			adc_msg_add_argument(cmd, ADC_INF_FLAG_CLIENT_TYPE ADC_CLIENT_TYPE_OPERATOR);
 			break;
-			
+
+		case auth_cred_opbot:
+			adc_msg_add_argument(cmd, ADC_INF_FLAG_CLIENT_TYPE ADC_CLIENT_TYPE_HUBBOT);
+			break;
+
+		case auth_cred_opubot:
+			adc_msg_add_argument(cmd, ADC_INF_FLAG_CLIENT_TYPE ADC_CLIENT_TYPE_HUBBOT);
+			break;
+
 		case auth_cred_super:
 			adc_msg_add_argument(cmd, ADC_INF_FLAG_CLIENT_TYPE ADC_CLIENT_TYPE_SUPER_USER);
 			break;
@@ -578,7 +606,7 @@ static int set_credentials(struct hub_info* hub, struct hub_user* user, struct a
 		case auth_cred_link:
 			break;
  	}
-	
+
 	return ret;
 }
 
@@ -611,10 +639,10 @@ static int hub_handle_info_common(struct hub_user* user, struct adc_message* cmd
 {
 	/* Remove server restricted flags */
 	remove_server_restricted_flags(cmd);
-	
+
 	/* Update/set the feature cast flags. */
 	set_feature_cast_supports(user, cmd);
-	
+
 	return 0;
 }
 
@@ -622,7 +650,8 @@ static int hub_handle_info_low_bandwidth(struct hub_info* hub, struct hub_user*
 {
 	if (hub->config->low_bandwidth_mode)
 	{
-		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_USER_AGENT);
+		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_USER_AGENT_VERSION);
+		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_USER_AGENT_PRODUCT);
 		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_SHARED_FILES);
 		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_COUNT_HUB_NORMAL);
 		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_COUNT_HUB_REGISTER);
@@ -635,7 +664,7 @@ static int hub_handle_info_low_bandwidth(struct hub_info* hub, struct hub_user*
 		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_DESCRIPTION);
 		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_EMAIL);
 	}
-	
+
 	return 0;
 }
 
@@ -680,20 +709,20 @@ int hub_handle_info_login(struct hub_info* hub, struct hub_user* user, struct ad
 	{
 		return status_msg_hub_full;
 	}
-	
+
 	if (check_registered_users_only(hub, user))
 	{
 		return status_msg_hub_registered_users_only;
 	}
-	
+
 	INF_CHECK(check_limits, hub, user, cmd);
-	
+
 	/* strip off stuff if low_bandwidth_mode is enabled */
 	hub_handle_info_low_bandwidth(hub, user, cmd);
-	
+
 	/* Set initial user info */
 	user_set_info(user, cmd);
-	
+
 	return code;
 }
 

src/core/inf.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/ioqueue.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -72,7 +72,7 @@ size_t ioq_recv_set(struct ioq_recv* q, void* buf, size_t bufsize)
 		q->buf = 0;
 		q->size = 0;
 	}
-	
+
 	if (!bufsize)
 	{
 		return 0;
@@ -130,7 +130,7 @@ void ioq_send_add(struct ioq_send* q, struct adc_message* msg_)
 	q->size += msg->length;
 }
 
-void ioq_send_remove(struct ioq_send* q, struct adc_message* msg)
+static void ioq_send_remove(struct ioq_send* q, struct adc_message* msg)
 {
 #ifdef DEBUG_SENDQ
 	debug_msg("ioq_send_remove", msg);

src/core/ioqueue.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/main.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -87,7 +87,7 @@ void setup_signal_handlers(struct hub_info* hub)
 	act.sa_mask = sig_set;
 	act.sa_flags = SA_ONSTACK | SA_RESTART;
 	act.sa_handler = hub_handle_signal;
-	
+
 	for (i = 0; signals[i]; i++)
 	{
 		if (sigaction(signals[i], &act, 0) != 0)
@@ -124,7 +124,7 @@ int main_loop()
 			hub_log_initialize(arg_log, arg_log_syslog);
 			hub_set_log_verbosity(arg_verbose);
 		}
-	
+
 		if (read_config(arg_config, &configuration, !arg_have_config) == -1)
 			return -1;
 
@@ -150,7 +150,7 @@ int main_loop()
 #if !defined(WIN32)
 			setup_signal_handlers(hub);
 #ifdef SYSTEMD
-                        /* Notify the service manager that this daemon has 
+                        /* Notify the service manager that this daemon has
                          * been successfully initalized and shall enter the
                          * main loop.
                          */
@@ -174,7 +174,7 @@ int main_loop()
 #if !defined(WIN32)
 	shutdown_signal_handlers(hub);
 #endif
-	
+
 	if (hub)
 	{
 		hub_shutdown_service(hub);
@@ -288,7 +288,7 @@ void parse_command_line(int argc, char** argv)
 				arg_dump_config = 1;
 				arg_check_config = 1;
 				break;
-				
+
 			case 'S':
 				arg_dump_config = 2;
 				arg_check_config = 1;
@@ -297,7 +297,7 @@ void parse_command_line(int argc, char** argv)
 			case 'l':
 				arg_log = optarg;
 				break;
-				
+
 			case 'L':
 				arg_log_syslog = 1;
 				break;

src/core/netevent.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/netevent.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/plugincallback.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -40,14 +40,11 @@ static int plugin_command_dispatch(struct command_base* cbase, struct hub_user*
 
 	LOG_PLUGIN("plugin_command_dispatch: cmd=%s", cmd->prefix);
 
-	cmdh = (struct plugin_command_handle*) list_get_first(data->commands);
-	while (cmdh)
+	LIST_FOREACH(struct plugin_command_handle*, cmdh, data->commands,
 	{
 		if (strcmp(cmdh->prefix, cmd->prefix) == 0)
 			return cmdh->handler(plugin, puser, pcommand);
-
-		cmdh = (struct plugin_command_handle*) list_get_next(data->commands);
-	}
+	});
 	return 0;
 }
 
@@ -68,6 +65,17 @@ static int cbfunc_send_message(struct plugin_handle* plugin, struct plugin_user*
 	return 1;
 }
 
+static int cbfunc_send_broadcast(struct plugin_handle* plugin, const char* message)
+{
+	char* buffer = adc_msg_escape(message);
+	struct adc_message* command = adc_msg_construct(ADC_CMD_IMSG, strlen(buffer) + 6);
+	adc_msg_add_argument(command, buffer);
+	route_to_all(plugin_get_hub(plugin), command);
+	adc_msg_free(command);
+	hub_free(buffer);
+	return 1;
+}
+
 static int cbfunc_send_status(struct plugin_handle* plugin, struct plugin_user* user, int code, const char* message)
 {
 	char code_str[4];
@@ -104,7 +112,6 @@ static int cbfunc_command_add(struct plugin_handle* plugin, struct plugin_comman
 	cmdh->internal_handle = command;
 	list_append(data->commands, cmdh);
 	command_add(plugin_get_hub(plugin)->commands, command, (void*) plugin);
-	printf("*** Add plugin command: %s (%p, %p)\n", command->prefix, command, cmdh);
 	return 0;
 }
 
@@ -113,7 +120,6 @@ static int cbfunc_command_del(struct plugin_handle* plugin, struct plugin_comman
 	struct plugin_callback_data* data = get_callback_data(plugin);
 	struct command_handle* command = (struct command_handle*) cmdh->internal_handle;
 
-	printf("*** Del plugin command: %s (%p, %p)\n", command->prefix, command, cmdh);
 	list_remove(data->commands, cmdh);
 	command_del(plugin_get_hub(plugin)->commands, command);
 	hub_free(command);
@@ -133,6 +139,12 @@ struct plugin_command_arg_data* cbfunc_command_arg_next(struct plugin_handle* pl
 	return (struct plugin_command_arg_data*) hub_command_arg_next((struct hub_command*) cmd, (enum hub_command_arg_type) t);
 }
 
+static size_t cbfunc_get_usercount(struct plugin_handle* plugin)
+{
+	struct hub_info* hub = plugin_get_hub(plugin);
+	return hub->users->count;
+}
+
 static char* cbfunc_get_hub_name(struct plugin_handle* plugin)
 {
 	struct hub_info* hub = plugin_get_hub(plugin);
@@ -158,7 +170,7 @@ static void cbfunc_set_hub_name(struct plugin_handle* plugin, const char* str)
 	char* new_str = adc_msg_escape(str ? str : hub->config->hub_name);
 
 	adc_msg_replace_named_argument(hub->command_info, ADC_INF_FLAG_NICK, new_str);
-		
+
 	// Broadcast hub name
 	command = adc_msg_construct(ADC_CMD_IINF, (strlen(new_str) + 8));
 	adc_msg_add_named_argument(command, ADC_INF_FLAG_NICK, new_str);
@@ -175,7 +187,7 @@ static void cbfunc_set_hub_description(struct plugin_handle* plugin, const char*
 	char* new_str = adc_msg_escape(str ? str : hub->config->hub_description);
 
 	adc_msg_replace_named_argument(hub->command_info, ADC_INF_FLAG_DESCRIPTION, new_str);
-		
+
 	// Broadcast hub description
 	command = adc_msg_construct(ADC_CMD_IINF, (strlen(new_str) + 8));
 	adc_msg_add_named_argument(command, ADC_INF_FLAG_DESCRIPTION, new_str);
@@ -188,12 +200,14 @@ static void cbfunc_set_hub_description(struct plugin_handle* plugin, const char*
 void plugin_register_callback_functions(struct plugin_handle* handle)
 {
 	handle->hub.send_message = cbfunc_send_message;
+	handle->hub.send_broadcast_message = cbfunc_send_broadcast;
 	handle->hub.send_status_message = cbfunc_send_status;
 	handle->hub.user_disconnect = cbfunc_user_disconnect;
 	handle->hub.command_add = cbfunc_command_add;
 	handle->hub.command_del = cbfunc_command_del;
 	handle->hub.command_arg_reset = cbfunc_command_arg_reset;
 	handle->hub.command_arg_next = cbfunc_command_arg_next;
+	handle->hub.get_usercount = cbfunc_get_usercount;
 	handle->hub.get_name = cbfunc_get_hub_name;
 	handle->hub.set_name = cbfunc_set_hub_name;
 	handle->hub.get_description = cbfunc_get_hub_description;

src/core/plugincallback.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/plugininvoke.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -27,13 +27,12 @@
 	PLUGIN_DEBUG(HUB, # FUNCNAME) \
 	if (HUB->plugins && HUB->plugins->loaded) \
 	{ \
-		struct plugin_handle* plugin = (struct plugin_handle*) list_get_first(HUB->plugins->loaded); \
-		while (plugin) \
+		struct plugin_handle* plugin;\
+		LIST_FOREACH(struct plugin_handle*, plugin, HUB->plugins->loaded, \
 		{ \
 			if (plugin->funcs.FUNCNAME) \
 				CODE \
-			plugin = (struct plugin_handle*) list_get_next(HUB->plugins->loaded); \
-		} \
+		}); \
 	}
 
 #define PLUGIN_INVOKE_STATUS_1(HUB, FUNCNAME, ARG1) \

src/core/plugininvoke.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/pluginloader.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -102,7 +102,6 @@ struct plugin_handle* plugin_load(const char* filename, const char* config, stru
 	int ret;
 	struct plugin_handle* handle = (struct plugin_handle*) hub_malloc_zero(sizeof(struct plugin_handle));
 	struct uhub_plugin* plugin = plugin_open(filename);
-	struct plugin_hub_internals* internals = (struct plugin_hub_internals*) plugin->internals;
 
 	if (!plugin)
 		return NULL;
@@ -118,6 +117,7 @@ struct plugin_handle* plugin_load(const char* filename, const char* config, stru
 	unregister_f = plugin_lookup_symbol(plugin, "plugin_unregister");
 
 	// register hub internals
+	struct plugin_hub_internals* internals = (struct plugin_hub_internals*) plugin->internals;
 	internals->unregister = unregister_f;
 	internals->hub = hub;
 	internals->callback_data = plugin_callback_data_create();
@@ -229,16 +229,16 @@ int plugin_initialize(struct hub_config* config, struct hub_info* hub)
 	return 0;
 }
 
+static void plugin_unload_ptr(void* ptr)
+{
+	struct plugin_handle* plugin = (struct plugin_handle*) ptr;
+	plugin_unload(plugin);
+}
+
+
 void plugin_shutdown(struct uhub_plugins* handle)
 {
-	struct plugin_handle* plugin = (struct plugin_handle*) list_get_first(handle->loaded);
-	while (plugin)
-	{
-		list_remove(handle->loaded, plugin);
-		plugin_unload(plugin);
-		plugin = (struct plugin_handle*) list_get_first(handle->loaded);
-	}
-
+	list_clear(handle->loaded, plugin_unload_ptr);
 	list_destroy(handle->loaded);
 }
 

src/core/pluginloader.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/probe.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -71,9 +71,18 @@ static void probe_net_event(struct net_connection* con, int events, void *arg)
 				probe_destroy(probe);
 				return;
 			}
+			else if ((memcmp(probe_recvbuf, "GET ", 4) == 0) ||
+				 (memcmp(probe_recvbuf, "POST", 4) == 0) ||
+				 (memcmp(probe_recvbuf, "HEAD", 4) == 0))
+			{
+				/* Looks like HTTP - Not supported, but we log it. */
+				LOG_TRACE("Probed HTTP connection. Not supported closing connection (%s)", ip_convert_to_string(&probe->addr));
+				const char* buf = "501 Not implemented\r\n\r\n";
+				net_con_send(con, buf, strlen(buf));
+			}
 #ifdef SSL_SUPPORT
 			else if (bytes >= 11 &&
-				probe_recvbuf[0] == 22 && 
+				probe_recvbuf[0] == 22 &&
 				probe_recvbuf[1] == 3 && /* protocol major version */
 				probe_recvbuf[5] == 1 && /* message type */
 				probe_recvbuf[9] == probe_recvbuf[1])

src/core/probe.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/route.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -28,7 +28,7 @@ int route_message(struct hub_info* hub, struct hub_user* u, struct adc_message*
 		case 'B': /* Broadcast to all logged in clients */
 			route_to_all(hub, msg);
 			break;
-			
+
 		case 'D':
 			target = uman_get_user_by_sid(hub->users, msg->target);
 			if (target)
@@ -36,7 +36,7 @@ int route_message(struct hub_info* hub, struct hub_user* u, struct adc_message*
 				route_to_user(hub, target, msg);
 			}
 			break;
-			
+
 		case 'E':
 			target = uman_get_user_by_sid(hub->users, msg->target);
 			if (target)
@@ -45,11 +45,11 @@ int route_message(struct hub_info* hub, struct hub_user* u, struct adc_message*
 				route_to_user(hub, u, msg);
 			}
 			break;
-			
+
 		case 'F':
 			route_to_subscribers(hub, msg);
-			break;	
-		
+			break;
+
 		default:
 			/* Ignore the message */
 			break;
@@ -139,12 +139,11 @@ int route_flush_pipeline(struct hub_info* hub, struct hub_user* u)
 
 int route_to_all(struct hub_info* hub, struct adc_message* command) /* iterate users */
 {
-	struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list);
-	while (user)
+	struct hub_user* user;
+	LIST_FOREACH(struct hub_user*, user, hub->users->list,
 	{
 		route_to_user(hub, user, command);
-		user = (struct hub_user*) list_get_next(hub->users->list);
-	}
+	});
 
 	return 0;
 }
@@ -153,49 +152,40 @@ int route_to_subscribers(struct hub_info* hub, struct adc_message* command) /* i
 {
 	int do_send;
 	char* tmp;
-	
-	struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list);
-	while (user)
+
+	struct hub_user* user;
+	LIST_FOREACH(struct hub_user*, user, hub->users->list,
 	{
 		if (user->feature_cast)
 		{
 			do_send = 1;
-			
-			tmp = list_get_first(command->feature_cast_include);
-			while (tmp)
+
+			LIST_FOREACH(char*, tmp, command->feature_cast_include,
 			{
 				if (!user_have_feature_cast_support(user, tmp))
 				{
 					do_send = 0;
 					break;
 				}
-				tmp = list_get_next(command->feature_cast_include);;
-			}
-			
-			if (!do_send) {
-				user = (struct hub_user*) list_get_next(hub->users->list);
+			});
+
+			if (!do_send)
 				continue;
-			}
-			
-			tmp = list_get_first(command->feature_cast_exclude);
-			while (tmp)
+
+			LIST_FOREACH(char*, tmp, command->feature_cast_exclude,
 			{
 				if (user_have_feature_cast_support(user, tmp))
 				{
 					do_send = 0;
 					break;
 				}
-				tmp = list_get_next(command->feature_cast_exclude);
-			}
-			
+			});
+
 			if (do_send)
-			{
 				route_to_user(hub, user, command);
-			}
 		}
-		user = (struct hub_user*) list_get_next(hub->users->list);
-	}
-	
+	});
+
 	return 0;
 }
 
@@ -210,20 +200,17 @@ int route_info_message(struct hub_info* hub, struct hub_user* u)
 		struct adc_message* cmd = adc_msg_copy(u->info);
 		const char* address = user_get_address(u);
 		struct hub_user* user = 0;
-		
+
 		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV4_ADDR);
 		adc_msg_add_named_argument(cmd, ADC_INF_FLAG_IPV4_ADDR, address);
-	
-		user = (struct hub_user*) list_get_first(hub->users->list);
-		while (user)
+
+		LIST_FOREACH(struct hub_user*, user, hub->users->list,
 		{
 			if (user_is_nat_override(user))
 				route_to_user(hub, user, cmd);
 			else
 				route_to_user(hub, user, u->info);
-			
-			user = (struct hub_user*) list_get_next(hub->users->list);
-		}
+		});
 		adc_msg_free(cmd);
 	}
 	return 0;

src/core/route.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/core/user.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -38,7 +38,7 @@ static const char* user_log_str(struct hub_user* user)
 struct hub_user* user_create(struct hub_info* hub, struct net_connection* con, struct ip_addr_encap* addr)
 {
 	struct hub_user* user = NULL;
-	
+
 	LOG_TRACE("user_create(), hub=%p, con[sd=%d]", hub, net_con_get_sd(con));
 
 	user = (struct hub_user*) hub_malloc_zero(sizeof(struct hub_user));
@@ -90,7 +90,7 @@ void user_set_state(struct hub_user* user, enum user_state state)
 	{
 		return;
 	}
-	
+
 	user->state = state;
 }
 
@@ -135,7 +135,7 @@ void user_update_info(struct hub_user* u, struct adc_message* cmd)
 			prefix[1] = argument[1];
 			adc_msg_replace_named_argument(cmd_new, prefix, argument+2);
 		}
-		
+
 		hub_free(argument);
 		argument = adc_msg_get_argument(cmd, n++);
 	}
@@ -232,15 +232,12 @@ void user_support_remove(struct hub_user* user, int fourcc)
 
 int user_have_feature_cast_support(struct hub_user* user, char feature[4])
 {
-	char* tmp = list_get_first(user->feature_cast);
-	while (tmp)
+	char* tmp;
+	LIST_FOREACH(char*, tmp, user->feature_cast,
 	{
 		if (strncmp(tmp, feature, 4) == 0)
 			return 1;
-	
-		tmp = list_get_next(user->feature_cast);
-	}
-	
+	});
 	return 0;
 }
 

src/core/user.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -51,7 +51,7 @@ enum user_flags
 	flag_muted      = 0x00800000, /** User is muted (cannot chat) */
 	flag_ignore     = 0x01000000, /** Ignore further reads */
 	flag_maxbuf     = 0x02000000, /** Hit max buf read, ignore msg */
-	flag_choke      = 0x04000000, /** Choked: Cannot send, waiting for write event */ 
+	flag_choke      = 0x04000000, /** Choked: Cannot send, waiting for write event */
 	flag_want_read  = 0x08000000, /** Need to read (SSL) */
 	flag_want_write = 0x10000000, /** Need to write (SSL) */
 	flag_user_list  = 0x20000000, /** Send queue bypass (when receiving the send queue) */
@@ -150,7 +150,7 @@ extern void user_destroy(struct hub_user* user);
  * This associates a INF message to the user.
  * If the user already has a INF message associated, then this is
  * released before setting the new one.
- * 
+ *
  * @param info new inf message (can be NULL)
  */
 extern void user_set_info(struct hub_user* user, struct adc_message* info);
@@ -244,7 +244,7 @@ extern int user_flag_get(struct hub_user* user, enum user_flags flag);
  * Check if a user supports 'feature' for feature casting (basis for 'Fxxx' messages)
  * The feature cast is specified as the 'SU' argument to the user's
  * INF-message.
- * 
+ *
  * @param feature a feature to lookup (example: 'TCP4' or 'UDP4')
  * @return 1 if 'feature' supported, or 0 otherwise
  */

src/core/usermanager.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -28,7 +28,7 @@ static void clear_user_list_callback(void* ptr)
 	if (ptr)
 	{
 		struct hub_user* u = (struct hub_user*) ptr;
-		
+
 		/* Mark the user as already being disconnected.
 		 * This prevents the hub from trying to send
 		 * quit messages to other users.
@@ -38,6 +38,11 @@ static void clear_user_list_callback(void* ptr)
 	}
 }
 
+static int uman_map_compare(const void* a, const void* b)
+{
+	return strcmp((const char*) a, (const char*) b);
+}
+
 
 struct hub_user_manager* uman_init()
 {
@@ -46,15 +51,10 @@ struct hub_user_manager* uman_init()
 		return NULL;
 
 	users->list = list_create();
+	users->nickmap = rb_tree_create(uman_map_compare, NULL, NULL);
+	users->cidmap = rb_tree_create(uman_map_compare, NULL, NULL);
 	users->sids = sid_pool_create(net_get_max_sockets());
 
-	if (!users->list)
-	{
-		list_destroy(users->list);
-		hub_free(users);
-		return NULL;
-	}
-
 	return users;
 }
 
@@ -64,11 +64,18 @@ int uman_shutdown(struct hub_user_manager* users)
 	if (!users)
 		return -1;
 
+	if (users->nickmap)
+		rb_tree_destroy(users->nickmap);
+
+	if (users->cidmap)
+		rb_tree_destroy(users->cidmap);
+
 	if (users->list)
 	{
 		list_clear(users->list, &clear_user_list_callback);
 		list_destroy(users->list);
 	}
+
 	sid_pool_destroy(users->sids);
 
 	hub_free(users);
@@ -81,6 +88,9 @@ int uman_add(struct hub_user_manager* users, struct hub_user* user)
 	if (!users || !user)
 		return -1;
 
+	rb_tree_insert(users->nickmap, user->id.nick, user);
+	rb_tree_insert(users->cidmap, user->id.cid, user);
+
 	list_append(users->list, user);
 	users->count++;
 	users->count_peak = MAX(users->count, users->count_peak);
@@ -96,6 +106,8 @@ int uman_remove(struct hub_user_manager* users, struct hub_user* user)
 		return -1;
 
 	list_remove(users->list, user);
+	rb_tree_remove(users->nickmap, user->id.nick);
+	rb_tree_remove(users->cidmap, user->id.cid);
 
 	if (users->count > 0)
 	{
@@ -120,42 +132,29 @@ struct hub_user* uman_get_user_by_sid(struct hub_user_manager* users, sid_t sid)
 
 struct hub_user* uman_get_user_by_cid(struct hub_user_manager* users, const char* cid)
 {
-	struct hub_user* user = (struct hub_user*) list_get_first(users->list); /* iterate users - only on incoming INF msg */
-	while (user)
-	{
-		if (strcmp(user->id.cid, cid) == 0)
-			return user;
-		user = (struct hub_user*) list_get_next(users->list);
-	}
-	return NULL;
+	struct hub_user* user = (struct hub_user*) rb_tree_get(users->cidmap, (const void*) cid);
+	return user;
 }
 
 
 struct hub_user* uman_get_user_by_nick(struct hub_user_manager* users, const char* nick)
 {
-	struct hub_user* user = (struct hub_user*) list_get_first(users->list); /* iterate users - only on incoming INF msg */
-	while (user)
-	{
-		if (strcmp(user->id.nick, nick) == 0)
-			return user;
-		user = (struct hub_user*) list_get_next(users->list);
-	}
-	return NULL;
+	struct hub_user* user = (struct hub_user*) rb_tree_get(users->nickmap, nick);
+	return user;
 }
 
 size_t uman_get_user_by_addr(struct hub_user_manager* users, struct linked_list* target, struct ip_range* range)
 {
 	size_t num = 0;
-	struct hub_user* user = (struct hub_user*) list_get_first(users->list); /* iterate users - only on incoming INF msg */
-	while (user)
+	struct hub_user* user;
+	LIST_FOREACH(struct hub_user*, user, users->list,
 	{
 		if (ip_in_range(&user->id.addr, range))
 		{
 			list_append(target, user);
 			num++;
 		}
-		user = (struct hub_user*) list_get_next(users->list);
-	}
+	});
 	return num;
 }
 
@@ -164,8 +163,8 @@ int uman_send_user_list(struct hub_info* hub, struct hub_user_manager* users, st
 	int ret = 1;
 	struct hub_user* user;
 	user_flag_set(target, flag_user_list);
-	user = (struct hub_user*) list_get_first(users->list); /* iterate users - only on INF or PAS msg */
-	while (user)
+
+	LIST_FOREACH(struct hub_user*, user, users->list,
 	{
 		if (user_is_logged_in(user))
 		{
@@ -173,8 +172,7 @@ int uman_send_user_list(struct hub_info* hub, struct hub_user_manager* users, st
 			if (!ret)
 				break;
 		}
-		user = (struct hub_user*) list_get_next(users->list);
-	}
+	});
 
 #if 0
 	FIXME: FIXME FIXME handle send queue excess

src/core/usermanager.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -24,10 +24,12 @@ struct hub_user_manager
 {
 	size_t count;                   /**<< "Number of all fully connected and logged in users" */
 	size_t count_peak;              /**<< "Peak number of users" */
-	struct sid_pool* sids;
 	uint64_t shared_size;           /**<< "The total number of shared bytes among fully connected users." */
 	uint64_t shared_files;          /**<< "The total number of shared files among fully connected users." */
+	struct sid_pool* sids;          /**<< "Maps SIDs to users (constant time)" */
 	struct linked_list* list;       /**<< "Contains all logged in users" */
+	struct rb_tree* nickmap;        /**<< "Maps nicknames to users (red black tree)" */
+	struct rb_tree* cidmap;         /**<< "Maps CIDs to users (red black tree)" */
 };
 
 /**
@@ -77,7 +79,7 @@ extern sid_t uman_get_free_sid(struct hub_user_manager* users, struct hub_user*
  *
  * NOTE: This function will only search connected users, which means
  * that SIDs assigned to users who are not yet completely logged in,
- * or are in the process of being disconnected will result in this 
+ * or are in the process of being disconnected will result in this
  * function returning NULL even though the sid is not freely available.
  *
  * FIXME: Is that really safe / sensible ?

src/network/backend.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -102,14 +102,7 @@ void net_backend_shutdown()
 }
 
 
-void net_con_reinitialize(struct net_connection* con, net_connection_cb callback, const void* ptr, int events)
-{
-	con->callback = callback;
-	con->ptr = (void*) ptr;
-	net_con_update(con, events);
-}
-
-void net_con_update(struct net_connection* con, int events)
+void net_backend_update(struct net_connection* con, int events)
 {
 	g_backend->handler.con_mod(g_backend->data, con, events);
 }
@@ -148,7 +141,7 @@ int net_backend_process()
 	}
 
 	// Process pending DNS results
-	net_dns_process();
+	// net_dns_process();
 
 	g_backend->handler.backend_process(g_backend->data, res);
 
@@ -166,8 +159,8 @@ void net_con_initialize(struct net_connection* con, int sd, net_connection_cb ca
 {
 	g_backend->handler.con_init(g_backend->data, con, sd, callback, ptr);
 
-	net_set_nonblocking(con->sd, 1);
-	net_set_nosigpipe(con->sd, 1);
+	net_set_nonblocking(net_con_get_sd(con), 1);
+	net_set_nosigpipe(net_con_get_sd(con), 1);
 
 	g_backend->handler.con_add(g_backend->data, con, events);
 	g_backend->common.num++;

src/network/backend.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -75,6 +75,14 @@ extern void net_backend_shutdown();
  */
 extern int net_backend_process();
 
+/**
+ * Update the event mask.
+ *
+ * @param con Connection handle.
+ * @param events Event mask (NET_EVENT_*)
+ */
+extern void net_backend_update(struct net_connection* con, int events);
+
 /**
  * Get the current time.
  */

src/network/common.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/network/connection.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2013, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -19,6 +19,7 @@
 
 #include "uhub.h"
 #include "network/common.h"
+#include "network/backend.h"
 
 static int is_blocked_or_interrupted()
 {
@@ -116,10 +117,27 @@ void* net_con_get_ptr(struct net_connection* con)
 	return con->ptr;
 }
 
-void net_con_destroy(struct net_connection* con)
+void net_con_update(struct net_connection* con, int events)
 {
 #ifdef SSL_SUPPORT
 	if (con->ssl)
+		net_ssl_update(con, events);
+	else
+#endif
+		net_backend_update(con, events);
+}
+
+void net_con_reinitialize(struct net_connection* con, net_connection_cb callback, const void* ptr, int events)
+{
+	con->callback = callback;
+	con->ptr = (void*) ptr;
+	net_con_update(con, events);
+}
+
+void net_con_destroy(struct net_connection* con)
+{
+#ifdef SSL_SUPPORT
+	if (con && con->ssl)
 		net_ssl_destroy(con);
 #endif
 	hub_free(con);
@@ -178,11 +196,12 @@ static int net_connect_job_check(struct net_connect_job* job)
 	int af = job->addr.ss_family;
 	enum net_connect_status status;
 
-	int ret = net_connect(net_con_get_sd(con), (struct sockaddr*) &job->addr, af == AF_INET ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in));
+	int ret = net_connect(net_con_get_sd(con), (struct sockaddr*) &job->addr, af == AF_INET ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6));
 	if (ret == 0 || (ret == -1 && net_error() == EISCONN))
 	{
 		LOG_TRACE("net_connect_job_check(): Socket connected!");
 		job->con = NULL;
+		net_con_clear_timeout(con);
 		net_connect_callback(job->handle, net_connect_status_ok, con);
 		return 1;
 	}
@@ -264,7 +283,6 @@ static int net_connect_job_process(struct net_connect_job* job)
  */
 static void net_connect_job_internal_cb(struct net_connection* con, int event, void* ptr)
 {
-	int ret;
 	struct net_connect_job* job = net_con_get_ptr(con);
 	struct net_connect_job* next_job = job->next;
 	struct net_connect_handle* handle = job->handle;
@@ -307,7 +325,7 @@ static void net_connect_job_internal_cb(struct net_connection* con, int event, v
 }
 
 
-static int net_connect_cancel(struct net_connect_handle* handle)
+static void net_connect_cancel(struct net_connect_handle* handle)
 {
 	struct net_connect_job* job;
 
@@ -363,6 +381,7 @@ static int net_connect_process(struct net_connect_handle* handle)
 		return 1; // Connected - cool!
 
 	net_connect_process_queue(handle, handle->job4);
+	return 0;
 }
 
 
@@ -421,7 +440,6 @@ static int net_con_connect_dns_callback(struct net_dns_job* job, const struct ne
 	struct net_connect_handle* handle = (struct net_connect_handle*) net_dns_job_get_ptr(job);
 	handle->dns = NULL;
 	size_t usable = 0;
-	int ret;
 
 	LOG_TRACE("net_con_connect(): async - Got DNS results");
 	if (!result)
@@ -506,3 +524,34 @@ static void net_connect_callback(struct net_connect_handle* handle, enum net_con
 	// Cleanup
 	net_connect_destroy(handle);
 }
+
+static void timeout_callback(struct timeout_evt* evt)
+{
+	net_con_callback((struct net_connection*) evt->ptr, NET_EVENT_TIMEOUT);
+}
+
+
+void net_con_set_timeout(struct net_connection* con, int seconds)
+{
+	if (!con->timeout)
+	{
+		con->timeout = hub_malloc_zero(sizeof(struct timeout_evt));
+		timeout_evt_initialize(con->timeout, timeout_callback, con);
+		timeout_queue_insert(net_backend_get_timeout_queue(), con->timeout, seconds);
+	}
+	else
+	{
+		timeout_queue_reschedule(net_backend_get_timeout_queue(), con->timeout, seconds);
+	}
+}
+
+void net_con_clear_timeout(struct net_connection* con)
+{
+	if (con->timeout && timeout_evt_is_scheduled(con->timeout))
+	{
+		timeout_queue_remove(net_backend_get_timeout_queue(), con->timeout);
+		hub_free(con->timeout);
+		con->timeout = 0;
+	}
+}
+

src/network/connection.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2013, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -28,6 +28,7 @@
 #define NET_EVENT_TIMEOUT         0x0001
 #define NET_EVENT_READ            0x0002
 #define NET_EVENT_WRITE           0x0004
+#define NET_EVENT_ERROR           0x1000
 
 struct net_connection
 {

src/network/dnsresolver.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2013, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -68,6 +68,11 @@ static void shutdown_free_results(void* ptr)
 	net_dns_result_free(result);
 }
 
+static void notify_callback(struct uhub_notify_handle* handle, void* ptr)
+{
+	net_dns_process();
+}
+
 
 // NOTE: Any job manipulating the members of this
 // struct must lock the mutex!
@@ -76,6 +81,8 @@ 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;
+
+	struct uhub_notify_handle* notify_handle; // used to signal back to the event loop that there is something to process.
 };
 
 static struct net_dns_subsystem* g_dns = NULL;
@@ -87,13 +94,11 @@ void net_dns_initialize()
 	g_dns->jobs = list_create();
 	g_dns->results = list_create();
 	uhub_mutex_init(&g_dns->mutex);
+	g_dns->notify_handle = net_notify_create(notify_callback, g_dns);
 }
 
 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);
@@ -105,22 +110,18 @@ void net_dns_destroy()
 	list_destroy(g_dns->jobs);
 	list_destroy(g_dns->results);
 	uhub_mutex_destroy(&g_dns->mutex);
+	net_notify_destroy(g_dns->notify_handle);
 	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));
+	LOG_TRACE("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))
+	LIST_FOREACH(struct net_dns_result*, result, g_dns->results,
 	{
 		struct net_dns_job* job = result->job;
 #ifdef DEBUG_LOOKUP_TIME
@@ -146,9 +147,9 @@ void net_dns_process()
 			result->job = NULL;
 			free_job(job);
 		}
-	}
+	});
 
-	list_clear(g_dns->results, &dummy_free);
+	list_clear(g_dns->results, NULL);
 	uhub_mutex_unlock(&g_dns->mutex);
 }
 
@@ -215,6 +216,7 @@ static void* job_thread_resolve_name(void* ptr)
 	uhub_mutex_lock(&g_dns->mutex);
 	list_remove(g_dns->jobs, job);
 	list_append(g_dns->results, dns_results);
+	net_notify_signal(g_dns->notify_handle, 1);
 	uhub_mutex_unlock(&g_dns->mutex);
 
 	return dns_results;
@@ -273,14 +275,14 @@ extern struct net_dns_job* net_dns_gethostbyaddr(struct ip_addr_encap* ipaddr, n
 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))
+	LIST_FOREACH(struct net_dns_job*, it, g_dns->jobs,
 	{
 		if (it == job)
 		{
 			list_remove(g_dns->jobs, it);
 			return job;
 		}
-	}
+	});
 	return NULL;
 }
 
@@ -288,14 +290,14 @@ 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_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))
+	LIST_FOREACH(struct net_dns_result*, it, g_dns->results,
 	{
 		if (it->job == job)
 		{
 			list_remove(g_dns->results, it);
 			return it;
 		}
-	}
+	});
 	return NULL;
 }
 

src/network/dnsresolver.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2013, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/network/epoll.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/network/ipcalc.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -25,10 +25,10 @@ int ip_is_valid_ipv4(const char* address)
 	int o = 0; /* octet number */
 	int n = 0; /* numbers after each dot */
 	int d = 0; /* dots */
-	
+
 	if (!address || strlen(address) > 15 || strlen(address) < 7)
 		return 0;
-	
+
 	for (; i < strlen(address); i++)
 	{
 		if (is_num(address[i]))
@@ -49,9 +49,9 @@ int ip_is_valid_ipv4(const char* address)
 			return 0;
 		}
 	}
-	
+
 	if (n == 0 || n > 3 || o > 255 || d != 3) return 0;
-	
+
 	return 1;
 }
 
@@ -107,9 +107,9 @@ int ip_convert_address(const char* text_address, int port, struct sockaddr* addr
 	struct sockaddr_in addr4;
 	size_t sockaddr_size;
 	const char* taddr = 0;
-	
+
 	int ipv6sup = net_is_ipv6_supported();
-	
+
 	if (strcmp(text_address, "any") == 0)
 	{
 		if (ipv6sup)
@@ -136,8 +136,8 @@ int ip_convert_address(const char* text_address, int port, struct sockaddr* addr
 	{
 		taddr = text_address;
 	}
-	
-	
+
+
 	if (ip_is_valid_ipv6(taddr) && ipv6sup)
 	{
 		sockaddr_size = sizeof(struct sockaddr_in6);
@@ -152,7 +152,7 @@ int ip_convert_address(const char* text_address, int port, struct sockaddr* addr
 
 		memcpy(addr, &addr6, sockaddr_size);
 		*addr_len = sockaddr_size;
-	
+
 	}
 	else if (ip_is_valid_ipv4(taddr))
 	{
@@ -185,28 +185,28 @@ int ip_mask_create_left(int af, int bits, struct ip_addr_encap* result)
 
 	memset(result, 0, sizeof(struct ip_addr_encap));
 	result->af = af;
-	
+
 	if (bits < 0) bits = 0;
-	
+
 	if (af == AF_INET)
 	{
 		if (bits > 32) bits = 32;
 		mask = (0xffffffff << (32 - bits));
 		if (bits == 0) mask = 0;
-		
+
 		result->internal_ip_data.in.s_addr = (((uint8_t*) &mask)[0] << 24) | (((uint8_t*) &mask)[1] << 16) | (((uint8_t*) &mask)[2] << 8) | (((uint8_t*) &mask)[3] << 0);
 	}
 	else if (af == AF_INET6)
 	{
 		if (bits > 128) bits = 128;
-		
+
 		fill = (128-bits) / 8;
 		remain_bits = (128-bits) % 8;
 		mask = (0xff << (8 - remain_bits));
 
 		for (n = 0; n < fill; n++)
 			((uint8_t*) &result->internal_ip_data.in6)[n] = (uint8_t) 0xff;
-		
+
 		if (fill < 16)
 			((uint8_t*) &result->internal_ip_data.in6)[fill] = (uint8_t) mask;
 	}
@@ -233,32 +233,32 @@ int ip_mask_create_right(int af, int bits, struct ip_addr_encap* result)
 
 	memset(result, 0, sizeof(struct ip_addr_encap));
 	result->af = af;
-	
+
 	if (bits < 0) bits = 0;
-	
+
 	if (af == AF_INET)
 	{
 		if (bits > 32) bits = 32;
 		mask = (0xffffffff >> (32-bits));
 		if (bits == 0) mask = 0;
 		result->internal_ip_data.in.s_addr = (((uint8_t*) &mask)[0] << 24) | (((uint8_t*) &mask)[1] << 16) | (((uint8_t*) &mask)[2] << 8) | (((uint8_t*) &mask)[3] << 0);
-	
+
 	}
 	else if (af == AF_INET6)
 	{
 		if (bits > 128) bits = 128;
-		
+
 		fill = (128-bits) / 8;
 		remain_bits = (128-bits) % 8;
 		mask8 = (0xff >> (8 - remain_bits));
 		start = 16-fill;
-		
+
 		for (n = 0; n < start; n++)
 			((uint8_t*) &result->internal_ip_data.in6)[n] = (uint8_t) 0x00;
-		
+
 		for (n = start; n < 16; n++)
 			((uint8_t*) &result->internal_ip_data.in6)[n] = (uint8_t) 0xff;
-		
+
 		if (start > 0)
 			((uint8_t*) &result->internal_ip_data.in6)[start-1] = (uint8_t) mask8;
 	}
@@ -266,13 +266,13 @@ int ip_mask_create_right(int af, int bits, struct ip_addr_encap* result)
 	{
 		return -1;
 	}
-	
+
 #ifdef IP_CALC_DEBUG
 	char* r_str = hub_strdup(ip_convert_to_string(result));
 	LOG_DUMP("Created right mask: %s", r_str);
 	hub_free(r_str);
 #endif
-	
+
 	return 0;
 }
 
@@ -281,7 +281,7 @@ void ip_mask_apply_AND(struct ip_addr_encap* addr, struct ip_addr_encap* mask, s
 {
 	memset(result, 0, sizeof(struct ip_addr_encap));
 	result->af = addr->af;
-	
+
 	if (addr->af == AF_INET)
 	{
 		result->internal_ip_data.in.s_addr = addr->internal_ip_data.in.s_addr & mask->internal_ip_data.in.s_addr;
@@ -294,19 +294,19 @@ void ip_mask_apply_AND(struct ip_addr_encap* addr, struct ip_addr_encap* mask, s
 		for (n = 0; n < 4; n++)
 		{
 			offset = n * 4;
-	
+
 			A =	(((uint8_t*) &addr->internal_ip_data.in6)[offset+0] << 24) |
 				(((uint8_t*) &addr->internal_ip_data.in6)[offset+1] << 16) |
 				(((uint8_t*) &addr->internal_ip_data.in6)[offset+2] <<  8) |
 				(((uint8_t*) &addr->internal_ip_data.in6)[offset+3] <<  0);
-				
+
 			B =	(((uint8_t*) &mask->internal_ip_data.in6)[offset+0] << 24) |
 				(((uint8_t*) &mask->internal_ip_data.in6)[offset+1] << 16) |
 				(((uint8_t*) &mask->internal_ip_data.in6)[offset+2] <<  8) |
 				(((uint8_t*) &mask->internal_ip_data.in6)[offset+3] <<  0);
-			
+
 			C = A & B;
-			
+
 			D =	(((uint8_t*) &C)[0] << 24) |
 				(((uint8_t*) &C)[1] << 16) |
 				(((uint8_t*) &C)[2] <<  8) |
@@ -321,7 +321,7 @@ void ip_mask_apply_OR(struct ip_addr_encap* addr, struct ip_addr_encap* mask, st
 {
 	memset(result, 0, sizeof(struct ip_addr_encap));
 	result->af = addr->af;
-	
+
 	if (addr->af == AF_INET)
 	{
 		result->internal_ip_data.in.s_addr = addr->internal_ip_data.in.s_addr | mask->internal_ip_data.in.s_addr;
@@ -334,19 +334,19 @@ void ip_mask_apply_OR(struct ip_addr_encap* addr, struct ip_addr_encap* mask, st
 		for (n = 0; n < 4; n++)
 		{
 			offset = n * 4;
-	
+
 			A =	(((uint8_t*) &addr->internal_ip_data.in6)[offset+0] << 24) |
 				(((uint8_t*) &addr->internal_ip_data.in6)[offset+1] << 16) |
 				(((uint8_t*) &addr->internal_ip_data.in6)[offset+2] <<  8) |
 				(((uint8_t*) &addr->internal_ip_data.in6)[offset+3] <<  0);
-				
+
 			B =	(((uint8_t*) &mask->internal_ip_data.in6)[offset+0] << 24) |
 				(((uint8_t*) &mask->internal_ip_data.in6)[offset+1] << 16) |
 				(((uint8_t*) &mask->internal_ip_data.in6)[offset+2] <<  8) |
 				(((uint8_t*) &mask->internal_ip_data.in6)[offset+3] <<  0);
-			
+
 			C = A | B;
-			
+
 			D =	(((uint8_t*) &C)[0] << 24) |
 				(((uint8_t*) &C)[1] << 16) |
 				(((uint8_t*) &C)[2] <<  8) |
@@ -368,7 +368,7 @@ int ip_compare(struct ip_addr_encap* a, struct ip_addr_encap* b)
 			(((uint8_t*) &a->internal_ip_data.in.s_addr)[1] << 16) |
 			(((uint8_t*) &a->internal_ip_data.in.s_addr)[2] <<  8) |
 			(((uint8_t*) &a->internal_ip_data.in.s_addr)[3] <<  0);
-			
+
 		B =	(((uint8_t*) &b->internal_ip_data.in.s_addr)[0] << 24) |
 			(((uint8_t*) &b->internal_ip_data.in.s_addr)[1] << 16) |
 			(((uint8_t*) &b->internal_ip_data.in.s_addr)[2] <<  8) |
@@ -386,19 +386,19 @@ int ip_compare(struct ip_addr_encap* a, struct ip_addr_encap* b)
 				(((uint8_t*) &a->internal_ip_data.in6)[offset+1] << 16) |
 				(((uint8_t*) &a->internal_ip_data.in6)[offset+2] <<  8) |
 				(((uint8_t*) &a->internal_ip_data.in6)[offset+3] <<  0);
-				
+
 			B =	(((uint8_t*) &b->internal_ip_data.in6)[offset+0] << 24) |
 				(((uint8_t*) &b->internal_ip_data.in6)[offset+1] << 16) |
 				(((uint8_t*) &b->internal_ip_data.in6)[offset+2] <<  8) |
 				(((uint8_t*) &b->internal_ip_data.in6)[offset+3] <<  0);
-						 
+
 			if (A == B) continue;
-			
+
 			return A - B;
 		}
 		return 0;
 	}
-	
+
 #ifdef IP_CALC_DEBUG
 	char* a_str = hub_strdup(ip_convert_to_string(a));
 	char* b_str = hub_strdup(ip_convert_to_string(b));
@@ -406,7 +406,7 @@ int ip_compare(struct ip_addr_encap* a, struct ip_addr_encap* b)
 	hub_free(a_str);
 	hub_free(b_str);
 #endif
-	
+
 	return ret;
 }
 

src/network/ipcalc.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -18,7 +18,7 @@
  */
 
 /*
- * This file is used for fiddling with IP-addresses, 
+ * This file is used for fiddling with IP-addresses,
  * primarily used for IP-banning in uhub.
  */
 

src/network/kqueue.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/network/network.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -449,7 +449,7 @@ int net_is_ipv6_supported()
 				is_ipv6_supported = 0;
 				return 0;
 			}
-			
+
 			net_error_out(ret, "net_is_ipv6_supported");
 		}
 		else
@@ -508,7 +508,7 @@ const char* net_address_to_string(int af, const void* src, char* dst, socklen_t
 	size_t size;
 	LPSOCKADDR addr;
 	DWORD len = cnt;
-	
+
 	switch (af)
 	{
 		case AF_INET:
@@ -531,7 +531,7 @@ const char* net_address_to_string(int af, const void* src, char* dst, socklen_t
 		default:
 			return NULL;
 	}
-	
+
 	if (WSAAddressToStringA(addr, size, NULL, dst, &len) == 0)
 	{
 		return dst;
@@ -602,15 +602,15 @@ const char* net_get_peer_address(int fd)
 	struct sockaddr_in*  name4;
 	struct sockaddr*     name;
 	socklen_t namelen;
-	
+
 	memset(address, 0, INET6_ADDRSTRLEN);
 	namelen = sizeof(struct sockaddr_storage);
 	memset(&storage, 0, namelen);
-	
+
 	name6 = (struct sockaddr_in6*) &storage;
 	name4 = (struct sockaddr_in*)  &storage;
 	name  = (struct sockaddr*)     &storage;
-	
+
 	if (getpeername(fd, (struct sockaddr*) name, &namelen) != -1)
 	{
 		int af = storage.ss_family;

src/network/network.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/network/notify.c

@@ -0,0 +1,102 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2014, 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"
+
+struct uhub_notify_handle
+{
+	net_notify_callback callback;
+	void* ptr;
+#ifndef WIN32
+	int pipe_fd[2];
+	struct net_connection* con;
+#endif
+};
+
+/*
+ * This contains a mechanism to wake up the main thread
+ * in a thread safe manner while it would be blocking
+ * in select() or something equivalent typically invoked from
+ * net_backend_process().
+ *
+ * The main usage is for the DNS resolver to notify the
+ * main thread that there are DNS results to be
+ * processed.
+ */
+
+/**
+ * Create a notification handle.
+ */
+#ifndef WIN32
+static void notify_callback(struct net_connection* con, int event, void* ptr)
+{
+	LOG_TRACE("notify_callback()");
+	struct uhub_notify_handle* handle = (struct uhub_notify_handle*) ptr;
+	char buf;
+	int ret = read(handle->pipe_fd[0], &buf, 1);
+	if (ret == 1)
+	{
+		if (handle->callback)
+			handle->callback(handle, handle->ptr);
+	}
+}
+#endif
+
+struct uhub_notify_handle* net_notify_create(net_notify_callback cb, void* ptr)
+{
+	LOG_TRACE("net_notify_create()");
+	struct uhub_notify_handle* handle = (struct uhub_notify_handle*) hub_malloc(sizeof(struct uhub_notify_handle));
+	handle->callback = cb;
+	handle->ptr = ptr;
+#ifndef WIN32
+	int ret = pipe(handle->pipe_fd);
+	if (ret == -1)
+	{
+		LOG_ERROR("Unable to setup notification pipes.");
+		hub_free(handle);
+		return 0;
+	}
+
+	handle->con = net_con_create();
+	net_con_initialize(handle->con, handle->pipe_fd[0], notify_callback, handle, NET_EVENT_READ);
+#endif
+	return handle;
+}
+
+
+void net_notify_destroy(struct uhub_notify_handle* handle)
+{
+	LOG_TRACE("net_notify_destroy()");
+#ifndef WIN32
+	net_con_destroy(handle->con);
+	close(handle->pipe_fd[0]);
+	close(handle->pipe_fd[1]);
+	handle->pipe_fd[0] = -1;
+	handle->pipe_fd[0] = -1;
+#endif
+	hub_free(handle);
+}
+
+void net_notify_signal(struct uhub_notify_handle* handle, char data)
+{
+	LOG_TRACE("net_notify_signal()");
+#ifndef WIN32
+	write(handle->pipe_fd[1], &data, 1);
+#endif
+}

src/network/notify.h

@@ -0,0 +1,56 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2014, 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_NOTIFY_API_H
+#define HAVE_UHUB_NETWORK_NOTIFY_API_H
+
+struct uhub_notify_handle;
+
+typedef void (*net_notify_callback)(struct uhub_notify_handle* handle, void* ptr);
+
+/*
+ * This contains a mechanism to wake up the main thread
+ * in a thread safe manner while it would be blocking
+ * in select() or something equivalent typically invoked from
+ * net_backend_process().
+ *
+ * The main usage is for the DNS resolver to notify the
+ * main thread that there are DNS results to be
+ * processed.
+ */
+
+/**
+ * Create a notification handle.
+ */
+struct uhub_notify_handle* net_notify_create(net_notify_callback cb, void* ptr);
+
+/**
+ * Destroy a notification handle.
+ */
+void net_notify_destroy(struct uhub_notify_handle*);
+
+/**
+ * Signal the notification handle, this will surely
+ * interrupt the net_backend_process(), and force it to
+ * process messages.
+ */
+void net_notify_signal(struct uhub_notify_handle*, char data);
+
+
+#endif /* HAVE_UHUB_NETWORK_NOTIFY_API_H */

src/network/openssl.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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,6 +20,7 @@
 #include "uhub.h"
 #include "network/common.h"
 #include "network/tls.h"
+#include "network/backend.h"
 
 #ifdef SSL_SUPPORT
 #ifdef SSL_USE_OPENSSL
@@ -32,6 +33,9 @@ struct net_ssl_openssl
 	SSL* ssl;
 	BIO* bio;
 	enum ssl_state state;
+	int events;
+	int ssl_read_events;
+	int ssl_write_events;
 	uint32_t flags;
 	size_t bytes_rx;
 	size_t bytes_tx;
@@ -39,8 +43,7 @@ struct net_ssl_openssl
 
 struct net_context_openssl
 {
-	SSL_METHOD* ssl_method;
-	SSL_CTX* ssl_ctx;
+	SSL_CTX* ssl;
 };
 
 static struct net_ssl_openssl* get_handle(struct net_connection* con)
@@ -49,6 +52,29 @@ static struct net_ssl_openssl* get_handle(struct net_connection* con)
 	return (struct net_ssl_openssl*) con->ssl;
 }
 
+#ifdef DEBUG
+static const char* get_state_str(enum ssl_state state)
+{
+	switch (state)
+	{
+		case tls_st_none:			return "tls_st_none";
+		case tls_st_error:			return "tls_st_error";
+		case tls_st_accepting:		return "tls_st_accepting";
+		case tls_st_connecting:		return "tls_st_connecting";
+		case tls_st_connected:		return "tls_st_connected";
+		case tls_st_disconnecting:	return "tls_st_disconnecting";
+	}
+	uhub_assert(!"This should not happen - invalid state!");
+	return "(UNKNOWN STATE)";
+}
+#endif
+
+static void net_ssl_set_state(struct net_ssl_openssl* handle, enum ssl_state new_state)
+{
+	LOG_DEBUG("net_ssl_set_state(): prev_state=%s, new_state=%s", get_state_str(handle->state), get_state_str(new_state));
+	handle->state = new_state;
+}
+
 const char* net_ssl_get_provider()
 {
 	return OPENSSL_VERSION_TEXT;
@@ -65,71 +91,126 @@ int net_ssl_library_init()
 int net_ssl_library_shutdown()
 {
 	ERR_clear_error();
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
 	ERR_remove_state(0);
+#endif
 
 	ENGINE_cleanup();
 	CONF_modules_unload(1);
 
-        ERR_free_strings();
+	ERR_free_strings();
 	EVP_cleanup();
-        CRYPTO_cleanup_all_ex_data();
-	
+	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)
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+	unsigned long num_read = handle->bio->num_read;
+	unsigned long num_write = handle->bio->num_write;
+#else
+	unsigned long num_read = BIO_number_read(handle->bio);
+	unsigned long num_write = BIO_number_written(handle->bio);
+#endif
+
+	if (num_read > handle->bytes_rx)
 	{
-		net_stats_add_rx(handle->bio->num_read - handle->bytes_rx);
-		handle->bytes_rx = handle->bio->num_read;
+		net_stats_add_rx(num_read - handle->bytes_rx);
+		handle->bytes_rx = num_read;
 	}
 
-	if (handle->bio->num_write > handle->bytes_tx)
+	if (num_write > handle->bytes_tx)
 	{
-		net_stats_add_tx(handle->bio->num_write - handle->bytes_tx);
-		handle->bytes_tx = handle->bio->num_write;
+		net_stats_add_tx(num_write - handle->bytes_tx);
+		handle->bytes_tx = num_write;
 	}
 }
 
+static const SSL_METHOD* get_ssl_method(const char* tls_version)
+{
+	if (!tls_version || !*tls_version)
+	{
+		LOG_ERROR("tls_version is not set.");
+		return 0;
+	}
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+	if (!strcmp(tls_version, "1.0"))
+	  return TLSv1_method();
+	if (!strcmp(tls_version, "1.1"))
+	  return TLSv1_1_method();
+	if (!strcmp(tls_version, "1.2"))
+	  return TLSv1_2_method();
+
+	LOG_ERROR("Unable to recognize tls_version.");
+	return 0;
+#else
+	LOG_WARN("tls_version is obsolete, and should not be used.");
+	return TLS_method();
+#endif
+}
+
 /**
  * Create a new SSL context.
  */
-struct ssl_context_handle* net_ssl_context_create()
+struct ssl_context_handle* net_ssl_context_create(const char* tls_version, const char* tls_ciphersuite)
 {
-
 	struct net_context_openssl* ctx = (struct net_context_openssl*) hub_malloc_zero(sizeof(struct net_context_openssl));
-	ctx->ssl_method = (SSL_METHOD*) SSLv23_method(); /* TLSv1_method() */
-	ctx->ssl_ctx = SSL_CTX_new(ctx->ssl_method);
+	const SSL_METHOD* ssl_method = get_ssl_method(tls_version);
+
+	if (!ssl_method)
+	{
+		hub_free(ctx);
+		return 0;
+	}
+
+	ctx->ssl = SSL_CTX_new(ssl_method);
 
 	/* Disable SSLv2 */
-	SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_SSLv2);
+	SSL_CTX_set_options(ctx->ssl, SSL_OP_NO_SSLv2);
+
+// #ifdef SSL_OP_NO_SSLv3
+	/* Disable SSLv3 */
+	SSL_CTX_set_options(ctx->ssl, SSL_OP_NO_SSLv3);
+// #endif
+
+	// FIXME: Why did we need this again?
+	SSL_CTX_set_quiet_shutdown(ctx->ssl, 1);
 
 #ifdef SSL_OP_NO_COMPRESSION
-	/* Disable compression? */
+	/* Disable compression */
 	LOG_TRACE("Disabling SSL compression."); /* "CRIME" attack */
-	SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_COMPRESSION);
+	SSL_CTX_set_options(ctx->ssl, SSL_OP_NO_COMPRESSION);
 #endif
 
-	SSL_CTX_set_quiet_shutdown(ctx->ssl_ctx, 1);
+	/* Set preferred cipher suite */
+	if (SSL_CTX_set_cipher_list(ctx->ssl, tls_ciphersuite) != 1)
+	{
+		LOG_ERROR("Unable to set cipher suite.");
+		SSL_CTX_free(ctx->ssl);
+		hub_free(ctx);
+		return 0;
+	}
 
 	return (struct ssl_context_handle*) ctx;
 }
 
-extern void net_ssl_context_destroy(struct ssl_context_handle* ctx_)
+void net_ssl_context_destroy(struct ssl_context_handle* ctx_)
 {
 	struct net_context_openssl* ctx = (struct net_context_openssl*) ctx_;
-	SSL_CTX_free(ctx->ssl_ctx);
+	SSL_CTX_free(ctx->ssl);
 	hub_free(ctx);
 }
 
 int ssl_load_certificate(struct ssl_context_handle* ctx_, const char* pem_file)
 {
 	struct net_context_openssl* ctx = (struct net_context_openssl*) ctx_;
-	if (SSL_CTX_use_certificate_file(ctx->ssl_ctx, pem_file, SSL_FILETYPE_PEM) < 0)
+	if (SSL_CTX_use_certificate_chain_file(ctx->ssl, pem_file) < 0)
 	{
-		LOG_ERROR("SSL_CTX_use_certificate_file: %s", ERR_error_string(ERR_get_error(), NULL));
+		LOG_ERROR("SSL_CTX_use_certificate_chain_file: %s", ERR_error_string(ERR_get_error(), NULL));
 		return 0;
 	}
 
@@ -139,7 +220,7 @@ int ssl_load_certificate(struct ssl_context_handle* ctx_, const char* pem_file)
 int ssl_load_private_key(struct ssl_context_handle* ctx_, const char* pem_file)
 {
 	struct net_context_openssl* ctx = (struct net_context_openssl*) ctx_;
-	if (SSL_CTX_use_PrivateKey_file(ctx->ssl_ctx, pem_file, SSL_FILETYPE_PEM) < 0)
+	if (SSL_CTX_use_PrivateKey_file(ctx->ssl, pem_file, SSL_FILETYPE_PEM) < 0)
 	{
 		LOG_ERROR("SSL_CTX_use_PrivateKey_file: %s", ERR_error_string(ERR_get_error(), NULL));
 		return 0;
@@ -150,7 +231,7 @@ int ssl_load_private_key(struct ssl_context_handle* ctx_, const char* pem_file)
 int ssl_check_private_key(struct ssl_context_handle* ctx_)
 {
 	struct net_context_openssl* ctx = (struct net_context_openssl*) ctx_;
-	if (SSL_CTX_check_private_key(ctx->ssl_ctx) != 1)
+	if (SSL_CTX_check_private_key(ctx->ssl) != 1)
 	{
 		LOG_FATAL("SSL_CTX_check_private_key: Private key does not match the certificate public key: %s", ERR_error_string(ERR_get_error(), NULL));
 		return 0;
@@ -158,7 +239,7 @@ int ssl_check_private_key(struct ssl_context_handle* ctx_)
 	return 1;
 }
 
-static int handle_openssl_error(struct net_connection* con, int ret, enum ssl_state forced_rwstate)
+static int handle_openssl_error(struct net_connection* con, int ret, int read)
 {
 	struct net_ssl_openssl* handle = get_handle(con);
 	int err = SSL_get_error(handle->ssl, ret);
@@ -169,33 +250,43 @@ static int handle_openssl_error(struct net_connection* con, int ret, enum ssl_st
 			return -1;
 
 		case SSL_ERROR_WANT_READ:
-			handle->state = forced_rwstate;
-			net_con_update(con, NET_EVENT_READ);
+			if (read)
+				handle->ssl_read_events = NET_EVENT_READ;
+			else
+				handle->ssl_write_events = NET_EVENT_READ;
 			return 0;
 
 		case SSL_ERROR_WANT_WRITE:
-			handle->state = forced_rwstate;
-			net_con_update(con, NET_EVENT_WRITE);
+			if (read)
+				handle->ssl_read_events = NET_EVENT_WRITE;
+			else
+				handle->ssl_write_events = NET_EVENT_WRITE;
 			return 0;
 
+		case SSL_ERROR_SSL:
+			net_ssl_set_state(handle, tls_st_error);
+			return -2;
+
 		case SSL_ERROR_SYSCALL:
-			handle->state = tls_st_error;
+			net_ssl_set_state(handle, tls_st_error);
 			return -2;
 	}
+
+	return -2;
 }
 
 ssize_t net_con_ssl_accept(struct net_connection* con)
 {
 	struct net_ssl_openssl* handle = get_handle(con);
-	handle->state = tls_st_accepting;
 	ssize_t ret;
+	net_ssl_set_state(handle, tls_st_accepting);
 
 	ret = SSL_accept(handle->ssl);
 	LOG_PROTO("SSL_accept() ret=%d", ret);
 	if (ret > 0)
 	{
 		net_con_update(con, NET_EVENT_READ);
-		handle->state = tls_st_connected;
+		net_ssl_set_state(handle, tls_st_connected);
 		return ret;
 	}
 	return handle_openssl_error(con, ret, tls_st_accepting);
@@ -205,30 +296,34 @@ ssize_t net_con_ssl_connect(struct net_connection* con)
 {
 	struct net_ssl_openssl* handle = get_handle(con);
 	ssize_t ret;
-	handle->state = tls_st_connecting;
+	net_ssl_set_state(handle, tls_st_connecting);
 
 	ret = SSL_connect(handle->ssl);
 	LOG_PROTO("SSL_connect() ret=%d", ret);
 
 	if (ret > 0)
 	{
-		handle->state = tls_st_connected;
 		net_con_update(con, NET_EVENT_READ);
+		net_ssl_set_state(handle, tls_st_connected);
 		return ret;
 	}
-	return handle_openssl_error(con, ret, tls_st_connecting);
+	
+	ret = handle_openssl_error(con, ret, tls_st_connecting);
+	LOG_ERROR("net_con_ssl_connect: ret=%d", ret);
+	return ret;
 }
 
 ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode ssl_mode, struct ssl_context_handle* ssl_ctx)
 {
 	uhub_assert(con);
+	uhub_assert(ssl_ctx);
 
 	struct net_context_openssl* ctx = (struct net_context_openssl*) ssl_ctx;
 	struct net_ssl_openssl* handle = (struct net_ssl_openssl*) hub_malloc_zero(sizeof(struct net_ssl_openssl));
 
 	if (ssl_mode == net_con_ssl_mode_server)
 	{
-		handle->ssl = SSL_new(ctx->ssl_ctx);
+		handle->ssl = SSL_new(ctx->ssl);
 		if (!handle->ssl)
 		{
 			LOG_ERROR("Unable to create new SSL stream\n");
@@ -241,31 +336,37 @@ ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode
 	}
 	else
 	{
-		handle->ssl = SSL_new(SSL_CTX_new(TLSv1_method()));
+		handle->ssl = SSL_new(ctx->ssl);
 		SSL_set_fd(handle->ssl, con->sd);
 		handle->bio = SSL_get_rbio(handle->ssl);
 		con->ssl = (struct ssl_handle*) handle;
 		return net_con_ssl_connect(con);
 	}
-
 }
 
 ssize_t net_ssl_send(struct net_connection* con, const void* buf, size_t len)
 {
 	struct net_ssl_openssl* handle = get_handle(con);
 
-	uhub_assert(handle->state == tls_st_connected || handle->state == tls_st_need_write);
+	LOG_TRACE("net_ssl_send(), state=%d", (int) handle->state);
+
+	if (handle->state == tls_st_error)
+		return -2;
+
+	uhub_assert(handle->state == tls_st_connected);
+	
 
 	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)
-	{
-		handle->state = tls_st_connected;
-		return ret;
-	}
-	return handle_openssl_error(con, ret, tls_st_need_write);
+		handle->ssl_write_events = 0;
+	else
+		ret = handle_openssl_error(con, ret, 0);
+
+	net_ssl_update(con, handle->events);  // Update backend only
+	return ret;
 }
 
 ssize_t net_ssl_recv(struct net_connection* con, void* buf, size_t len)
@@ -276,7 +377,10 @@ ssize_t net_ssl_recv(struct net_connection* con, void* buf, size_t len)
 	if (handle->state == tls_st_error)
 		return -2;
 
-	uhub_assert(handle->state == tls_st_connected || handle->state == tls_st_need_read);
+	if (handle->state == tls_st_accepting || handle->state == tls_st_connecting)
+		return -1;
+
+	uhub_assert(handle->state == tls_st_connected);
 
 	ERR_clear_error();
 
@@ -284,29 +388,43 @@ ssize_t net_ssl_recv(struct net_connection* con, void* buf, size_t 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)
-	{
-		handle->state = tls_st_connected;
-		return ret;
-	}
-	return handle_openssl_error(con, ret, tls_st_need_read);
+		handle->ssl_read_events = 0;
+	else
+		ret = handle_openssl_error(con, ret, 1);
+
+	net_ssl_update(con, handle->events);  // Update backend only
+	return ret;
+}
+
+void net_ssl_update(struct net_connection* con, int events)
+{
+	struct net_ssl_openssl* handle = get_handle(con);
+	handle->events = events;
+	net_backend_update(con, handle->events | handle->ssl_read_events | handle->ssl_write_events);
 }
 
 void net_ssl_shutdown(struct net_connection* con)
 {
 	struct net_ssl_openssl* handle = get_handle(con);
-	SSL_shutdown(handle->ssl);
-	SSL_clear(handle->ssl);
+	if (handle)
+	{
+		SSL_shutdown(handle->ssl);
+		SSL_clear(handle->ssl);
+	}
 }
 
 void net_ssl_destroy(struct net_connection* con)
 {
 	struct net_ssl_openssl* handle = get_handle(con);
+	LOG_TRACE("net_ssl_destroy: %p", con);
 	SSL_free(handle->ssl);
+	hub_free(handle);
 }
 
 void net_ssl_callback(struct net_connection* con, int events)
 {
 	struct net_ssl_openssl* handle = get_handle(con);
+	int ret;
 
 	switch (handle->state)
 	{
@@ -315,7 +433,7 @@ void net_ssl_callback(struct net_connection* con, int events)
 			break;
 
 		case tls_st_error:
-			con->callback(con, NET_EVENT_READ, con->ptr);
+			con->callback(con, NET_EVENT_ERROR, con->ptr);
 			break;
 
 		case tls_st_accepting:
@@ -324,19 +442,27 @@ void net_ssl_callback(struct net_connection* con, int events)
 			break;
 
 		case tls_st_connecting:
-			if (net_con_ssl_connect(con) != 0)
+			ret = net_con_ssl_connect(con);
+			if (ret == 0)
+				return;
+
+			if (ret > 0)
+			{
+				LOG_DEBUG("%p SSL connected!", con);
 				con->callback(con, NET_EVENT_READ, con->ptr);
-			break;
-
-		case tls_st_need_read:
-			con->callback(con, NET_EVENT_READ, con->ptr);
-			break;
-
-		case tls_st_need_write:
-			con->callback(con, NET_EVENT_WRITE, con->ptr);
+			}
+			else
+			{
+				LOG_DEBUG("%p SSL handshake failed!", con);
+				con->callback(con, NET_EVENT_ERROR, con->ptr);
+			}
 			break;
 
 		case tls_st_connected:
+			if (handle->ssl_read_events & events)
+				events |= NET_EVENT_READ;
+			if (handle->ssl_write_events & events)
+				events |= NET_EVENT_WRITE;
 			con->callback(con, events, con->ptr);
 			break;
 
@@ -345,6 +471,18 @@ void net_ssl_callback(struct net_connection* con, int events)
 	}
 }
 
+const char* net_ssl_get_tls_version(struct net_connection* con)
+{
+	struct net_ssl_openssl* handle = get_handle(con);
+	return SSL_get_version(handle->ssl);
+}
+
+const char* net_ssl_get_tls_cipher(struct net_connection* con)
+{
+	struct net_ssl_openssl* handle = get_handle(con);
+	const SSL_CIPHER *cipher = SSL_get_current_cipher(handle->ssl);
+	return SSL_CIPHER_get_name(cipher);
+}
 
 #endif /* SSL_USE_OPENSSL */
 #endif /* SSL_SUPPORT */

src/network/select.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/network/timeout.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -42,6 +42,7 @@ void timeout_queue_initialize(struct timeout_queue* t, time_t now, size_t max)
 {
 	t->last = now;
 	t->max = max;
+	memset(&t->lock, 0, sizeof(t->lock));
 	t->events = hub_malloc_zero(max * sizeof(struct timeout_evt*));
 }
 
@@ -52,12 +53,56 @@ void timeout_queue_shutdown(struct timeout_queue* t)
 	t->max = 0;
 }
 
+static int timeout_queue_locked(struct timeout_queue* t)
+{
+	return t->lock.ptr != NULL;
+}
+
+static void timeout_queue_lock(struct timeout_queue* t)
+{
+	t->lock.ptr = t;
+}
+
+// unlock and flush the locked events to the main timeout queue.
+static void timeout_queue_unlock(struct timeout_queue* t)
+{
+	struct timeout_evt* evt, *tmp, *first;
+	size_t pos;
+	t->lock.ptr = NULL;
+
+	evt = t->lock.next;
+	while (evt)
+	{
+		tmp = evt->next;
+		pos = evt->timestamp % t->max;
+		first = t->events[pos];
+		if (first)
+		{
+			first->prev->next = evt;
+			evt->prev = first->prev;
+			first->prev = evt;
+		}
+		else
+		{
+			t->events[pos] = evt;
+			evt->prev = evt;
+		}
+		evt->next = 0;
+		evt = tmp;
+	}
+
+	t->lock.next = 0;
+	t->lock.prev = 0;
+}
+
+
 size_t timeout_queue_process(struct timeout_queue* t, time_t now)
 {
 	size_t pos = (size_t) t->last;
 	size_t events = 0;
 	struct timeout_evt* evt = 0;
 	t->last = now;
+	timeout_queue_lock(t);
 	for (; pos <= now; pos++)
 	{
 		while ((evt = t->events[pos % t->max]))
@@ -67,6 +112,7 @@ size_t timeout_queue_process(struct timeout_queue* t, time_t now)
 			events++;
 		}
 	}
+	timeout_queue_unlock(t);
 	return events;
 }
 
@@ -82,6 +128,61 @@ size_t timeout_queue_get_next_timeout(struct timeout_queue* t, time_t now)
 	return seconds;
 }
 
+static void timeout_queue_insert_locked(struct timeout_queue* t, struct timeout_evt* evt)
+{
+	/* All events point back to the sentinel.
+	 * this means the event is considered schedule (see timeout_evt_is_scheduled),
+	 * and it is easy to tell if the event is in the wait queue or not.
+	 */
+	evt->prev = &t->lock;
+	evt->next = NULL;
+
+	// The sentinel next points to the first event in the locked queue
+	// The sentinel prev points to the last evetnt in the locked queue.
+	// NOTE: if prev is != NULL then next also must be != NULL.
+	if (t->lock.prev)
+	{
+		t->lock.prev->next = evt;
+		t->lock.prev = evt;
+	}
+	else
+	{
+		t->lock.next = evt;
+		t->lock.prev = evt;
+	}
+	return;
+}
+
+static void timeout_queue_remove_locked(struct timeout_queue* t, struct timeout_evt* evt)
+{
+	uhub_assert(evt->prev == &t->lock);
+	if (t->lock.next == evt)
+	{
+		t->lock.next = evt->next;
+		if (t->lock.prev == evt)
+			t->lock.prev = evt->next;
+	}
+	else
+	{
+		struct timeout_evt *prev, *it;
+		prev = 0;
+		it = t->lock.next;
+		while (it)
+		{
+			prev = it;
+			it = it->next;
+			if (it == evt)
+			{
+				prev->next = it->next;
+				if (!prev->next)
+					t->lock.prev = prev;
+			}
+		}
+	}
+	timeout_evt_reset(evt);
+}
+
+
 
 void timeout_queue_insert(struct timeout_queue* t, struct timeout_evt* evt, size_t seconds)
 {
@@ -89,9 +190,15 @@ void timeout_queue_insert(struct timeout_queue* t, struct timeout_evt* evt, size
 	size_t pos = ((t->last + seconds) % t->max);
 	evt->timestamp = t->last + seconds;
 	evt->next = 0;
-	
+
+	if (timeout_queue_locked(t))
+	{
+		timeout_queue_insert_locked(t, evt);
+		return;
+	}
+
 	first = t->events[pos];
-	
+
 	if (first)
 	{
 		uhub_assert(first->timestamp == evt->timestamp);
@@ -112,6 +219,13 @@ void timeout_queue_remove(struct timeout_queue* t, struct timeout_evt* evt)
 	size_t pos = (evt->timestamp % t->max);
 	struct timeout_evt* first = t->events[pos];
 
+	// Removing a locked event
+	if (evt->prev == &t->lock)
+	{
+		timeout_queue_remove_locked(t, evt);
+		return;
+	}
+
 	if (!first || !evt->prev)
 		return;
 

src/network/timeout.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -43,6 +43,7 @@ struct timeout_queue
 {
 	time_t last;
 	size_t max;
+	struct timeout_evt lock;
 	struct timeout_evt** events;
 };
 

src/network/timer.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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,31 +20,4 @@
 #include "uhub.h"
 #include "network/connection.h"
 
-static void timeout_callback(struct timeout_evt* evt)
-{
-	net_con_callback((struct net_connection*) evt->ptr, NET_EVENT_TIMEOUT);
-}
 
-void net_con_set_timeout(struct net_connection* con, int seconds)
-{
-	if (!con->timeout)
-	{
-		con->timeout = hub_malloc_zero(sizeof(struct timeout_evt));
-		timeout_evt_initialize(con->timeout, timeout_callback, con);
-		timeout_queue_insert(net_backend_get_timeout_queue(), con->timeout, seconds);
-	}
-	else
-	{
-		timeout_queue_reschedule(net_backend_get_timeout_queue(), con->timeout, seconds);
-	}
-}
-
-void net_con_clear_timeout(struct net_connection* con)
-{
-	if (con->timeout && timeout_evt_is_scheduled(con->timeout))
-	{
-		timeout_queue_remove(net_backend_get_timeout_queue(), con->timeout);
-		hub_free(con->timeout);
-		con->timeout = 0;
-	}
-}

src/network/tls.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -32,8 +32,6 @@ enum ssl_state
 	tls_st_accepting,
 	tls_st_connecting,
 	tls_st_connected,
-	tls_st_need_read,  /* special case of connected */
-	tls_st_need_write, /* special case of connected */
 	tls_st_disconnecting,
 };
 
@@ -58,8 +56,9 @@ extern int net_ssl_library_shutdown();
 
 /**
  * Create a new SSL context.
+ * Specify a TLS version as a string: "1.2" for TLS 1.2.
  */
-extern struct ssl_context_handle* net_ssl_context_create();
+extern struct ssl_context_handle* net_ssl_context_create(const char* tls_version, const char* tls_ciphersuite);
 extern void net_ssl_context_destroy(struct ssl_context_handle* ctx);
 
 /**
@@ -90,15 +89,26 @@ extern ssize_t net_con_ssl_connect(struct net_connection*);
 extern ssize_t net_ssl_send(struct net_connection* con, const void* buf, size_t len);
 extern ssize_t net_ssl_recv(struct net_connection* con, void* buf, size_t len);
 
+/**
+ * Update the event mask. Additional events may be requested depending on the
+ * needs of the TLS layer.
+ *
+ * @param con Connection handle.
+ * @param events Event mask (NET_EVENT_*)
+ */
+extern void net_ssl_update(struct net_connection* con, int events);
+
 extern void net_ssl_shutdown(struct net_connection* con);
 extern void net_ssl_destroy(struct net_connection* con);
 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 int   net_con_is_ssl(struct net_connection* con);
 
+extern const char* net_ssl_get_tls_version(struct net_connection* con);
+extern const char* net_ssl_get_tls_cipher(struct net_connection* con);
+
 #endif /* SSL_SUPPORT */
 #endif /* HAVE_UHUB_NETWORK_TLS_H */
 

src/plugin_api/command_api.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/plugin_api/handle.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -110,6 +110,7 @@ struct plugin_command;
 struct plugin_command_arg_data;
 
 typedef int (*hfunc_send_message)(struct plugin_handle*, struct plugin_user* user, const char* message);
+typedef int (*hfunc_send_broadcast_message)(struct plugin_handle*, const char* message);
 typedef int (*hfunc_send_status)(struct plugin_handle*, struct plugin_user* to, int code, const char* message);
 typedef int (*hfunc_user_disconnect)(struct plugin_handle*, struct plugin_user* user);
 typedef int (*hfunc_command_add)(struct plugin_handle*, struct plugin_command_handle*);
@@ -118,6 +119,8 @@ typedef int (*hfunc_command_del)(struct plugin_handle*, struct plugin_command_ha
 typedef size_t (*hfunc_command_arg_reset)(struct plugin_handle*, struct plugin_command*);
 typedef struct plugin_command_arg_data* (*hfunc_command_arg_next)(struct plugin_handle*, struct plugin_command*, enum plugin_command_arg_type);
 
+typedef size_t (*hfunc_get_usercount)(struct plugin_handle*);
+
 typedef char* (*hfunc_get_hub_name)(struct plugin_handle*);
 typedef void  (*hfunc_set_hub_name)(struct plugin_handle*, const char*);
 typedef char* (*hfunc_get_hub_description)(struct plugin_handle*);
@@ -130,12 +133,14 @@ typedef void  (*hfunc_set_hub_description)(struct plugin_handle*, const char*);
 struct plugin_hub_funcs
 {
 	hfunc_send_message send_message;
+	hfunc_send_broadcast_message send_broadcast_message;
 	hfunc_send_status send_status_message;
 	hfunc_user_disconnect user_disconnect;
 	hfunc_command_add command_add;
 	hfunc_command_del command_del;
 	hfunc_command_arg_reset command_arg_reset;
 	hfunc_command_arg_next command_arg_next;
+	hfunc_get_usercount get_usercount;
 	hfunc_get_hub_name get_name;
 	hfunc_set_hub_name set_name;
 	hfunc_get_hub_description get_description;

src/plugin_api/message_api.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/plugin_api/types.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/plugins/mod_auth_simple.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -177,16 +177,15 @@ static void unload_acl(struct acl_data* data)
 static plugin_st get_user(struct plugin_handle* plugin, const char* nickname, struct auth_info* data)
 {
 	struct acl_data* acl = (struct acl_data*) plugin->ptr;
-	struct auth_info* info = (struct auth_info*) list_get_first(acl->users);
-	while (info)
+	struct auth_info* info;
+	LIST_FOREACH(struct auth_info*, info, acl->users,
 	{
 		if (strcasecmp((char*)info->nickname, nickname) == 0)
 		{
 			memcpy(data, info, sizeof(struct auth_info));
 			return st_allow;
 		}
-		info = (struct auth_info*) list_get_next(acl->users);
-	}
+	});
 	if (acl->exclusive)
 		return st_deny;
 	return st_default;

src/plugins/mod_auth_sqlite.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -199,7 +199,7 @@ static plugin_st get_user(struct plugin_handle* plugin, const char* nickname, st
 		sqlite3_free(errMsg);
 		return st_default;
 	}
-	
+
 	if (result.found)
 		return st_allow;
 	return st_default;
@@ -222,7 +222,7 @@ static plugin_st register_user(struct plugin_handle* plugin, struct auth_info* u
 		return st_deny;
 	}
 	return st_allow;
-	
+
 }
 
 static plugin_st update_user(struct plugin_handle* plugin, struct auth_info* user)
@@ -243,7 +243,7 @@ static plugin_st update_user(struct plugin_handle* plugin, struct auth_info* use
 		return st_deny;
 	}
 	return st_allow;
-	
+
 }
 
 static plugin_st delete_user(struct plugin_handle* plugin, struct auth_info* user)

src/plugins/mod_chat_history.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -50,9 +50,7 @@ static void history_add(struct plugin_handle* plugin, struct plugin_user* from,
 	list_append(data->chat_history, log);
 	while (list_size(data->chat_history) > data->history_max)
 	{
-		char* msg = list_get_first(data->chat_history);
-		list_remove(data->chat_history, msg);
-		hub_free(msg);
+		list_remove_first(data->chat_history, hub_free);
 	}
 }
 
@@ -79,16 +77,14 @@ static size_t get_messages(struct chat_history_data* data, size_t num, struct cb
 		skiplines = total - num;
 
 	cbuf_append(outbuf, "\n");
-	message = (char*) list_get_first(messages);
-	while (message)
+	LIST_FOREACH(char*, message, messages,
 	{
 		if (--skiplines < 0)
 		{
 			cbuf_append(outbuf, message);
 			lines++;
 		}
-		message = (char*) list_get_next(messages);
-	}
+	});
 	cbuf_append(outbuf, "\n");
 	return lines;
 }
@@ -139,7 +135,7 @@ static int command_history(struct plugin_handle* plugin, struct plugin_user* use
 		maxlines = arg->data.integer;
 	else
 		maxlines = data->history_default;
-	
+
 	buf = cbuf_create(MAX_HISTORY_SIZE);
 	cbuf_append_format(buf, "*** %s: Chat History:\n", cmd->prefix);
 	get_messages(data, maxlines, buf);

src/plugins/mod_chat_history_sqlite.c

@@ -0,0 +1,349 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2014, 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 "plugin_api/handle.h"
+#include "plugin_api/command_api.h"
+#include "util/config_token.h"
+#include <sqlite3.h>
+#include "util/memory.h"
+#include "util/misc.h"
+#include "util/list.h"
+#include "util/cbuffer.h"
+
+#define MAX_HISTORY_SIZE 614400
+
+struct chat_history_data
+{
+	size_t history_max;	///<<< "the maximum number of chat messages kept in history."
+	size_t history_default;	///<<< "the default number of chat messages returned if no limit was provided"
+	size_t history_connect;	///<<< "the number of chat messages provided when users connect to the hub."
+	sqlite3* db;		///<<< "The chat history storage database."
+	struct plugin_command_handle* command_history_handle;		///<<< "A handle to the !history command."
+	struct plugin_command_handle* command_historycleanup_handle;	///<<< "A handle to the !historycleanup command."
+};
+
+struct chat_history_line
+{
+	char message[MAX_HISTORY_SIZE];
+	char from[MAX_NICK_LEN];
+	char time[20];
+};
+
+static int null_callback(void* ptr, int argc, char **argv, char **colName) { return 0; }
+
+static const char* sql_escape_string(const char* str)
+{
+	static char out[MAX_HISTORY_SIZE];
+	size_t i = 0;
+	size_t n = 0;
+	for (; n < strlen(str); n++)
+	{
+		if (str[n] == '\'')
+			out[i++] = '\'';
+		out[i++] = str[n];
+	}
+	out[i++] = '\0';
+	return out;
+}
+
+static int sql_execute(struct chat_history_data* sql, int (*callback)(void* ptr, int argc, char **argv, char **colName), void* ptr, const char* sql_fmt, ...)
+{
+	va_list args;
+	char query[MAX_HISTORY_SIZE];
+	char* errMsg;
+	int rc;
+
+	va_start(args, sql_fmt);
+	vsnprintf(query, sizeof(query), sql_fmt, args);
+
+	rc = sqlite3_exec(sql->db, query, callback, ptr, &errMsg);
+	if (rc != SQLITE_OK)
+	{
+		sqlite3_free(errMsg);
+		return -rc;
+	}
+
+	rc = sqlite3_changes(sql->db);
+	return rc;
+}
+
+static void create_tables(struct plugin_handle* plugin)
+{
+	const char* table_create = "CREATE TABLE IF NOT EXISTS chat_history"
+		"("
+			"from_nick CHAR,"
+			"message TEXT,"
+			"time TIMESTAMP DEFAULT (DATETIME('NOW'))"
+		");";
+
+	struct chat_history_data* data = (struct chat_history_data*) plugin->ptr;
+	sql_execute(data, null_callback, NULL, table_create);
+}
+/**
+ * Add a chat message to history.
+ */
+static void history_add(struct plugin_handle* plugin, struct plugin_user* from, const char* message, int flags)
+{
+	struct chat_history_data* data = (struct chat_history_data*) plugin->ptr;
+	char* history_line = strdup(sql_escape_string(message));
+	char* history_nick = strdup(sql_escape_string(from->nick));
+
+	sql_execute(data, null_callback, NULL, "INSERT INTO chat_history (from_nick, message) VALUES('%s', '%s');DELETE FROM chat_history WHERE time <= (SELECT time FROM chat_history ORDER BY time DESC LIMIT %d,1);", history_nick, history_line, data->history_max);
+
+	hub_free(history_line);
+	hub_free(history_nick);
+}
+
+/**
+ * Obtain messages from the chat history as a linked list
+ */
+
+static int get_messages_callback(void* ptr, int argc, char **argv, char **colName)
+{
+	struct linked_list* messages = (struct linked_list*) ptr;
+	struct chat_history_line* line = hub_malloc(sizeof(struct chat_history_line));
+	int i = 0;
+	
+	memset(line, 0, sizeof(struct chat_history_line));
+	
+	for (; i < argc; i++) {
+		if (strcmp(colName[i], "from_nick") == 0)
+			strncpy(line->from, argv[i], MAX_NICK_LEN);
+		else if (strcmp(colName[i], "message") == 0)
+			strncpy(line->message, argv[i], MAX_HISTORY_SIZE);
+		else if (strcmp(colName[i], "time") == 0)
+			strncpy(line->time, argv[i], 20);
+	}
+	
+	list_append(messages, line);
+	
+	return 0;
+}
+
+void user_login(struct plugin_handle* plugin, struct plugin_user* user)
+{
+	struct chat_history_data* data = (struct chat_history_data*) plugin->ptr;
+	struct cbuffer* buf = NULL;
+	struct linked_list* found = (struct linked_list*) list_create();
+	
+	sql_execute(data, get_messages_callback, found, "SELECT from_nick,message, datetime(time, 'localtime') as time FROM chat_history ORDER BY time DESC LIMIT 0,%d;", (int) data->history_connect);
+
+	if (data->history_connect > 0 && list_size(found) > 0)
+	{
+		buf = cbuf_create(MAX_HISTORY_SIZE);
+		cbuf_append(buf, "Chat history:\n\n");
+		struct chat_history_line* history_line;
+		history_line = (struct chat_history_line*) list_get_last(found);
+		while (history_line)
+		{
+			cbuf_append_format(buf, "[%s] <%s> %s\n", history_line->time, history_line->from, history_line->message);
+			list_remove(found, history_line);
+			hub_free(history_line);
+			history_line = (struct chat_history_line*) list_get_last(found);
+		}
+		plugin->hub.send_message(plugin, user, cbuf_get(buf));
+		cbuf_destroy(buf);
+	}
+	list_clear(found, &hub_free);
+	list_destroy(found);
+}
+
+/**
+ * The callback function for handling the !history command.
+ */
+static int command_history(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
+{
+	struct chat_history_data* data = (struct chat_history_data*) plugin->ptr;
+	struct cbuffer* buf = cbuf_create(MAX_HISTORY_SIZE);
+	struct linked_list* found = (struct linked_list*) list_create();
+	struct plugin_command_arg_data* arg = plugin->hub.command_arg_next(plugin, cmd, plugin_cmd_arg_type_integer);
+	int maxlines;
+
+	if (arg)
+		maxlines = arg->data.integer;
+	else
+		maxlines = data->history_default;
+
+	sql_execute(data, get_messages_callback, found, "SELECT from_nick,message, datetime(time, 'localtime') as time FROM chat_history ORDER BY time DESC LIMIT 0,%d;", maxlines);
+
+	size_t linecount = list_size(found);
+
+	if (linecount > 0)
+	{
+		cbuf_append_format(buf, "*** %s: Chat History:\n\n", cmd->prefix);
+		struct chat_history_line* history_line;
+		history_line = (struct chat_history_line*) list_get_last(found);
+		while (history_line)
+		{
+			cbuf_append_format(buf, "[%s] <%s> %s\n", history_line->time, history_line->from, history_line->message);
+			list_remove(found, history_line);
+			hub_free(history_line);
+			history_line = (struct chat_history_line*) list_get_last(found);
+		}
+	}
+	else
+	{
+		cbuf_append_format(buf, "*** %s: No messages found.", cmd->prefix);
+	}
+
+	plugin->hub.send_message(plugin, user, cbuf_get(buf));
+	cbuf_destroy(buf);
+	list_clear(found, &hub_free);
+	list_destroy(found);
+
+	return 0;
+}
+
+static int command_historycleanup(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
+{
+	struct chat_history_data* data = (struct chat_history_data*) plugin->ptr;
+	struct cbuffer* buf = cbuf_create(128);
+	int rc = 0;
+
+	rc = sql_execute(data, null_callback, NULL, "DELETE FROM chat_history;");
+ 
+	if (!rc)
+		cbuf_append_format(buf, "*** %s: Unable to clean chat history table.", cmd->prefix);
+	else
+		cbuf_append_format(buf, "*** %s: Cleaned chat history table.", cmd->prefix);
+
+	plugin->hub.send_message(plugin, user, cbuf_get(buf));
+	cbuf_destroy(buf);
+
+	sql_execute(data, null_callback, NULL, "VACUUM;");
+
+	return 0;
+}
+
+static void set_error_message(struct plugin_handle* plugin, const char* msg)
+{
+	plugin->error_msg = msg;
+}
+
+static struct chat_history_data* parse_config(const char* line, struct plugin_handle* plugin)
+{
+	struct chat_history_data* data = (struct chat_history_data*) hub_malloc_zero(sizeof(struct chat_history_data));
+	struct cfg_tokens* tokens = cfg_tokenize(line);
+	char* token = cfg_token_get_first(tokens);
+
+	uhub_assert(data != NULL);
+
+	data->history_max = 200;
+	data->history_default = 25;
+	data->history_connect = 5;
+
+	while (token)
+	{
+		struct cfg_settings* setting = cfg_settings_split(token);
+
+		if (!setting)
+		{
+			set_error_message(plugin, "Unable to parse startup parameters");
+			cfg_tokens_free(tokens);
+			hub_free(data);
+			return 0;
+		}
+
+		if (strcmp(cfg_settings_get_key(setting), "file") == 0)
+		{
+			if (!data->db)
+			{
+				if (sqlite3_open(cfg_settings_get_value(setting), &data->db))
+				{
+					cfg_tokens_free(tokens);
+					cfg_settings_free(setting);
+					hub_free(data);
+					set_error_message(plugin, "Unable to open database file");
+					return 0;
+				}
+			}
+		}
+		else if (strcmp(cfg_settings_get_key(setting), "history_max") == 0)
+		{
+			data->history_max = (size_t) uhub_atoi(cfg_settings_get_value(setting));
+		}
+		else if (strcmp(cfg_settings_get_key(setting), "history_default") == 0)
+		{
+			data->history_default = (size_t) uhub_atoi(cfg_settings_get_value(setting));
+		}
+		else if (strcmp(cfg_settings_get_key(setting), "history_connect") == 0)
+		{
+			data->history_connect = (size_t) uhub_atoi(cfg_settings_get_value(setting));
+		}
+		else
+		{
+			set_error_message(plugin, "Unknown startup parameters given");
+			cfg_tokens_free(tokens);
+			cfg_settings_free(setting);
+			hub_free(data);
+			return 0;
+		}
+
+		cfg_settings_free(setting);
+		token = cfg_token_get_next(tokens);
+	}
+	cfg_tokens_free(tokens);
+	return data;
+}
+
+int plugin_register(struct plugin_handle* plugin, const char* config)
+{
+	struct chat_history_data* data;
+	PLUGIN_INITIALIZE(plugin, "SQLite chat history plugin", "1.0", "Provide a global chat history log.");
+
+	plugin->funcs.on_user_chat_message = history_add;
+	plugin->funcs.on_user_login = user_login;
+	data = parse_config(config, plugin);
+	
+	if (!data)
+		return -1;
+
+	plugin->ptr = data;
+
+	create_tables(plugin);
+
+	data->command_history_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
+	PLUGIN_COMMAND_INITIALIZE(data->command_history_handle, plugin, "history", "?N", auth_cred_guest, &command_history, "Show chat message history.");
+	plugin->hub.command_add(plugin, data->command_history_handle);
+
+	data->command_historycleanup_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
+	PLUGIN_COMMAND_INITIALIZE(data->command_historycleanup_handle, plugin, "historycleanup", "", auth_cred_admin, &command_historycleanup, "Clean chat message history.");
+	plugin->hub.command_add(plugin, data->command_historycleanup_handle);
+
+	return 0;
+}
+
+int plugin_unregister(struct plugin_handle* plugin)
+{
+	struct chat_history_data* data = (struct chat_history_data*) plugin->ptr;
+
+	if (data)
+	{
+		sqlite3_close(data->db);
+
+		plugin->hub.command_del(plugin, data->command_history_handle);
+		plugin->hub.command_del(plugin, data->command_historycleanup_handle);
+		hub_free(data->command_history_handle);
+		hub_free(data->command_historycleanup_handle);
+		hub_free(data);
+	}
+
+	return 0;
+}
+

src/plugins/mod_chat_is_privileged.c

@@ -0,0 +1,171 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2014, 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 "plugin_api/handle.h"
+#include "util/memory.h"
+
+struct user_info
+{
+	sid_t sid;
+	int warnings;
+};
+
+struct chat_restrictions_data
+{
+	size_t num_users;        // number of users tracked.
+	size_t max_users;        // max users (hard limit max 1M users due to limitations in the SID (20 bits)).
+	struct user_info* users; // array of max_users
+
+	enum auth_credentials allow_privchat;   // minimum credentials to allow using private chat
+	enum auth_credentials allow_op_contact; // minimum credentials to allow private chat to operators (including super and admins).
+	enum auth_credentials allow_mainchat;   // minimum credentials to allow using main chat
+};
+
+static struct chat_data* parse_config(struct plugin_handle* plugin, const char* line)
+{
+	struct chat_data* data = (struct chat_data*) hub_malloc(sizeof(struct chat_data));
+	struct cfg_tokens* tokens = cfg_tokenize(line);
+	char* token = cfg_token_get_first(tokens);
+
+	// defaults
+	data->num_users = 0;
+	data->max_users = 512;
+	data->users = hub_malloc_zero(sizeof(struct user_info) * data->max_users);
+	data->allow_mainchat = auth_cred_guest;
+	data->allow_op_contact = auth_cred_guest;
+	data->allow_privchat = auth_cred_guest;
+
+	while (token)
+	{
+		struct cfg_settings* setting = cfg_settings_split(token);
+
+		if (!setting)
+		{
+			set_error_message(plugin, "Unable to parse startup parameters");
+			cfg_tokens_free(tokens);
+			hub_free(data);
+			return 0;
+		}
+
+		if (strcmp(cfg_settings_get_key(setting), "allow_privchat") == 0)
+		{
+			if (!string_to_boolean(cfg_settings_get_value(setting), &data->allow_privchat))
+				data->allow_privchat = 0;
+		}
+		else if (strcmp(cfg_settings_get_key(setting), "minimum_access") == 0)
+		{
+		}
+		else
+		{
+			set_error_message(plugin, "Unknown startup parameters given");
+			cfg_tokens_free(tokens);
+			cfg_settings_free(setting);
+			hub_free(data);
+			return 0;
+		}
+
+		cfg_settings_free(setting);
+		token = cfg_token_get_next(tokens);
+	}
+	cfg_tokens_free(tokens);
+
+	return data;
+}
+
+static struct user_info* get_user_info(struct chat_data* data, sid_t sid)
+{
+	struct user_info* u;
+
+	// resize buffer if needed.
+	if (sid >= data->max_users)
+	{
+		u = hub_malloc_zero(sizeof(struct user_info) * (sid + 1));
+		memcpy(u, data->users, data->max_users);
+		hub_free(data->users);
+		data->users = u;
+		data->max_users = sid;
+		u = NULL;
+	}
+
+	u = &data->users[sid];
+
+	// reset counters if the user was not previously known.
+	if (!u->sid)
+	{
+		u->sid = sid;
+		u->warnings = 0;
+		data->num_users++;
+	}
+	return u;
+}
+
+static void on_user_login(struct plugin_handle* plugin, struct plugin_user* user)
+{
+	struct chat_data* data = (struct chat_data*) plugin->ptr;
+	/*struct user_info* info = */
+	get_user_info(data, user->sid);
+}
+
+static void on_user_logout(struct plugin_handle* plugin, struct plugin_user* user, const char* reason)
+{
+	struct chat_data* data = (struct chat_data*) plugin->ptr;
+	struct user_info* info = get_user_info(data, user->sid);
+	if (info->sid)
+		data->num_users--;
+	info->warnings = 0;
+	info->sid = 0;
+}
+
+plugin_st on_chat_msg(struct plugin_handle* plugin, struct plugin_user* from, const char* message)
+{
+	struct chat_data* data = (struct chat_data*) plugin->ptr;
+	if (from->credentials >=
+	return st_default;
+}
+
+plugin_st on_private_msg(struct plugin_handle* plugin, struct plugin_user* from, struct plugin_user* to, const char* message)
+{
+	return st_default;
+}
+
+
+int plugin_register(struct plugin_handle* plugin, const char* config)
+{
+	PLUGIN_INITIALIZE(plugin, "Privileged chat hub", "1.0", "Only registered users can send messages on the main chat.");
+	plugin->ptr = cip_initialize();
+
+	plugin->funcs.on_user_login = on_user_login;
+	plugin->funcs.on_user_logout = on_user_logout;
+	plugin->funcs.on_chat_msg = on_chat_msg;
+	plugin->funcs.on_private_msg = on_private_msg;
+
+	return 0;
+}
+
+int plugin_unregister(struct plugin_handle* plugin)
+{
+	struct chat_data* data = (struct chat_data*) plugin->ptr;
+	if (data)
+	{
+		hub_free(data->users);
+		hub_free(data);
+	}
+	return 0;
+}
+

src/plugins/mod_chat_only.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/plugins/mod_example.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2011, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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

src/plugins/mod_logging.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2014, 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
@@ -102,7 +102,7 @@ static struct log_data* parse_config(const char* line, struct plugin_handle* plu
 		else if (strcmp(cfg_settings_get_key(setting), "syslog") == 0)
 		{
 			int use_syslog = 0;
-			if (!string_to_boolean(cfg_settings_get_value(setting), &use_syslog))
+			if (string_to_boolean(cfg_settings_get_value(setting), &use_syslog))
 			{
 				data->logmode = (use_syslog) ? mode_syslog : mode_file;
 			}