Added support for connecting the hub to an upstream master hub (slave mode).

This API provides transparent asynchronous DNS lookups
with both IPv4 and IPv6 support, and in addition will try
to connect to all addresses until one of them work.

This implements the "happy eyeballs" algorithm provided that the client supports IPv6
and that the DNS records provides both IPv6 and IPv4 addresses.

.gitignore

@@ -14,6 +14,7 @@ uhub-admin
 adcrush
 uhub
 build-stamp
+build.ninja
 debian/files
 debian/uhub.debhelper.log
 debian/uhub.postinst.debhelper
@@ -22,3 +23,4 @@ debian/uhub.prerm.debhelper
 debian/uhub.substvars
 uhub-passwd
 src/version.h
+

AUTHORS

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

CMakeLists.txt

@@ -3,7 +3,7 @@
 ## Copyright (C) 2007-2012, Jan Vidar Krey <janvidar@extatic.org>
  #
 
-cmake_minimum_required (VERSION 2.8.3)
+cmake_minimum_required (VERSION 2.8.2)
 
 project (uhub NONE)
 enable_language(C)
@@ -13,15 +13,17 @@ set (UHUB_VERSION_MINOR 4)
 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(SSL_SUPPORT "Enable SSL support" ON)
 option(USE_OPENSSL "Use OpenSSL's SSL support" ON )
-option(SQLITE_SUPPORT "Enable SQLite support" ON)
+option(SYSTEMD_SUPPORT "Enable systemd notify and journal logging" OFF)
 option(ADC_STRESS "Enable the stress tester client" OFF)
 
 find_package(Git)
+find_package(Sqlite3)
 
 if (SSL_SUPPORT)
 	if (USE_OPENSSL)
@@ -34,11 +36,22 @@ if (SSL_SUPPORT)
 	endif()
 endif()
 
+if (LINK_SUPPORT)
+	add_definitions(-DLINK_SUPPORT)
+endif()
+
+if (SYSTEMD_SUPPORT)
+        INCLUDE(FindPkgConfig)
+        pkg_search_module(SD_DAEMON REQUIRED libsystemd-daemon)
+        pkg_search_module(SD_JOURNAL REQUIRED libsystemd-journal)
+endif()
+
 if (MSVC)
 	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
 include_directories("${PROJECT_SOURCE_DIR}")
+include_directories(${SQLITE3_INCLUDE_DIRS})
 
 file (GLOB uhub_SOURCES ${PROJECT_SOURCE_DIR}/core/*.c)
 list (REMOVE_ITEM uhub_SOURCES
@@ -68,6 +81,7 @@ 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(uhub-passwd ${PROJECT_SOURCE_DIR}/tools/uhub-passwd.c)
 
 add_library(mod_example MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_example.c)
 add_library(mod_welcome MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_welcome.c)
@@ -76,16 +90,8 @@ add_library(mod_auth_simple MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_auth_simple
 add_library(mod_chat_history MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_chat_history.c )
 add_library(mod_chat_only MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_chat_only.c)
 add_library(mod_topic MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_topic.c)
-
+add_library(mod_no_guest_downloads MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_no_guest_downloads.c)
-if (SQLITE_SUPPORT)
 add_library(mod_auth_sqlite MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_auth_sqlite.c)
-	add_executable(uhub-passwd ${PROJECT_SOURCE_DIR}/tools/uhub-passwd.c)
-
-	target_link_libraries(mod_auth_sqlite sqlite3 utils)
-	target_link_libraries(uhub-passwd sqlite3 utils)
-	set_target_properties(mod_auth_sqlite PROPERTIES PREFIX "")
-endif()
-
 
 if(WIN32)
 	target_link_libraries(uhub ws2_32)
@@ -99,17 +105,22 @@ set_target_properties(
 	mod_welcome
 	mod_logging
 	mod_auth_simple
+	mod_auth_sqlite
 	mod_chat_history
 	mod_chat_only
+	mod_no_guest_downloads
 	mod_topic
 	PROPERTIES PREFIX "")
 
 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(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_no_guest_downloads utils)
 target_link_libraries(mod_chat_only utils)
 target_link_libraries(mod_logging utils)
 target_link_libraries(mod_topic utils)
@@ -117,6 +128,7 @@ target_link_libraries(utils network)
 target_link_libraries(mod_welcome network)
 target_link_libraries(mod_logging network)
 
+
 if(UNIX)
 	add_library(adcclient STATIC ${adcclient_SOURCES})
 	add_executable(uhub-admin ${PROJECT_SOURCE_DIR}/tools/admin.c)
@@ -172,24 +184,33 @@ if(SSL_SUPPORT)
 	endif()
 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})
+        add_definitions(-DSYSTEMD)
+endif()
+
 configure_file ("${PROJECT_SOURCE_DIR}/version.h.in" "${PROJECT_SOURCE_DIR}/version.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)
+	add_definitions(-DDEBUG)
 endif()
 
 if (UNIX)
-	install( TARGETS uhub RUNTIME DESTINATION bin )
+	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 DESTINATION /usr/lib/uhub/ OPTIONAL )
+	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( FILES ${CMAKE_SOURCE_DIR}/doc/uhub.conf ${CMAKE_SOURCE_DIR}/doc/plugins.conf ${CMAKE_SOURCE_DIR}/doc/rules.txt ${CMAKE_SOURCE_DIR}/doc/motd.txt DESTINATION /etc/uhub OPTIONAL )
-
-	if (SQLITE_SUPPORT)
-		install( TARGETS uhub-passwd RUNTIME DESTINATION bin )
-	endif()
 endif()
 
 

ChangeLog

@@ -1,3 +1,18 @@
+0.4.1:
+- Converted to CMake which replaces Visual Studio project files and GNU makefiles
+- Fix issues with SSL causing excessive CPU usage.
+- Fix TLS/SSL handshake detection issues
+- Fixed crash in mod_chat_only.
+- Implemented red-black tree for better performance for certain lookups.
+- Better network statistics using the !stats command.
+- Improved protocol parsing, especially escape handling.
+- Fix cbuffer initialization.
+- Install plugins in /usr/lib/uhub, not /var/lib/uhub.
+- Improved init scripts and added a upstart script.
+- Work-around client security bugs by disallowing UCMD messages from being relayed.
+- Added asynchronous DNS resolver.
+
+
 0.4.0:
 - Cleaned up code generator for config file parsing.
 - Merge pull request #5 from yorhel/master

cmake/Modules/FindSqlite3.cmake

@@ -0,0 +1,77 @@
+# - Try to find sqlite3
+# Find sqlite3 headers, libraries and the answer to all questions.
+#
+#  SQLITE3_FOUND               True if sqlite3 got found
+#  SQLITE3_INCLUDEDIR          Location of sqlite3 headers
+#  SQLITE3_LIBRARIES           List of libaries to use sqlite3
+#  SQLITE3_DEFINITIONS         Definitions to compile sqlite3
+#
+# Copyright (c) 2007 Juha Tuomala <tuju@iki.fi>
+# Copyright (c) 2007 Daniel Gollub <gollub@b1-systems.de>
+# Copyright (c) 2007 Alban Browaeys <prahal@yahoo.com>
+#
+#  Redistribution and use is allowed according to the terms of the New
+#  BSD license.
+#  For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+#
+
+INCLUDE( FindPkgConfig )
+# Take care about sqlite3.pc settings
+IF ( Sqlite3_FIND_REQUIRED )
+  SET( _pkgconfig_REQUIRED "REQUIRED" )
+ELSE ( Sqlite3_FIND_REQUIRED )
+  SET( _pkgconfig_REQUIRED "" )
+ENDIF ( Sqlite3_FIND_REQUIRED )
+
+IF ( SQLITE3_MIN_VERSION )
+	PKG_SEARCH_MODULE( SQLITE3 ${_pkgconfig_REQUIRED} sqlite3>=${SQLITE3_MIN_VERSION} )
+ELSE ( SQLITE3_MIN_VERSION )
+	pkg_search_module( SQLITE3 ${_pkgconfig_REQUIRED} sqlite3 )
+ENDIF ( SQLITE3_MIN_VERSION )
+
+
+# Look for sqlite3 include dir and libraries w/o pkgconfig
+IF ( NOT SQLITE3_FOUND AND NOT PKG_CONFIG_FOUND )
+	FIND_PATH( _sqlite3_include_DIR sqlite3.h
+		PATHS
+		/opt/local/include/
+		/sw/include/
+		/usr/local/include/
+		/usr/include/
+	)
+	FIND_LIBRARY( _sqlite3_link_DIR sqlite3
+		PATHS
+		/opt/local/lib
+		/sw/lib
+		/usr/lib
+		/usr/local/lib
+		/usr/lib64
+		/usr/local/lib64
+		/opt/lib64
+	)
+	IF ( _sqlite3_include_DIR AND _sqlite3_link_DIR )
+		SET ( _sqlite3_FOUND TRUE )
+	ENDIF ( _sqlite3_include_DIR AND _sqlite3_link_DIR )
+
+
+	IF ( _sqlite3_FOUND )
+		SET ( SQLITE3_INCLUDE_DIRS ${_sqlite3_include_DIR} )
+		SET ( SQLITE3_LIBRARIES ${_sqlite3_link_DIR} )
+	ENDIF ( _sqlite3_FOUND )
+
+	# Report results
+	IF ( SQLITE3_LIBRARIES AND SQLITE3_INCLUDE_DIRS AND _sqlite3_FOUND )
+		SET( SQLITE3_FOUND 1 )
+		MESSAGE( STATUS "Found sqlite3: ${SQLITE3_LIBRARIES} ${SQLITE3_INCLUDE_DIRS}" )
+	ELSE ( SQLITE3_LIBRARIES AND SQLITE3_INCLUDE_DIRS AND _sqlite3_FOUND )
+		IF ( Sqlite3_FIND_REQUIRED )
+			MESSAGE( SEND_ERROR "Could NOT find sqlite3" )
+		ELSE ( Sqlite3_FIND_REQUIRED )
+			MESSAGE( STATUS "Could NOT find sqlite3" )
+		ENDIF ( Sqlite3_FIND_REQUIRED )
+	ENDIF ( SQLITE3_LIBRARIES AND SQLITE3_INCLUDE_DIRS AND _sqlite3_FOUND )
+
+ENDIF ( NOT SQLITE3_FOUND AND NOT PKG_CONFIG_FOUND )
+
+# Hide advanced variables from CMake GUIs
+MARK_AS_ADVANCED( SQLITE3_LIBRARIES SQLITE3_INCLUDE_DIRS )

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-2013, 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
@@ -34,6 +34,7 @@ typedef uint32_t fourcc_t;
 
 /* default welcome protocol support message, as sent by this server */
 #define ADC_PROTO_SUPPORT "ADBASE ADTIGR ADPING ADUCMD"
+#define ADC_PROTO_LINK_SUPPORT "ADTIGR ADLINK"
 
 /* Server sent commands */
 #define ADC_CMD_ISID FOURCC('I','S','I','D')
@@ -101,6 +102,12 @@ typedef uint32_t fourcc_t;
 #define ADC_CMD_HCMD FOURCC('H','C','M','D')
 #define ADC_CMD_ICMD FOURCC('I','C','M','D')
 
+/* Link commands */
+#define ADC_CMD_LSUP FOURCC('L','S','U','P') /* Link support handshake */
+#define ADC_CMD_LINF FOURCC('L','I','N','F') /* Hub link info */
+#define ADC_CMD_LGPA FOURCC('L','G','P','A') /* Hub link get password */
+#define ADC_CMD_LPAS FOURCC('L','P','A','S') /* Hub link password */
+#define ADC_CMD_LSTA FOURCC('L','S','T','A') /* Hub link status */
 
 #define ADC_INF_FLAG_IPV4_ADDR          "I4" /* ipv4 address */
 #define ADC_INF_FLAG_IPV6_ADDR          "I6" /* ipv6 address */

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-2013, 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
@@ -178,6 +178,7 @@ int adc_msg_get_arg_offset(struct adc_message* msg)
 		
 		case 'I':
 		case 'H':
+		case 'L':
 			return 4;
 			
 		case 'B':
@@ -383,8 +384,9 @@ struct adc_message* adc_msg_parse(const char* line, size_t length)
 			ok = 0;
 			break;
 
-		case 'I':
+		case 'I': /* Hub to client */
-		case 'H':
+		case 'H': /* Clien to hub */
+		case 'L': /* hub to hub Link */
 			ok = (length > 3);
 			break;
 
@@ -787,6 +789,16 @@ int adc_msg_add_argument(struct adc_message* cmd, const char* string)
 	return 0;
 }
 
+int adc_msg_add_argument_string(struct adc_message* cmd, const char* string)
+{
+	char* arg = adc_msg_escape(string);
+	int ret;
+	if (!arg) return -1;
+	ret = adc_msg_add_argument(cmd, arg);
+	hub_free(arg);
+	return ret;
+}
+
 
 char* adc_msg_get_argument(struct adc_message* cmd, int offset)
 {
@@ -868,21 +880,21 @@ int adc_msg_get_argument_index(struct adc_message* cmd, const char prefix[2])
 
 
 
-int adc_msg_escape_length(const char* str)
+size_t adc_msg_escape_length(const char* str)
 {
-	int add = 0;
+	size_t add = 0;
-	int n = 0;
+	size_t n = 0;
 	for (; str[n]; n++)
 		if (str[n] == ' ' || str[n] == '\n' || str[n] == '\\') add++;
 	return n + add;
 }
 
 
-int adc_msg_unescape_length(const char* str)
+size_t adc_msg_unescape_length(const char* str)
 {
-	int add = 0;
+	size_t add = 0;
-	int n = 0;
+	size_t n = 0;
-	int escape = 0;
+	size_t escape = 0;
 	for (; str[n]; n++)
 	{
 		if (escape)
@@ -998,3 +1010,20 @@ char* adc_msg_escape(const char* string)
 	return str;
 }
 
+enum msg_type adc_msg_get_type(const struct adc_message* msg)
+{
+	switch (msg->cache[0])
+	{
+		case 'B': return msg_type_client_broadcast;
+		case 'C': return msg_type_client_to_client;
+		case 'D': return msg_type_client_direct;
+		case 'E': return msg_type_client_echo;
+		case 'F': return msg_type_client_feature;
+		case 'H': return msg_type_client_to_hub;
+		case 'I': return msg_type_hub_to_client;
+		case 'L': return msg_type_link_to_link;
+		case 'U': return msg_type_hub_to_client_udp;
+	}
+	return msg_type_unknown;
+}
+

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-2013, 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,20 @@ enum msg_status_level
 	status_level_fatal = 2, /* Fatal error (disconnect) */
 };
 
+enum msg_type
+{
+	msg_type_unknown           = 0,
+	msg_type_client_broadcast  = 'B',
+	msg_type_client_to_client  = 'C',
+	msg_type_client_direct     = 'D',
+	msg_type_client_echo       = 'E',
+	msg_type_client_feature    = 'F',
+	msg_type_client_to_hub     = 'H',
+	msg_type_hub_to_client     = 'I',
+	msg_type_link_to_link      = 'L',
+	msg_type_hub_to_client_udp = 'U',
+};
+
 /**
  * Increase the reference counter for an ADC message struct.
  * NOTE: Always use the returned value, and not the passed value, as
@@ -171,6 +185,13 @@ extern int adc_msg_replace_named_argument(struct adc_message* cmd, const char pr
  */
 extern int adc_msg_add_argument(struct adc_message* cmd, const char* string);
 
+/**
+ * Append a string argumnent.
+ * The string will automatcally be escaped.
+ * @return  0 if successful, or -1 if an error occured (out of memory).
+ */
+extern int adc_msg_add_argument_string(struct adc_message* cmd, const char* string);
+
 /**
  * Append a named argument
  *
@@ -216,6 +237,12 @@ extern int adc_msg_unescape_to_target(const char* string, char* target, size_t t
  */
 extern char* adc_msg_escape(const char* string);
 
+/**
+ * Calculate the length str would be after escaping.
+ * Does not include any NULL terminator.
+ */
+size_t adc_msg_escape_length(const char* str);
+
 /**
  * This will ensure a newline is at the end of the command.
  */
@@ -234,4 +261,6 @@ void adc_msg_unterminate(struct adc_message* cmd);
  */
 int adc_msg_get_arg_offset(struct adc_message* msg);
 
+enum msg_type adc_msg_get_type(const struct adc_message* msg);
+
 #endif /* HAVE_UHUB_COMMAND_H */

src/core/config.c

@@ -102,7 +102,7 @@ static int config_parse_line(char* line, int line_count, void* ptr_data)
 	data = strip_white_space(data);
 	data = strip_off_quotes(data);
 
-	if (!*key || !*data)
+	if (!*key /*|| !*data*/)
 	{
 		LOG_FATAL("Configuration parse error on line %d", line_count);
 		return -1;

src/core/config.xml

@@ -165,6 +165,36 @@
 		<since>0.3.2</since>
 	</option>
 
+	<option name="hub_link_enabled" type="boolean" default="0">
+		<short>Allow other hubs to link to this hub</short>
+		<description><![CDATA[
+			This allows multiple hubs to link to this hub so
+			that users on the different hubs appear as being on one hub.
+			This is useful for distributing or load balancing large hubs.
+		]]></description>
+		<since>0.5.0</since>
+		<ifdef>LINK_SUPPORT</ifdef>
+	</option>
+
+	<option name="hub_link_secret" type="string" default="">
+		<short>A secret token required to accept hub linking</short>
+		<description><![CDATA[
+			This should be a secret token needed to authorize hubs
+			linking into this one.
+		]]></description>
+		<since>0.5.0</since>
+		<ifdef>LINK_SUPPORT</ifdef>
+	</option>
+
+	<option name="hub_link_connect" type="string" default="">
+		<short>Connect this to hub to another hub</short>
+		<description><![CDATA[
+			The other hub must allow links to be established.
+			Example: uhub://host:port
+		]]></description>
+		<since>0.5.0</since>
+		<ifdef>LINK_SUPPORT</ifdef>
+	</option>
 
 	<option name="max_recv_buffer" type="int" default="4096" advanced="true" >
 		<check min="1024" max="1048576" />

src/core/gen_config.c

@@ -17,6 +17,15 @@ void config_defaults(struct hub_config* config)
 	config->hub_name = hub_strdup("uhub");
 	config->hub_description = hub_strdup("no description");
 	config->redirect_addr = hub_strdup("");
+#ifdef LINK_SUPPORT
+	config->hub_link_enabled = 0;
+#endif /* LINK_SUPPORT */
+#ifdef LINK_SUPPORT
+	config->hub_link_secret = hub_strdup("");
+#endif /* LINK_SUPPORT */
+#ifdef LINK_SUPPORT
+	config->hub_link_connect = hub_strdup("");
+#endif /* LINK_SUPPORT */
 	config->max_recv_buffer = 4096;
 	config->max_send_buffer = 131072;
 	config->max_send_buffer_soft = 98304;
@@ -245,6 +254,42 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 		return 0;
 	}
 
+#ifdef LINK_SUPPORT
+	if (!strcmp(key, "hub_link_enabled"))
+	{
+		if (!apply_boolean(key, data, &config->hub_link_enabled))
+		{
+			LOG_ERROR("Configuration parse error on line %d", line_count);
+			return -1;
+		}
+		return 0;
+	}
+#endif /* LINK_SUPPORT */
+
+#ifdef LINK_SUPPORT
+	if (!strcmp(key, "hub_link_secret"))
+	{
+		if (!apply_string(key, data, &config->hub_link_secret, (char*) ""))
+		{
+			LOG_ERROR("Configuration parse error on line %d", line_count);
+			return -1;
+		}
+		return 0;
+	}
+#endif /* LINK_SUPPORT */
+
+#ifdef LINK_SUPPORT
+	if (!strcmp(key, "hub_link_connect"))
+	{
+		if (!apply_string(key, data, &config->hub_link_connect, (char*) ""))
+		{
+			LOG_ERROR("Configuration parse error on line %d", line_count);
+			return -1;
+		}
+		return 0;
+	}
+#endif /* LINK_SUPPORT */
+
 	if (!strcmp(key, "max_recv_buffer"))
 	{
 		min = 1024;
@@ -943,6 +988,14 @@ void free_config(struct hub_config* config)
 
 	hub_free(config->redirect_addr);
 
+#ifdef LINK_SUPPORT
+	hub_free(config->hub_link_secret);
+#endif /* LINK_SUPPORT */
+
+#ifdef LINK_SUPPORT
+	hub_free(config->hub_link_connect);
+#endif /* LINK_SUPPORT */
+
 	hub_free(config->tls_require_redirect_addr);
 
 	hub_free(config->tls_certificate);
@@ -1074,6 +1127,21 @@ void dump_config(struct hub_config* config, int ignore_defaults)
 	if (!ignore_defaults || strcmp(config->redirect_addr, "") != 0)
 		fprintf(stdout, "redirect_addr = \"%s\"\n", config->redirect_addr);
 
+#ifdef LINK_SUPPORT
+	if (!ignore_defaults || config->hub_link_enabled != 0)
+		fprintf(stdout, "hub_link_enabled = %s\n", config->hub_link_enabled ? "yes" : "no");
+#endif /* LINK_SUPPORT */
+
+#ifdef LINK_SUPPORT
+	if (!ignore_defaults || strcmp(config->hub_link_secret, "") != 0)
+		fprintf(stdout, "hub_link_secret = \"%s\"\n", config->hub_link_secret);
+#endif /* LINK_SUPPORT */
+
+#ifdef LINK_SUPPORT
+	if (!ignore_defaults || strcmp(config->hub_link_connect, "") != 0)
+		fprintf(stdout, "hub_link_connect = \"%s\"\n", config->hub_link_connect);
+#endif /* LINK_SUPPORT */
+
 	if (!ignore_defaults || config->max_recv_buffer != 4096)
 		fprintf(stdout, "max_recv_buffer = %d\n", config->max_recv_buffer);
 

src/core/gen_config.h

@@ -17,6 +17,15 @@ struct hub_config
 	char* hub_name;                        /*<<< Name of hub (default: "uhub") */
 	char* hub_description;                 /*<<< Short hub description, topic or subject. (default: "no description") */
 	char* redirect_addr;                   /*<<< A common hub redirect address. (default: "") */
+#ifdef LINK_SUPPORT
+	int   hub_link_enabled;                /*<<< Allow other hubs to link to this hub (default: 0) */
+#endif /* LINK_SUPPORT */
+#ifdef LINK_SUPPORT
+	char* hub_link_secret;                 /*<<< A secret token required to accept hub linking (default: "") */
+#endif /* LINK_SUPPORT */
+#ifdef LINK_SUPPORT
+	char* hub_link_connect;                /*<<< Connect this to hub to another hub (default: "") */
+#endif /* LINK_SUPPORT */
 	int   max_recv_buffer;                 /*<<< Max read buffer before parse, per user (default: 4096) */
 	int   max_send_buffer;                 /*<<< Max send buffer before disconnect, per user (default: 131072) */
 	int   max_send_buffer_soft;            /*<<< Max send buffer before message drops, per user (default: 98304) */

src/core/hub.c

@@ -787,6 +787,13 @@ struct hub_info* hub_start_service(struct hub_config* config)
 	}
 #endif
 
+#ifdef LINK_SUPPORT
+	if (config->hub_link_enabled)
+	{
+		LOG_INFO("Hub linking support enabled");
+	}
+#endif
+
 	hub->config = config;
 	hub->users = NULL;
 
@@ -834,6 +841,15 @@ struct hub_info* hub_start_service(struct hub_config* config)
 
 	// Start the hub command sub-system
 	hub->commands = command_initialize(hub);
+
+#ifdef LINK_SUPPORT
+	if (*config->hub_link_connect)
+	{
+		link_connect_uri(hub, config->hub_link_connect);
+	}
+#endif
+
+
 	return hub;
 }
 
@@ -897,23 +913,14 @@ void hub_plugins_unload(struct hub_info* hub)
 
 void hub_set_variables(struct hub_info* hub, struct acl_handle* acl)
 {
-	char* tmp;
-	char* server = adc_msg_escape(PRODUCT_STRING); /* FIXME: OOM */
-
 	hub->acl = acl;
 	hub->command_info = adc_msg_construct(ADC_CMD_IINF, 15);
 	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_string(hub->command_info, ADC_INF_FLAG_USER_AGENT, PRODUCT_STRING);
-
+		adc_msg_add_named_argument_string(hub->command_info, ADC_INF_FLAG_NICK, hub->config->hub_name);
-		tmp = adc_msg_escape(hub->config->hub_name);
+		adc_msg_add_named_argument_string(hub->command_info, ADC_INF_FLAG_DESCRIPTION, hub->config->hub_description);
-		adc_msg_add_named_argument(hub->command_info, ADC_INF_FLAG_NICK, tmp);
-		hub_free(tmp);
-
-		tmp = adc_msg_escape(hub->config->hub_description);
-		adc_msg_add_named_argument(hub->command_info, ADC_INF_FLAG_DESCRIPTION, tmp);
-		hub_free(tmp);
 	}
 
 	hub->command_support = adc_msg_construct(ADC_CMD_ISUP, 6 + strlen(ADC_PROTO_SUPPORT));
@@ -922,16 +929,14 @@ void hub_set_variables(struct hub_info* hub, struct acl_handle* acl)
 		adc_msg_add_argument(hub->command_support, ADC_PROTO_SUPPORT);
 	}
 
-	hub->command_banner = adc_msg_construct(ADC_CMD_ISTA, 100 + strlen(server));
+	hub->command_banner = adc_msg_construct(ADC_CMD_ISTA, 100 + adc_msg_escape_length(PRODUCT_STRING));
 	if (hub->command_banner)
 	{
-		if (hub->config->show_banner_sys_info)
-			tmp = adc_msg_escape("Powered by " PRODUCT_STRING " on " OPSYS "/" CPUINFO);
-		else
-			tmp = adc_msg_escape("Powered by " PRODUCT_STRING);
 		adc_msg_add_argument(hub->command_banner, "000");
-		adc_msg_add_argument(hub->command_banner, tmp);
+		if (hub->config->show_banner_sys_info)
-		hub_free(tmp);
+			adc_msg_add_argument_string(hub->command_banner, "Powered by " PRODUCT_STRING " on " OPSYS "/" CPUINFO);
+		else
+			adc_msg_add_argument_string(hub->command_banner, "Powered by " PRODUCT_STRING);
 	}
 
 	if (hub_plugins_load(hub) < 0)
@@ -942,7 +947,6 @@ void hub_set_variables(struct hub_info* hub, struct acl_handle* acl)
 	else
 
 	hub->status = (hub->config->hub_enabled ? hub_status_running : hub_status_disabled);
-	hub_free(server);
 }
 
 

src/core/hub.h

@@ -115,6 +115,10 @@ struct hub_info
 	struct command_base* commands;       /* Hub command handler */
 	struct uhub_plugins* plugins;        /* Plug-ins loaded for this hub instance. */
 
+#ifdef LINK_SUPPORT
+	struct linked_list* hub_links;       /* Other hubs linked to this hub */
+#endif
+
 #ifdef SSL_SUPPORT
 	struct ssl_context_handle* ctx;
 #endif /*  SSL_SUPPORT */

src/core/ioqueue.c

@@ -49,6 +49,34 @@ void ioq_recv_destroy(struct ioq_recv* q)
 	}
 }
 
+#define IOQ_RECV_FLAGS_PREALLOC 1
+#define IOQ_RECV_FLAGS_FULL 2
+
+enum ioq_recv_status ioq_recv_read(struct ioq_recv* q, struct net_connection* con)
+{
+	static char buf[MAX_RECV_BUF];
+	size_t buf_size = ioq_recv_get(q, buf, MAX_RECV_BUF);
+	ssize_t size;
+
+	if (buf_size >= MAX_RECV_BUF)
+		return ioq_recv_full;
+
+	size = net_con_recv(con, buf + buf_size, MAX_RECV_BUF - buf_size);
+
+	if (size > 0)
+		buf_size += size;
+	if (size < 0)
+		return ioq_recv_error;
+	if (size == 0)
+		return ioq_recv_later;
+
+	ioq_recv_set(q, buf, buf_size);
+	return ioq_recv_ok;
+}
+
+
+
+
 size_t ioq_recv_get(struct ioq_recv* q, void* buf, size_t bufsize)
 {
 	uhub_assert(bufsize >= q->size);
@@ -88,6 +116,21 @@ size_t ioq_recv_set(struct ioq_recv* q, void* buf, size_t bufsize)
 }
 
 
+int ioq_recv_consume(struct ioq_recv* q, size_t bytes)
+{
+	size_t newsize;
+	void* ptr;
+
+	if (!q || bytes > q->size) return 0;
+
+	newsize = (q->size - bytes);
+	memmove(q->buf, q->buf + bytes, newsize);
+	ptr = hub_realloc(q->buf, newsize);
+	q->buf = ptr;
+	q->size = newsize;
+	return 1;
+}
+
 struct ioq_send* ioq_send_create()
 {
 	struct ioq_send* q = hub_malloc_zero(sizeof(struct ioq_send));

src/core/ioqueue.h

@@ -39,6 +39,7 @@ struct ioq_recv
 {
 	char* buf;
 	size_t size;
+	// int flags;
 };
 
 /**
@@ -102,5 +103,26 @@ extern size_t ioq_recv_set(struct ioq_recv*, void* buf, size_t bufsize);
 extern int ioq_recv_is_empty(struct ioq_recv* buf);
 
 
+enum ioq_recv_status
+{
+	ioq_recv_ok = 0,    // read data OK
+	ioq_recv_later = 1, // all OK, but call again later (no change)
+	ioq_recv_full  = 2, // all OK, but the buffer is full
+	ioq_recv_error = 3, // error (connection is not working)
+};
+
+/**
+ * Receive from connection into buffer.
+ */
+extern enum ioq_recv_status ioq_recv_read(struct ioq_recv* q, struct net_connection* con);
+
+/**
+ * Consume 'bytes' bytes.
+ * 'bytes' must be <= q->size
+ *
+ * @return 1 on success, or 0 on error (only if q == NULL or bytes is > q->size).
+ */
+extern int ioq_recv_consume(struct ioq_recv* q, size_t bytes);
+
 
 #endif /* HAVE_UHUB_IO_QUEUE_H */

src/core/link.c

@@ -0,0 +1,508 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2013, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+
+#ifdef LINK_SUPPORT
+static int link_send_support(struct hub_link* link);
+
+static void link_net_event(struct net_connection* con, int event, void *arg)
+{
+	LOG_INFO("link_net_event(), event=%d", event);
+	struct hub_link* link = (struct hub_link*) arg;
+	struct hub_info* hub = link->hub;
+	int ret = 0;
+
+	if (event == NET_EVENT_TIMEOUT)
+	{
+		LOG_DEBUG("Hub link timeout!");
+	}
+
+	if (event & NET_EVENT_READ)
+	{
+		ret = link_handle_read(link);
+		if (ret < 0)
+		{
+			link_disconnect(link);
+			return;
+		}
+	}
+
+	if (event & NET_EVENT_WRITE)
+	{
+		ret = link_handle_write(link);
+		if (ret < 0)
+		{
+			link_disconnect(link);
+			return;
+		}
+	}
+}
+
+void link_disconnect(struct hub_link* link)
+{
+	if (link->connection)
+		net_con_close(link->connection);
+	link->connection = NULL;
+
+	ioq_send_destroy(link->send_queue);
+	ioq_recv_destroy(link->recv_queue);
+	link->send_queue = NULL;
+	link->recv_queue = NULL;
+
+	// FIXME: Notify hub and disconnect users!
+
+	hub_free(link);
+}
+
+static struct hub_link* link_create_internal(struct hub_info* hub)
+{
+	struct hub_link* link = NULL;
+
+	LOG_DEBUG("link_create_internal(), hub=%p");
+	link = (struct hub_link*) hub_malloc_zero(sizeof(struct hub_link));
+	if (link == NULL)
+		return NULL; /* OOM */
+
+	link->send_queue = ioq_send_create();
+	link->recv_queue = ioq_recv_create();
+
+	link->hub = hub;
+	link->state = state_protocol;
+	return link;
+}
+
+
+struct hub_link* link_create(struct hub_info* hub, struct net_connection* con, struct ip_addr_encap* addr)
+{
+	struct hub_link* link = link_create_internal(hub);
+	link->connection = con;
+	net_con_reinitialize(link->connection, link_net_event, link, NET_EVENT_READ);
+	link->mode = link_mode_server;
+	return link;
+}
+
+static void link_connect_callback(struct net_connect_handle* handle, enum net_connect_status status, struct net_connection* con, void* ptr)
+{
+	struct hub_link* link = (struct hub_link*) ptr;
+	link->connect_job = NULL;
+
+	LOG_DEBUG("link_connect_callback()");
+
+	switch (status)
+	{
+		case net_connect_status_ok:
+			link->connection = con;
+			net_con_reinitialize(link->connection, link_net_event, link, NET_EVENT_READ);
+			// FIXME: send handshake here
+			link_send_support(link);
+			break;
+
+		case net_connect_status_host_not_found:
+		case net_connect_status_no_address:
+		case net_connect_status_dns_error:
+		case net_connect_status_refused:
+		case net_connect_status_unreachable:
+		case net_connect_status_timeout:
+		case net_connect_status_socket_error:
+			// FIXME: Unable to connect - start timer and re-try connection establishment!
+			break;
+	}
+}
+
+struct link_address
+{
+	char host[256];
+	uint16_t port;
+};
+
+static int link_parse_address(const char* arg, struct link_address* addr)
+{
+	int port;
+	char* split;
+
+	memset(addr, 0, sizeof(struct link_address));
+
+	/* Split hostname and port (if possible) */
+	split = strrchr(arg, ':');
+	if (split == 0 || strlen(split) < 2 || strlen(split) > 6)
+		return 0;
+
+	/* Ensure port number is valid */
+	port = strtol(split+1, NULL, 10);
+	if (port <= 0 || port > 65535)
+		return 0;
+
+	memcpy(addr->host, arg, &split[0] - &arg[0]);
+	addr->port = port;
+	return 1;
+}
+
+
+struct hub_link* link_connect_uri(struct hub_info* hub, const char* address)
+{
+	struct link_address link_address;
+	if (!link_parse_address(address, &link_address))
+	{
+		LOG_INFO("Invalid master hub link address");
+		return NULL;
+	}
+
+	return link_connect(hub, link_address.host, link_address.port);
+}
+
+
+struct hub_link* link_connect(struct hub_info* hub, const char* address, uint16_t port)
+{
+	struct hub_link* link = link_create_internal(hub);
+
+	LOG_DEBUG("Connecting to master link at %s:%d...", address, port);
+
+	link->mode = link_mode_client;
+	link->connect_job = net_con_connect(address, port, link_connect_callback, link);
+	if (!link->connect_job)
+	{
+		// FIXME: Immediate failure!
+		LOG_DEBUG("Error connecting to master hub link.");
+		link_disconnect(link);
+		return NULL;
+	}
+
+	return link;
+}
+
+static int link_net_io_want_read(struct hub_link* link)
+{
+	net_con_update(link->connection, NET_EVENT_READ);
+}
+
+static int link_net_io_want_write(struct hub_link* link)
+{
+	net_con_update(link->connection, NET_EVENT_READ | NET_EVENT_WRITE);
+}
+
+
+int link_handle_write(struct hub_link* link)
+{
+	int ret = 0;
+	while (ioq_send_get_bytes(link->send_queue))
+	{
+		ret = ioq_send_send(link->send_queue, link->connection);
+		if (ret <= 0)
+			break;
+	}
+
+	if (ret < 0)
+		return -1; // FIXME! Extract socket error!
+
+	if (ioq_send_get_bytes(link->send_queue))
+		link_net_io_want_write(link);
+	else
+		link_net_io_want_read(link);
+	return 0;
+}
+
+
+int link_send_message(struct hub_link* link, struct adc_message* msg)
+{
+#ifdef DEBUG_SENDQ
+	char* data = strndup(msg->cache, msg->length-1);
+	LOG_PROTO("[link] send %p: \"%s\"", link, data);
+	free(data);
+#endif
+
+	if (!link->connection)
+		return -1;
+
+	uhub_assert(msg->cache && *msg->cache);
+
+	if (ioq_send_is_empty(link->send_queue) /*&& !user_flag_get(user, flag_pipeline)*/)
+	{
+		/* Perform oportunistic write */
+		ioq_send_add(link->send_queue, msg);
+		link_handle_write(link);
+	}
+	else
+	{
+// 		if (check_send_queue(hub, user, msg) >= 0)
+// 		{
+			ioq_send_add(link->send_queue, msg);
+// 			if (!user_flag_get(user, flag_pipeline))
+			link_net_io_want_write(link);
+	}
+	return 0;
+}
+
+static int link_send_support(struct hub_link* link)
+{
+	int ret;
+	struct adc_message* msg = adc_msg_construct(ADC_CMD_LSUP, 6 + strlen(ADC_PROTO_LINK_SUPPORT));
+	adc_msg_add_argument(msg, ADC_PROTO_LINK_SUPPORT);
+	ret = link_send_message(link, msg);
+	adc_msg_free(msg);
+	return ret;
+}
+
+static int link_send_welcome(struct hub_link* link)
+{
+	int ret;
+	struct adc_message* info = adc_msg_construct(ADC_CMD_LINF, 128);
+
+	if (!info)
+		return -1;
+
+	adc_msg_add_named_argument(info, ADC_INF_FLAG_CLIENT_TYPE, ADC_CLIENT_TYPE_HUB);
+	adc_msg_add_named_argument_string(info, ADC_INF_FLAG_USER_AGENT, PRODUCT_STRING);
+	adc_msg_add_named_argument_string(info, ADC_INF_FLAG_NICK, link->hub->config->hub_name);
+	adc_msg_add_named_argument_string(info, ADC_INF_FLAG_DESCRIPTION, link->hub->config->hub_description);
+
+	ret = link_send_message(link, info);
+
+	link->state = state_normal;
+}
+
+static int link_send_auth_response(struct hub_link* link, const char* challenge)
+{
+	int ret;
+	struct adc_message* msg = adc_msg_construct(ADC_CMD_LPAS, 128);
+
+	// FIXME: Solve challenge.
+
+	ret = link_send_message(link, msg);
+	adc_msg_free(msg);
+	return ret;
+}
+
+static int link_send_auth_request(struct hub_link* link)
+{
+	int ret;
+	struct adc_message* msg = adc_msg_construct(ADC_CMD_LGPA, 128);
+
+	// FIXME: Create challenge.
+	char buf[64];
+	uint64_t tiger_res[3];
+	static char tiger_buf[MAX_CID_LEN+1];
+
+	LOG_DEBUG("link_send_auth_request");
+
+	// FIXME: Generate a better nonce scheme.
+	snprintf(buf, 64, "%p%d", link, (int) net_con_get_sd(link->connection));
+
+	tiger((uint64_t*) buf, strlen(buf), (uint64_t*) tiger_res);
+	base32_encode((unsigned char*) tiger_res, TIGERSIZE, tiger_buf);
+	tiger_buf[MAX_CID_LEN] = 0;
+
+	// Add nonce to message
+	adc_msg_add_argument(msg, (const char*) tiger_buf);
+	ret = link_send_message(link, msg);
+	adc_msg_free(msg);
+	return ret;
+}
+
+static int link_handle_support(struct hub_link* link, struct adc_message* msg)
+{
+	int ret = 0;
+
+	LOG_DEBUG("link_handle_support");
+
+	if (link->mode == link_mode_server)
+	{
+		if (link->state == state_protocol)
+		{
+			ret = link_send_support(link);
+			if (ret == 0)
+				ret = link_send_auth_request(link);
+			link->state = state_verify;
+		}
+	}
+	return ret;
+}
+
+static int link_handle_auth_request(struct hub_link* link, struct adc_message* msg)
+{
+	char* challenge;
+	int ret = -1;
+
+	LOG_DEBUG("link_handle_auth_request");
+
+	if (link->state == state_verify)
+		return -1;
+
+	if (link->mode == link_mode_client)
+	{
+		challenge = adc_msg_get_argument(msg, 0);
+		ret = link_send_auth_response(link, challenge);
+		hub_free(challenge);
+	}
+	return ret;
+}
+
+static int link_handle_auth_response(struct hub_link* link, struct adc_message* msg)
+{
+
+	LOG_DEBUG("link_handle_auth_response. link_state=%d", (int) link->state);
+
+	if (link->state != state_verify)
+		return -1;
+
+	LOG_DEBUG("State is not verify!");
+
+	if (link->mode == link_mode_server)
+	{
+		// Check authentication data
+		// FIXME: Can involve plug-ins at this point.
+		return link_send_welcome(link);
+	}
+	else
+	{
+		LOG_DEBUG("Ignoring auth response - We're client mode!");
+	}
+
+	return -1;
+}
+
+static int link_handle_link_info(struct hub_link* link, struct adc_message* msg)
+{
+	LOG_DEBUG("link_handle_link_info");
+	return 0;
+}
+
+static int link_handle_status(struct hub_link* link, struct adc_message* msg)
+{
+	LOG_DEBUG("link_handle_status");
+	return -1;
+}
+
+static int link_handle_message(struct hub_link* link, const char* message, size_t length)
+{
+	int ret = 0;
+	struct adc_message* cmd = 0;
+
+	LOG_INFO("link_handle_message(): %s (%d)", message, (int) length);
+
+	// FIXME: is this needed?
+	if (link->state == state_cleanup || link->state == state_disconnected)
+		return -1;
+
+	cmd = adc_msg_parse(message, length);
+	if (!cmd)
+	{
+		LOG_DEBUG("Unable to parse hub-link message");
+		return -1;
+	}
+
+	// if (
+
+	switch (cmd->cmd)
+	{
+		case ADC_CMD_LSUP:
+			ret = link_handle_support(link, cmd);
+			break;
+
+		case ADC_CMD_LPAS:
+			ret = link_handle_auth_response(link, cmd);
+			break;
+
+		case ADC_CMD_LGPA:
+			ret = link_handle_auth_request(link, cmd);
+			break;
+
+		case ADC_CMD_LINF:
+			ret = link_handle_link_info(link, cmd);
+			break;
+
+		case ADC_CMD_LSTA:
+			ret = link_handle_status(link, cmd);
+			break;
+	}
+
+	adc_msg_free(cmd);
+	return ret;
+}
+
+
+static int link_read_message(struct hub_link* link)
+{
+	char* lastPos = 0;
+	char* pos = 0;
+	char* start = link->recv_queue->buf;
+	size_t remaining = link->recv_queue->size;
+
+	while ((pos = memchr(start, '\n', remaining)))
+	{
+		lastPos = pos+1;
+		pos[0] = '\0';
+
+		if (link->flags & 1)
+		{
+			 /* FIXME Unset maxbuf flag */
+			link->flags = 0;
+		}
+		else
+		{
+			if (link_handle_message(link, start, (pos - start)) == -1)
+			{
+				return -1;
+			}
+		}
+
+		pos[0] = '\n'; /* FIXME: not needed */
+		pos ++;
+		remaining -= (pos - start);
+		start = pos;
+	}
+
+	ioq_recv_consume(link->recv_queue, (start - link->recv_queue->buf));
+	return 0;
+}
+
+int link_handle_read(struct hub_link* link)
+{
+	int ret = 0;
+	while (1)
+	{
+		switch (ioq_recv_read(link->recv_queue, link->connection))
+		{
+			case ioq_recv_ok:
+				if (link_read_message(link) < 0)
+				{
+					// FIXME: propagate protocol error?
+					return -1;
+				}
+				// Parse messages then call again
+				break;
+				
+			case ioq_recv_later:
+				return 0;
+
+			case ioq_recv_full:
+				link->flags = 1; // FIXME: MAXBUF
+				ioq_recv_set(link->recv_queue, 0, 0);
+				break;
+
+			case ioq_recv_error:
+				return -1; // FIXME: it would be good to signal type of socket error
+		}
+	}
+
+	return 0;
+}
+
+
+#endif /* LINK_SUPPORT */

src/core/link.h

@@ -0,0 +1,70 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2013, 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_LINK_H
+#define HAVE_UHUB_LINK_H
+
+#ifdef LINK_SUPPORT
+
+struct hub_link
+{
+	char name[MAX_NICK_LEN+1];         /** The name of the linked hub */
+	char user_agent[MAX_UA_LEN+1];     /** The user agent of the linked hub */
+	char address[256];                 /** The official address of the linked hub */
+	enum link_mode { link_mode_client, link_mode_server } mode;
+	enum user_state state;
+	struct ioq_send* send_queue;
+	struct ioq_recv* recv_queue;
+	struct net_connection* connection; /** Connection data */
+	struct net_connect_handle* connect_job; /** Only used when establishing a connection in client mode */
+	struct hub_info* hub;
+	int flags;
+};
+
+/**
+ * Create a link from an accepted connection (act as a link server).
+ */
+extern struct hub_link* link_create(struct hub_info* hub, struct net_connection* con, struct ip_addr_encap* addr);
+
+/**
+ * Connect this hub to an upstream server (act as a link client).
+ */
+extern struct hub_link* link_connect(struct hub_info* hub, const char* address, uint16_t port);
+extern struct hub_link* link_connect_uri(struct hub_info* hub, const char* address);
+
+/**
+ * Disconnect a link connection.
+ */
+extern void link_disconnect(struct hub_link*);
+
+/**
+ * Read from link connection and process messages.
+ * @return 0 on success, and a negative value otherwise
+ */
+extern int link_handle_read(struct hub_link* link);
+
+/**
+ * Write queued messages to the link.
+ * @return 0 on success, and a negative value otherwise.
+ */
+extern int link_handle_write(struct hub_link* link);
+
+#endif // LINK_SUPPORT
+
+#endif /* HAVE_UHUB_LINK_H */

src/core/main.c

@@ -19,6 +19,10 @@
 
 #include "uhub.h"
 
+#ifdef SYSTEMD
+#include <systemd/sd-daemon.h>
+#endif
+
 static int arg_verbose = 5;
 static int arg_fork    = 0;
 static int arg_check_config = 0;
@@ -121,6 +125,10 @@ int main_loop()
 			hub_set_log_verbosity(arg_verbose);
 		}
 
+#ifdef DEBUG
+		LOG_INFO("Debug messages enabled");
+#endif
+	
 		if (read_config(arg_config, &configuration, !arg_have_config) == -1)
 			return -1;
 
@@ -145,7 +153,16 @@ int main_loop()
 			}
 #if !defined(WIN32)
 			setup_signal_handlers(hub);
-#endif
+#ifdef SYSTEMD
+                        /* Notify the service manager that this daemon has 
+                         * been successfully initalized and shall enter the
+                         * main loop.
+                         */
+                        sd_notifyf(0, "READY=1\n"
+                                      "MAINPID=%lu", (unsigned long) getpid());
+#endif /* SYSTEMD */
+
+#endif /* ! WIN32 */
 		}
 
 		hub_set_variables(hub, &acl);
@@ -216,13 +233,17 @@ void print_usage(char* program)
 		"   -q          Quiet mode - no output\n"
 		"   -f          Fork to background\n"
 		"   -l <file>   Log messages to given file (default: stderr)\n"
-		"   -L          Log messages to syslog\n"
 		"   -c <file>   Specify configuration file (default: " SERVER_CONFIG ")\n"
 		"   -C          Check configuration and return\n"
 		"   -s          Show configuration parameters\n"
 		"   -S          Show configuration parameters, but ignore defaults\n"
 		"   -h          This message\n"
 #ifndef WIN32
+#ifdef SYSTEMD
+		"   -L          Log messages to journal\n"
+#else
+		"   -L          Log messages to syslog\n"
+#endif
 		"   -u <user>   Run as given user\n"
 		"   -g <group>  Run with given group permissions\n"
 		"   -p <file>   Store pid in file (process id)\n"

src/core/probe.c

@@ -71,6 +71,17 @@ static void probe_net_event(struct net_connection* con, int events, void *arg)
 				probe_destroy(probe);
 				return;
 			}
+#ifdef LINK_SUPPORT
+			else if (probe->hub->config->hub_link_enabled && memcmp(probe_recvbuf, "LSUP", 4) == 0)
+			{
+				if (link_create(probe->hub, probe->connection, &probe->addr))
+				{
+					probe->connection = 0;
+				}
+				probe_destroy(probe);
+				return;
+			}
+#endif /* LINK_SUPPORT */
 #ifdef SSL_SUPPORT
 			else if (bytes >= 11 &&
 				probe_recvbuf[0] == 22 && 

src/core/route.c

@@ -99,7 +99,7 @@ int route_to_user(struct hub_info* hub, struct hub_user* user, struct adc_messag
 {
 #ifdef DEBUG_SENDQ
 	char* data = strndup(msg->cache, msg->length-1);
-	LOG_PROTO("send %s: \"%s\"", sid_to_string(user->id.sid), data);
+	LOG_PROTO("[user] send %s: \"%s\"", sid_to_string(user->id.sid), data);
 	free(data);
 #endif
 

src/network/backend.c

@@ -132,9 +132,10 @@ struct timeout_queue* net_backend_get_timeout_queue()
  */
 int net_backend_process()
 {
-	int res;
+	int res = 0;
 	size_t secs = timeout_queue_get_next_timeout(&g_backend->timeout_queue, g_backend->now);
 
+	if (g_backend->common.num)
 		res = g_backend->handler.backend_poll(g_backend->data, secs * 1000);
 
 	g_backend->now = time(0);

src/network/connection.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2013, 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
@@ -145,3 +145,364 @@ void net_con_callback(struct net_connection* con, int events)
 		con->callback(con, events, con->ptr);
 }
 
+struct net_connect_job
+{
+	struct net_connection* con;
+	struct net_connect_handle* handle;
+	struct sockaddr_storage addr;
+	struct net_connect_job* next;
+};
+
+struct net_connect_handle
+{
+	const char* address;
+	uint16_t port;
+	void* ptr;
+	net_connect_cb callback;
+	struct net_dns_job* dns;
+	const struct net_dns_result* result;
+	struct net_connect_job* job4;
+	struct net_connect_job* job6;
+};
+
+static void net_connect_callback(struct net_connect_handle* handle, enum net_connect_status status, struct net_connection* con);
+static void net_connect_job_internal_cb(struct net_connection* con, int event, void* ptr);
+
+/**
+ * Check if a connection job is completed.
+ * @return -1 on completed with an error, 0 on not yet completed, or 1 if completed successfully (connected).
+ */
+static int net_connect_job_check(struct net_connect_job* job)
+{
+	struct net_connection* con = job->con;
+	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));
+	if (ret == 0 || (ret == -1 && net_error() == EISCONN))
+	{
+		LOG_TRACE("net_connect_job_check(): Socket connected!");
+		job->con = NULL;
+		net_connect_callback(job->handle, net_connect_status_ok, con);
+		return 1;
+	}
+	else if (ret == -1 && (net_error() == EALREADY || net_error() == EINPROGRESS || net_error() == EWOULDBLOCK || net_error() == EINTR))
+	{
+		return 0;
+	}
+	LOG_TRACE("net_connect_job_check(): Socket error!");
+
+	switch (net_error())
+	{
+		case ECONNREFUSED:
+			status = net_connect_status_refused;
+			break;
+		case ENETUNREACH:
+			status = net_connect_status_unreachable;
+			break;
+
+		default:
+			status = net_connect_status_socket_error;
+	}
+
+	net_connect_callback(job->handle, status, NULL);
+	return -1;
+}
+
+static void net_connect_job_free(struct net_connect_job* job)
+{
+	if (job->con)
+		net_con_close(job->con);
+	job->handle = NULL;
+	job->next = NULL;
+	hub_free(job);
+}
+
+static void net_connect_job_stop(struct net_connect_job* job)
+{
+	if (job->addr.ss_family == AF_INET6)
+	{
+		job->handle->job6 = job->next;
+	}
+	else
+	{
+		job->handle->job4 = job->next;
+	}
+
+	net_connect_job_free(job);
+}
+
+static int net_connect_depleted(struct net_connect_handle* handle)
+{
+	return (!handle->job6 && !handle->job4);
+}
+
+static int net_connect_job_process(struct net_connect_job* job)
+{
+	int sd;
+	if (!job->con)
+	{
+		sd = net_socket_create(job->addr.ss_family, SOCK_STREAM, IPPROTO_TCP);
+		if (sd == -1)
+		{
+			LOG_DEBUG("net_connect_job_process: Unable to create socket!");
+			net_connect_callback(job->handle, net_connect_status_socket_error, NULL);
+			return -1; // FIXME
+		}
+
+		job->con = 	net_con_create();
+		net_con_initialize(job->con, sd, net_connect_job_internal_cb, job, NET_EVENT_WRITE);
+		net_con_set_timeout(job->con, TIMEOUT_CONNECTED); // FIXME: Use a proper timeout value!
+	}
+
+	return net_connect_job_check(job);
+}
+
+
+/*
+ * Internal callback used to establish an outbound connection.
+ */
+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;
+
+	if (event == NET_EVENT_TIMEOUT)
+	{
+		// FIXME: Try next address, or if no more addresses left declare failure to connect.
+		if (job->addr.ss_family == AF_INET6)
+		{
+			net_connect_job_stop(job);
+
+			if (!next_job)
+			{
+				LOG_TRACE("No more IPv6 addresses to try!");
+			}
+
+		}
+		else
+		{
+			net_connect_job_stop(job);
+
+			if (!next_job)
+			{
+				LOG_TRACE("No more IPv4 addresses to try!");
+			}
+		}
+
+		if (net_connect_depleted(handle))
+		{
+			LOG_TRACE("No more addresses left. Unable to connect!");
+			net_connect_callback(handle, net_connect_status_timeout, NULL);
+		}
+		return;
+	}
+
+	if (event == NET_EVENT_WRITE)
+	{
+		net_connect_job_process(job);
+	}
+}
+
+
+static int net_connect_cancel(struct net_connect_handle* handle)
+{
+	struct net_connect_job* job;
+
+	job = handle->job6;
+	while (job)
+	{
+		job = job->next;
+		net_connect_job_free(handle->job6);
+		handle->job6 = job;
+	}
+
+	job = handle->job4;
+	while (job)
+	{
+		job = job->next;
+		net_connect_job_free(handle->job4);
+		handle->job4 = job;
+	}
+}
+
+
+static int net_connect_process_queue(struct net_connect_handle* handle, struct net_connect_job* job)
+{
+	int ret;
+	while (job)
+	{
+		ret = net_connect_job_process(job);
+		if (ret < 0)
+		{
+			net_connect_job_stop(job);
+			continue;
+		}
+		else if (ret == 0)
+		{
+			// Need to process again
+			return 0;
+		}
+		else
+		{
+			// FIXME: Success!
+			return 1;
+		}
+	}
+	return -1;
+}
+
+static int net_connect_process(struct net_connect_handle* handle)
+{
+	int ret4, ret6;
+
+	ret6 = net_connect_process_queue(handle, handle->job6);
+	if (ret6 == 1)
+		return 1; // Connected - cool!
+
+	net_connect_process_queue(handle, handle->job4);
+}
+
+
+static int net_connect_job_schedule(struct net_connect_handle* handle, struct ip_addr_encap* addr)
+{
+	struct net_connect_job* job;
+	struct sockaddr_in* addr4;
+	struct sockaddr_in6* addr6;
+
+	if (addr->af == AF_INET6 && !net_is_ipv6_supported())
+	{
+		LOG_TRACE("net_connect_job_schedule(): Skipping IPv6 support since IPv6 is not supported.");
+		return 0;
+	}
+	else
+	{
+		job = hub_malloc_zero(sizeof(struct net_connect_job));
+		job->handle = handle;
+		if (addr->af == AF_INET6)
+		{
+			addr6 = (struct sockaddr_in6*) &job->addr;
+			LOG_TRACE("net_connect_job_schedule(): Scheduling IPv6 connect job.");
+			addr6->sin6_family = AF_INET6;
+			addr6->sin6_port = htons(handle->port);
+			memcpy(&addr6->sin6_addr, &addr->internal_ip_data.in6, sizeof(struct in6_addr));
+
+			// prepend
+			job->next = handle->job6;
+			handle->job6 = job;
+		}
+		else
+		{
+			addr4 = (struct sockaddr_in*) &job->addr;
+			LOG_TRACE("net_connect_job_schedule(): Scheduling IPv4 connect job.");
+			addr4->sin_family = AF_INET;
+			addr4->sin_port = htons(handle->port);
+			memcpy(&addr4->sin_addr, &addr->internal_ip_data.in, sizeof(struct in_addr));
+
+			// prepend
+			job->next = handle->job4;
+			handle->job4 = job;
+		}
+	}
+	return 1;
+}
+
+
+/*
+ * Callback when the DNS results are ready.
+ * Create a list of IPv6 and IPv4 addresses, then
+ * start connecting to them one by one until one succeeds.
+ */
+static int net_con_connect_dns_callback(struct net_dns_job* job, const struct net_dns_result* result)
+{
+	struct ip_addr_encap* addr;
+	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)
+	{
+		LOG_DEBUG("net_con_connect() - Unable to lookup host!");
+		net_connect_callback(handle, net_connect_status_dns_error, NULL);
+		return 1;
+	}
+
+	if (!net_dns_result_size(result))
+	{
+		LOG_DEBUG("net_con_connect() - Host not found!");
+		net_connect_callback(handle, net_connect_status_host_not_found, NULL);
+		return 1;
+	}
+
+	handle->result = result;
+
+	// Extract results into a separate list of IPv4 and IPv6 addresses.
+	addr = net_dns_result_first(result);
+	while (addr)
+	{
+		if (net_connect_job_schedule(handle, addr))
+			usable++;
+		addr = net_dns_result_next(result);
+	}
+
+	net_connect_process(handle);
+
+	return 0;
+}
+
+// typedef void (*net_connect_cb)(struct net_connect_handle*, enum net_connect_handle_code, struct net_connection* con);
+
+struct net_connect_handle* net_con_connect(const char* address, uint16_t port, net_connect_cb callback, void* ptr)
+{
+	struct net_connect_handle* handle = hub_malloc_zero(sizeof(struct net_connect_handle));
+
+	handle->address = hub_strdup(address);
+	handle->port = port;
+	handle->ptr = ptr;
+	handle->callback = callback;
+
+	// FIXME: Check if DNS resolving is necessary ?
+	handle->dns = net_dns_gethostbyname(address, AF_UNSPEC, net_con_connect_dns_callback, handle);
+	if (!handle->dns)
+	{
+		LOG_TRACE("net_con_connect(): Unable to create DNS lookup job.");
+		hub_free((char*) handle->address);
+		hub_free(handle);
+		return NULL;
+	}
+
+	return handle;
+}
+
+void net_connect_destroy(struct net_connect_handle* handle)
+{
+	hub_free((char*) handle->address);
+
+	// cancel DNS job if pending
+	if (handle->dns)
+		net_dns_job_cancel(handle->dns);
+
+	// Stop any connect jobs.
+	net_connect_cancel(handle);
+
+	// free any DNS results
+	net_dns_result_free(handle->result);
+
+	hub_free(handle);
+}
+
+static void net_connect_callback(struct net_connect_handle* handle, enum net_connect_status status, struct net_connection* con)
+{
+	uhub_assert(handle->callback != NULL);
+
+	// Call the callback
+	handle->callback(handle, status, con, handle->ptr);
+	handle->callback = NULL;
+
+	// Cleanup
+	net_connect_destroy(handle);
+}

src/network/connection.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2013, 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
@@ -34,10 +34,41 @@ struct net_connection
 	NET_CON_STRUCT_COMMON
 };
 
+struct net_connect_handle;
+
+enum net_connect_status
+{
+	net_connect_status_ok = 0,
+	net_connect_status_host_not_found = -1,
+	net_connect_status_no_address = -2,
+	net_connect_status_dns_error = -3,
+	net_connect_status_refused = -4,
+	net_connect_status_unreachable = -5,
+	net_connect_status_timeout = -6,
+	net_connect_status_socket_error = -7,
+};
+
+typedef void (*net_connect_cb)(struct net_connect_handle*, enum net_connect_status status, struct net_connection* con, void* ptr);
+
 extern int   net_con_get_sd(struct net_connection* con);
 extern void* net_con_get_ptr(struct net_connection* con);
 
 extern struct net_connection* net_con_create();
+
+/**
+ * Establish an outbound TCP connection.
+ * This will resolve the IP-addresses, and connect to
+ * either an IPv4 or IPv6 address depending if it is supported,
+ * and using the happy eyeballs algorithm.
+ *
+ * @param address Hostname, IPv4 or IPv6 address
+ * @param port TCP port number
+ * @param callback A callback to be called once the connection is established, or failed.
+ * @returns a handle to the connection establishment job, or NULL if an immediate error.
+ */
+extern struct net_connect_handle* net_con_connect(const char* address, uint16_t port, net_connect_cb callback, void* ptr);
+extern void net_connect_destroy(struct net_connect_handle* handle);
+
 extern void net_con_destroy(struct net_connection*);
 extern void net_con_initialize(struct net_connection* con, int sd, net_connection_cb callback, const void* ptr, int events);
 extern void net_con_reinitialize(struct net_connection* con, net_connection_cb callback, const void* ptr, int events);

src/network/dnsresolver.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2013, 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
@@ -366,21 +366,24 @@ extern size_t net_dns_result_size(const struct net_dns_result* res)
 extern struct ip_addr_encap* net_dns_result_first(const struct net_dns_result* res)
 {
 	struct ip_addr_encap* ipaddr = list_get_first(res->addr_list);
-	LOG_TRACE("net_dns_result_first() - Address: %s", ip_convert_to_string(ipaddr));
+	LOG_TRACE("net_dns_result_first() - Address: %s", ipaddr ? ip_convert_to_string(ipaddr) : "(no address)");
 	return ipaddr;
 }
 
 extern struct ip_addr_encap* net_dns_result_next(const struct net_dns_result* res)
 {
 	struct ip_addr_encap* ipaddr = list_get_next(res->addr_list);
-	LOG_TRACE("net_dns_result_next() - Address: %s", ip_convert_to_string(ipaddr));
+	LOG_TRACE("net_dns_result_next() - Address: %s", ipaddr ? ip_convert_to_string(ipaddr) : "(no more addresses)");
 	return ipaddr;
 }
 
-extern void net_dns_result_free(struct net_dns_result* res)
+extern void net_dns_result_free(const struct net_dns_result* res)
 {
+	if (!res)
+		return;
+
 	list_clear(res->addr_list, &hub_free);
 	list_destroy(res->addr_list);
 	free_job(res->job);
-	hub_free(res);
+	hub_free((struct net_dns_result*) res);
 }

src/network/dnsresolver.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2012, Jan Vidar Krey
+ * Copyright (C) 2007-2013, 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
@@ -114,6 +114,6 @@ extern struct ip_addr_encap* net_dns_result_first(const struct net_dns_result*);
 extern struct ip_addr_encap* net_dns_result_next(const struct net_dns_result*);
 
 /// When finished with the results
-extern void net_dns_result_free(struct net_dns_result*);
+extern void net_dns_result_free(const struct net_dns_result*);
 
 #endif /* HAVE_UHUB_NETWORK_DNS_RESOLVER_H */

src/plugins/mod_no_guest_downloads.c

@@ -0,0 +1,60 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "plugin_api/handle.h"
+#include "util/memory.h"
+
+static plugin_st on_search_result(struct plugin_handle* plugin, struct plugin_user* from, struct plugin_user* to, const char* search_data)
+{
+	if (to->credentials >= auth_cred_user)
+		return st_default;
+	return st_deny;
+}
+
+static plugin_st on_search(struct plugin_handle* plugin, struct plugin_user* user, const char* search_data)
+{
+	// Registered users are allowed to search.
+	if (user->credentials >= auth_cred_user)
+		return st_default;
+	return st_deny;
+}
+
+static plugin_st on_p2p_connect(struct plugin_handle* plugin, struct plugin_user* from, struct plugin_user* to)
+{
+	if (from->credentials >= auth_cred_user)
+		return st_default;
+	return st_deny;
+}
+
+int plugin_register(struct plugin_handle* plugin, const char* config)
+{
+	PLUGIN_INITIALIZE(plugin, "No guest downloading", "0.1", "This plug-in only allows registered users to search and initiate transfers.");
+	plugin->ptr = NULL;
+	plugin->funcs.on_search = on_search;
+	plugin->funcs.on_search_result = on_search_result;
+	plugin->funcs.on_p2p_connect = on_p2p_connect;
+	// plugin->funcs.on_p2p_revconnect = on_p2p_connect;
+	return 0;
+}
+
+int plugin_unregister(struct plugin_handle* plugin)
+{
+	return 0;
+}
+

src/system.h

@@ -127,6 +127,10 @@
 */
 #endif
 
+#ifdef __GNU__
+#define POSIX_THREAD_SUPPORT
+#endif
+
 #define USE_SELECT
 #ifndef WINSOCK
 #include <sys/select.h>

src/tools/adcclient.c

@@ -30,7 +30,6 @@
 enum ADC_client_state
 {
 	ps_none, /* Not connected */
-	ps_dns,  /* looking up name */
 	ps_conn, /* Connecting... */
 	ps_conn_ssl, /* SSL handshake */
 	ps_protocol, /* Have sent HSUP */
@@ -68,7 +67,7 @@ struct ADC_client
 	struct net_connection* con;
 	struct net_timer* timer;
 	struct sockaddr_storage addr;
-	struct net_dns_job* dns_job;
+	struct net_connect_handle* connect_job;
 	struct ADC_client_address address;
 	char* nick;
 	char* desc;
@@ -109,7 +108,6 @@ static void ADC_client_debug(struct ADC_client* client, const char* format, ...)
 static const char* ADC_client_state_string[] =
 {
 	"ps_none",
-	"ps_dns",
 	"ps_conn",
 	"ps_conn_ssl",
 	"ps_protocol",
@@ -164,18 +162,12 @@ static void event_callback(struct net_connection* con, int events, void *arg)
 
 	switch (client->state)
 	{
-		case ps_dns:
-			break;
-
 		case ps_conn:
 			if (events == NET_EVENT_TIMEOUT)
 			{
 				client->callback(client, ADC_CLIENT_DISCONNECTED, 0);
 				return;
 			}
-
-			if (events & NET_EVENT_WRITE)
-				ADC_client_connect_internal(client);
 			break;
 
 #ifdef SSL_SUPPORT
@@ -539,11 +531,6 @@ struct ADC_client* ADC_client_create(const char* nickname, const char* descripti
 	ADC_TRACE;
 	struct ADC_client* client = (struct ADC_client*) hub_malloc_zero(sizeof(struct ADC_client));
 
-	int sd = net_socket_create(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-	if (sd == -1) return NULL;
-
-	client->con = net_con_create();
-	net_con_initialize(client->con, sd, event_callback, client, 0);
 	ADC_client_set_state(client, ps_none);
 
 	client->nick = hub_strdup(nickname);
@@ -570,40 +557,42 @@ void ADC_client_destroy(struct ADC_client* client)
 	hub_free(client);
 }
 
+static void connect_callback(struct net_connect_handle* handle, enum net_connect_status status, struct net_connection* con, void* ptr)
+{
+	struct ADC_client* client = (struct ADC_client*) ptr;
+	client->connect_job = NULL;
+	switch (status)
+	{
+		case net_connect_status_ok:
+			client->con = con;
+			net_con_reinitialize(client->con, event_callback, client, 0);
+			ADC_client_on_connected(client);
+			break;
+
+		case net_connect_status_host_not_found:
+		case net_connect_status_no_address:
+		case net_connect_status_dns_error:
+		case net_connect_status_refused:
+		case net_connect_status_unreachable:
+		case net_connect_status_timeout:
+		case net_connect_status_socket_error:
+			ADC_client_disconnect(client);
+			break;
+	}
+}
+
 int ADC_client_connect(struct ADC_client* client, const char* address)
 {
 	ADC_TRACE;
 	if (client->state == ps_none)
 	{
-		// Parse address and start name resolving!
 		if (!ADC_client_parse_address(client, address))
 			return 0;
-		return 1;
-	}
-	return ADC_client_connect_internal(client);
 	}
 
-int ADC_client_connect_internal(struct ADC_client* client)
-{
-	int ret;
-	if (client->state == ps_dns)
-	{
-		// Done name resolving!
-		client->callback(client, ADC_CLIENT_CONNECTING, 0);
 	ADC_client_set_state(client, ps_conn);
-	}
+	client->connect_job = net_con_connect(client->address.hostname, client->address.port, connect_callback, client);
-
+	if (!client->connect_job)
-	ret = net_connect(net_con_get_sd(client->con), (struct sockaddr*) &client->addr, sizeof(struct sockaddr_in));
-	if (ret == 0 || (ret == -1 && net_error() == EISCONN))
-	{
-		ADC_client_on_connected(client);
-	}
-	else if (ret == -1 && (net_error() == EALREADY || net_error() == EINPROGRESS || net_error() == EWOULDBLOCK || net_error() == EINTR))
-	{
-		net_con_update(client->con, NET_EVENT_READ | NET_EVENT_WRITE);
-		ADC_client_set_state(client, ps_conn);
-	}
-	else
 	{
 		ADC_client_on_disconnected(client);
 		return 0;
@@ -611,6 +600,7 @@ int ADC_client_connect_internal(struct ADC_client* client)
 	return 1;
 }
 
+
 static void ADC_client_on_connected(struct ADC_client* client)
 {
 	ADC_TRACE;
@@ -674,43 +664,6 @@ void ADC_client_disconnect(struct ADC_client* client)
 	}
 }
 
-int ADC_client_dns_callback(struct net_dns_job* job, const struct net_dns_result* result)
-{
-	struct ADC_client* client = (struct ADC_client*) net_dns_job_get_ptr(job);
-	struct ip_addr_encap* ipaddr;
-	LOG_WARN("ADC_client_dns_callback(): result=%p (%d)", result, net_dns_result_size(result));
-
-	memset(&client->addr, 0, sizeof(client->addr));
-
-	ipaddr = net_dns_result_first(result);
-	switch (ipaddr->af)
-	{
-		case AF_INET:
-		{
-			struct sockaddr_in* addr4 = (struct sockaddr_in*) &client->addr;
-			addr4->sin_family = AF_INET;
-			addr4->sin_port = htons(client->address.port);
-			memcpy(&addr4->sin_addr, &ipaddr->internal_ip_data.in, sizeof(struct in_addr));
-			break;
-		}
-
-		case AF_INET6:
-		{
-			struct sockaddr_in6* addr6 = (struct sockaddr_in6*) &client->addr;
-			addr6->sin6_family = AF_INET6;
-			addr6->sin6_port = htons(client->address.port);
-			memcpy(&addr6->sin6_addr, &ipaddr->internal_ip_data.in6, sizeof(struct in6_addr));
-			break;
-		}
-
-		default:
-			LOG_WARN("Unknown ipaddr!");
-	}
-
-	ADC_client_connect_internal(client);
-	return 1;
-}
-
 static int ADC_client_parse_address(struct ADC_client* client, const char* arg)
 {
 	ADC_TRACE;
@@ -753,9 +706,6 @@ static int ADC_client_parse_address(struct ADC_client* client, const char* arg)
 
 	client->address.hostname = strndup(hub_address, &split[0] - &hub_address[0]);
 
-	client->callback(client, ADC_CLIENT_NAME_LOOKUP, 0);
-	ADC_client_set_state(client, ps_dns);
-	client->dns_job = net_dns_gethostbyname(client->address.hostname, AF_UNSPEC, ADC_client_dns_callback, client);
 	return 1;
 }
 

src/uhub.h

@@ -94,6 +94,7 @@ extern "C" {
 #include "core/commands.h"
 #include "core/inf.h"
 #include "core/hubevent.h"
+#include "core/link.h"
 #include "core/plugincallback.h"
 #include "core/plugininvoke.h"
 #include "core/pluginloader.h"

src/util/log.c

@@ -21,7 +21,15 @@
 #include <locale.h>
 
 #ifndef WIN32
+
+#ifdef SYSTEMD
+#define SD_JOURNAL_SUPPRESS_LOCATION
+#include <systemd/sd-journal.h>
+
+#else
 #include <syslog.h>
+#endif
+
 static int use_syslog = 0;
 #endif
 
@@ -83,7 +91,9 @@ void hub_log_initialize(const char* file, int syslog)
 	if (syslog)
 	{
 		use_syslog = 1;
+                #ifndef SYSTEMD
 		openlog("uhub", LOG_PID, LOG_USER);
+                #endif
 	}
 #endif
 
@@ -132,7 +142,9 @@ void hub_log_shutdown()
 	if (use_syslog)
 	{
 		use_syslog = 0;
+                #ifndef SYSTEMD
 		closelog();
+                #endif
 	}
 #endif
 }
@@ -212,7 +224,12 @@ void hub_log(int log_verbosity, const char *format, ...)
 			case log_fatal:    level = LOG_CRIT; break;
 			case log_error:    level = LOG_ERR; break;
 			case log_warning:  level = LOG_WARNING; break;
+                        #ifdef SYSTEMD
+                        case log_user:     level = LOG_INFO; break;
+
+                        #else
                         case log_user:     level = LOG_INFO | LOG_AUTH; break;
+                        #endif
 			case log_info:     level = LOG_INFO; break;
 			case log_debug:    level = LOG_DEBUG; break;
 			
@@ -224,8 +241,13 @@ void hub_log(int log_verbosity, const char *format, ...)
 		if (level == 0)
 			return;
 		
+                #ifdef SYSTEMD
+		sd_journal_print(level, "%s", logmsg);
+
+                #else
 		level |= (LOG_USER | LOG_DAEMON);
 		syslog(level, "%s", logmsg);
+                #endif
 	}
 #endif