kick off CI

If a TLS error occurs, it could end up in a situation where the network handler code did not want to
read or write because it only had the error flag set. However, this was not handled, which left the
socket triggering in the event loop - but nothing was done to handle it.

This can easily cause a 100% cpu situation - the hub is still functioning though while this is
happening.

.drone.yml

@@ -0,0 +1,17 @@
+kind: pipeline
+name: default
+
+steps:
+- name: docker
+  image: plugins/docker
+  network_mode: bridge
+  settings:
+    repo: sneak/uhub
+    username:
+      from_secret: docker_username
+    password:
+      from_secret: docker_password
+    tags:
+      - ${DRONE_BRANCH//\//-}-${DRONE_COMMIT_SHA:0:8}
+      - ${DRONE_COMMIT_SHA}
+      - ${DRONE_BRANCH/\//-}

.gitignore

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

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "thirdparty/sqlite"]
 	path = thirdparty/sqlite
-	url = git://github.com/janvidar/sqlite.git
+	url = https://github.com/janvidar/sqlite.git

.travis.yml

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

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
+MiMic, Implemented user commands, and plugins
-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

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,170 +1,246 @@
  ##
 ## 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.3)
+cmake_minimum_required (VERSION 2.8.2)
 
-project (uhub)
+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 "src")
+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(SQLITE_SUPPORT "Enable SQLite support" ON)
+option(USE_OPENSSL "Use OpenSSL's SSL 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)
+
+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)
-	find_package(OpenSSL REQUIRED)
+	if (USE_OPENSSL)
+		find_package(OpenSSL)
+	else()
+		find_package(GnuTLS)
+	endif()
+	if (NOT GNUTLS_FOUND AND NOT OPENSSL_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 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("${PROJECT_BINARY_DIR}")
+include_directories(${SQLITE3_INCLUDE_DIRS})
+link_directories(${SQLITE3_LIBRARY_DIRS})
 
-set (network_SOURCES
+file (GLOB uhub_SOURCES ${PROJECT_SOURCE_DIR}/core/*.c)
-	${PROJECT_SOURCE_DIR}/network/backend.c
+list (REMOVE_ITEM uhub_SOURCES
-	${PROJECT_SOURCE_DIR}/network/connection.c
+	${PROJECT_SOURCE_DIR}/core/gen_config.c
-	${PROJECT_SOURCE_DIR}/network/epoll.c
+	${PROJECT_SOURCE_DIR}/core/main.c
-	${PROJECT_SOURCE_DIR}/network/kqueue.c
-	${PROJECT_SOURCE_DIR}/network/select.c
-	${PROJECT_SOURCE_DIR}/network/timeout.c
-	${PROJECT_SOURCE_DIR}/network/timer.c
-	${PROJECT_SOURCE_DIR}/network/network.c
-	${PROJECT_SOURCE_DIR}/util/ipcalc.c
 )
 
-set (uhub_SOURCES
+file (GLOB adc_SOURCES ${PROJECT_SOURCE_DIR}/adc/*.c)
-	${PROJECT_SOURCE_DIR}/core/auth.c
+file (GLOB network_SOURCES ${PROJECT_SOURCE_DIR}/network/*.c)
-	${PROJECT_SOURCE_DIR}/core/command_parser.c
+file (GLOB utils_SOURCES ${PROJECT_SOURCE_DIR}/util/*.c)
-	${PROJECT_SOURCE_DIR}/core/commands.c
-	${PROJECT_SOURCE_DIR}/core/config.c
-	${PROJECT_SOURCE_DIR}/core/eventqueue.c
-	${PROJECT_SOURCE_DIR}/core/hub.c
-	${PROJECT_SOURCE_DIR}/core/hubevent.c
-	${PROJECT_SOURCE_DIR}/core/inf.c
-	${PROJECT_SOURCE_DIR}/core/ioqueue.c
-	${PROJECT_SOURCE_DIR}/core/netevent.c
-	${PROJECT_SOURCE_DIR}/core/probe.c
-	${PROJECT_SOURCE_DIR}/core/route.c
-	${PROJECT_SOURCE_DIR}/core/user.c
-	${PROJECT_SOURCE_DIR}/core/usermanager.c
-	${PROJECT_SOURCE_DIR}/core/plugincallback.c
-	${PROJECT_SOURCE_DIR}/core/plugininvoke.c
-	${PROJECT_SOURCE_DIR}/core/pluginloader.c
-)
-
-set (adc_SOURCES
-	${PROJECT_SOURCE_DIR}/adc/message.c
-	${PROJECT_SOURCE_DIR}/adc/sid.c
-)
-
-set (utils_SOURCES
-	${PROJECT_SOURCE_DIR}/util/cbuffer.c
-	${PROJECT_SOURCE_DIR}/util/config_token.c
-	${PROJECT_SOURCE_DIR}/util/credentials.c
-	${PROJECT_SOURCE_DIR}/util/floodctl.c
-	${PROJECT_SOURCE_DIR}/util/getopt.c
-	${PROJECT_SOURCE_DIR}/util/list.c
-	${PROJECT_SOURCE_DIR}/util/log.c
-	${PROJECT_SOURCE_DIR}/util/memory.c
-	${PROJECT_SOURCE_DIR}/util/misc.c
-	${PROJECT_SOURCE_DIR}/util/rbtree.c
-	${PROJECT_SOURCE_DIR}/util/tiger.c
-)
 
 set (adcclient_SOURCES
 	${PROJECT_SOURCE_DIR}/tools/adcclient.c
+	${PROJECT_SOURCE_DIR}/core/ioqueue.c
 )
 
 add_library(adc       STATIC ${adc_SOURCES})
 add_library(network   STATIC ${network_SOURCES})
 add_library(utils     STATIC ${utils_SOURCES})
-
+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()
 
 add_dependencies(adc utils)
 add_dependencies(network utils)
 
 add_executable(uhub ${PROJECT_SOURCE_DIR}/core/main.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 ${utils_SOURCES})
+add_library(mod_example MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_example.c)
-add_library(mod_welcome MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_welcome.c ${utils_SOURCES} ${network_SOURCES})
+add_library(mod_welcome MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_welcome.c)
-add_library(mod_logging MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_logging.c ${utils_SOURCES} ${PROJECT_SOURCE_DIR}/adc/sid.c ${network_SOURCES})
+add_library(mod_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 ${utils_SOURCES})
+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 ${utils_SOURCES})
+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 ${utils_SOURCES})
+add_library(mod_chat_history_sqlite MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_chat_history_sqlite.c )
-add_library(mod_topic MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_topic.c ${utils_SOURCES})
+add_library(mod_chat_only MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_chat_only.c)
-
+add_library(mod_topic MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_topic.c)
-if (SQLITE_SUPPORT)
+add_library(mod_no_guest_downloads MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_no_guest_downloads.c)
-	add_library(mod_auth_sqlite MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_auth_sqlite.c ${utils_SOURCES})
+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 ${PROJECT_SOURCE_DIR}/util/misc.c ${PROJECT_SOURCE_DIR}/util/memory.c ${PROJECT_SOURCE_DIR}/util/log.c ${PROJECT_SOURCE_DIR}/util/list.c)
-
-	target_link_libraries(mod_auth_sqlite sqlite3)
-	target_link_libraries(uhub-passwd sqlite3)
-	set_target_properties(mod_auth_sqlite PROPERTIES PREFIX "")
-endif()
-
-if(WIN32)
-	target_link_libraries(uhub ws2_32)
-	target_link_libraries(mod_logging ws2_32)
-	target_link_libraries(mod_welcome ws2_32)
-endif()
 
 set_target_properties(
 	mod_example
 	mod_welcome
 	mod_logging
 	mod_auth_simple
+	mod_auth_sqlite
 	mod_chat_history
+	mod_chat_history_sqlite
 	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(autotest-bin ${CMAKE_DL_LIBS} adc network utils)
+target_link_libraries(mod_example utils)
+target_link_libraries(mod_welcome network 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 network utils)
+target_link_libraries(mod_topic utils)
+target_link_libraries(utils network)
+
+if(WIN32)
+	target_link_libraries(uhub ws2_32)
+	target_link_libraries(autotest-bin ws2_32)
+	target_link_libraries(mod_logging ws2_32)
+	target_link_libraries(mod_welcome ws2_32)
+endif()
 
 if(UNIX)
 	add_library(adcclient STATIC ${adcclient_SOURCES})
-	add_executable(uhub-admin ${PROJECT_SOURCE_DIR}/tools/admin.c ${adcclient_SOURCES})
+	add_executable(uhub-admin ${PROJECT_SOURCE_DIR}/tools/admin.c)
-	target_link_libraries(uhub-admin adcclient adc network utils)
+	target_link_libraries(uhub-admin adcclient adc network utils pthread)
+	target_link_libraries(uhub pthread)
+	target_link_libraries(autotest-bin pthread)
+
+	if (ADC_STRESS)
+		add_executable(adcrush ${PROJECT_SOURCE_DIR}/tools/adcrush.c ${adcclient_SOURCES})
+		target_link_libraries(adcrush adcclient adc network utils pthread)
+	endif()
 endif()
 
-if(GIT_FOUND)
+if (NOT UHUB_REVISION AND GIT_FOUND)
-	execute_process(COMMAND ${GIT_EXECUTABLE} show -s --pretty=format:%h OUTPUT_VARIABLE UHUB_REVISION)
+	execute_process(COMMAND ${GIT_EXECUTABLE} show -s --pretty=format:%h
-	set (UHUB_GIT_VERSION "${UHUB_VERSION_MAJOR}.${UHUB_VERSION_MINOR}.${UHUB_VERSION_PATCH}-git-${UHUB_REVISION}")
+					WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-else()
+					OUTPUT_VARIABLE UHUB_REVISION_TEMP
+					OUTPUT_STRIP_TRAILING_WHITESPACE)
+	if (UHUB_REVISION_TEMP)
+		set (UHUB_REVISION "git-${UHUB_REVISION_TEMP}")
+	endif()
 endif()
 
+if (NOT UHUB_REVISION)
+	set (UHUB_REVISION "release")
+endif()
+
+set (UHUB_GIT_VERSION "${UHUB_VERSION_MAJOR}.${UHUB_VERSION_MINOR}.${UHUB_VERSION_PATCH}-${UHUB_REVISION}")
+message (STATUS "Configuring uhub version: ${UHUB_GIT_VERSION}")
+
 if(OPENSSL_FOUND)
-	add_definitions(-DSSL_SUPPORT=1)
+	set(SSL_LIBS ${OPENSSL_LIBRARIES})
+	add_definitions(-DSSL_SUPPORT=1 -DSSL_USE_OPENSSL=1)
 	include_directories(${OPENSSL_INCLUDE_DIR})
-	target_link_libraries(uhub ${OPENSSL_LIBRARIES})
+endif()
+
+if (GNUTLS_FOUND)
+	set(SSL_LIBS ${GNUTLS_LIBRARIES})
+	add_definitions(-DSSL_SUPPORT=1 -DSSL_USE_GNUTLS=1 ${GNUTLS_DEFINITIONS})
+	include_directories(${GNUTLS_INCLUDE_DIR})
+endif()
+
+if(SSL_SUPPORT)
+	target_link_libraries(uhub ${SSL_LIBS})
+	target_link_libraries(autotest-bin ${SSL_LIBS})
 	if(UNIX)
-		target_link_libraries(uhub-admin ${OPENSSL_LIBRARIES})
+		target_link_libraries(uhub-admin ${SSL_LIBS})
+	endif()
+	target_link_libraries(mod_welcome ${SSL_LIBS})
+	target_link_libraries(mod_logging ${SSL_LIBS})
+	if (ADC_STRESS)
+		target_link_libraries(adcrush ${SSL_LIBS})
 	endif()
-	target_link_libraries(mod_welcome ${OPENSSL_LIBRARIES})
-	target_link_libraries(mod_logging ${OPENSSL_LIBRARIES})
 endif()
 
-configure_file ("${PROJECT_SOURCE_DIR}/version.h.in" "${PROJECT_SOURCE_DIR}/version.h")
+if (SYSTEMD_SUPPORT)
+        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()
 
-mark_as_advanced(FORCE CMAKE_BUILD_TYPE)
+configure_file ("${PROJECT_SOURCE_DIR}/version.h.in" "${PROJECT_BINARY_DIR}/version.h")
-if (RELEASE)
+configure_file ("${PROJECT_SOURCE_DIR}/system.h.in" "${PROJECT_BINARY_DIR}/system.h")
-	set(CMAKE_BUILD_TYPE Release)
+
-else()
+# mark_as_advanced(FORCE CMAKE_BUILD_TYPE)
-	set(CMAKE_BUILD_TYPE Debug)
+# 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_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,38 @@
+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.
+- 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
@@ -12,8 +47,8 @@
 - marked plugin callbacks that are not called yet
 - add on_change_nick() to struct plugin_funcs
 - minimal changes
-- Updated init script in debian package.
+- Updated init script in Debian package.
-- Updated list of man pages in debian package.
+- Updated list of man pages in Debian package.
 - Added man page for uhub-passwd.
 - Merge branch 'master' of https://github.com/Tilka/uhub
 - Fix issue with QUI messages being allowed through the hub
@@ -43,7 +78,7 @@
 - minimal documentation fixes
 - update client software link
 - update compile howto link
-- fix debian changelog
+- fix Debian changelog
 - Fix bug #158 - Added plugin for setting topic (hub description).
 - Command arguments handling + cleanups
 

Dockerfile

@@ -0,0 +1,19 @@
+FROM alpine:latest as builder
+RUN apk update && apk upgrade && apk add --no-cache bash util-linux cmake make gcc git sqlite-dev openssl-dev git build-base
+WORKDIR /app
+COPY . .
+RUN cmake . && make
+RUN sed -i 's/\/usr\/lib\/uhub\//\/libs\//g' ./doc/*.conf && \
+sed -i 's/\/usr\/lib\/uhub\//\/libs\//g' ./doc/rules.txt && \
+sed -i 's/\/etc\/uhub\//\/conf\//g' ./doc/*.conf && \
+sed -i 's/\/etc\/uhub\//\/conf\//g' ./doc/rules.txt && \
+echo 'Welcome to uHub' > ./doc/motd.txt
+
+FROM alpine:latest
+RUN apk update && apk upgrade && apk add --no-cache bash util-linux openssl-dev sqlite-dev
+WORKDIR /app
+COPY --from=builder /app/uhub .
+COPY --from=builder /app/doc/plugins.conf /app/doc/uhub.conf /app/doc/users.conf /app/doc/rules.txt /app/doc/motd.txt /conf/
+COPY --from=builder /app/*.so /libs/
+ENTRYPOINT ["./uhub"]
+CMD ["-c","/conf/uhub.conf"]

README.md

@@ -1,8 +1,13 @@
+# uhub
+
 Welcome and thanks for downloading uHub, a high performance ADC p2p hub.
 
 For the official documentation, bugs and other information, please visit:
-http://www.uhub.org/
+https://www.uhub.org/
 
 For a list of compatible ADC clients, see:
-http://en.wikipedia.org/wiki/Advanced_Direct_Connect#Client_software
+https://en.wikipedia.org/wiki/Comparison_of_ADC_software#Client_software
 
+# on dockerhub
+
+* https://hub.docker.com/r/sneak/uhub

admin/make_pkg_deb.sh

@@ -78,7 +78,7 @@ Description: a high performance hub for the ADC peer-to-peer network
  Its low memory footprint allows it to handle several thousand users
  on high-end servers, or a small private hub on embedded hardware.
  .
-Homepage: http://www.extatic.org/uhub/
+Homepage: https://www.uhub.org/
 EOF
 cd ..
 

autotest/exotic

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

autotest/test_inf.tcc

@@ -12,11 +12,10 @@ extern int hub_handle_info_login(struct hub_info* hub, struct hub_user* user, st
 
 static void inf_create_hub()
 {
+	net_initialize();
 	inf_hub = (struct hub_info*) hub_malloc_zero(sizeof(struct hub_info));
-	inf_hub->users = (struct hub_user_manager*) hub_malloc_zero(sizeof(struct hub_user_manager));
-	inf_hub->users->list = list_create();
-	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));
 	
@@ -26,15 +25,13 @@ static void inf_create_hub()
 
 static void inf_destroy_hub()
 {
-	/* FIXME */
+	uman_shutdown(inf_hub->users);
-	list_destroy(inf_hub->users->list);
-	sid_pool_destroy(inf_hub->users->sids);
 	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);
+	net_destroy();
 }
 
 
@@ -63,13 +60,14 @@ EXO_TEST(inf_create_setup,
 
 /* FIXME: MEMORY LEAK - Need to fix hub_handle_info_login */
 #define CHECK_INF(MSG, EXPECT) \
-	struct adc_message* msg = adc_msg_parse_verify(inf_user, MSG, strlen(MSG)); \
+	do { \
-	int ok = hub_handle_info_login(inf_hub, inf_user, msg); /* FIXME: MEMORY LEAK */ \
+		struct adc_message* msg = adc_msg_parse_verify(inf_user, MSG, strlen(MSG)); \
-	adc_msg_free(msg); \
+		int ok = hub_handle_info_login(inf_hub, inf_user, msg); /* FIXME: MEMORY LEAK */ \
-	if (ok == EXPECT) \
+		adc_msg_free(msg); \
-		user_set_info(inf_user, 0); \
+		if (ok == EXPECT) \
-	return ok == EXPECT;
+			user_set_info(inf_user, 0); \
-	
+		return ok == EXPECT; \
+	} while(0)
 
 EXO_TEST(inf_ok_1,  { CHECK_INF("BINF AAAB NIFriend IDGNSSMURMD7K466NGZIHU65TP3S3UZSQ6MN5B2RI PD3A4545WFVGZLSGUXZLG7OS6ULQUVG3HM2T63I7Y\n", 0); });
 
@@ -107,12 +105,15 @@ EXO_TEST(inf_nick_08, { CHECK_INF("BINF AAAB NIa\\nc IDGNSSMURMD7K466NGZIHU65TP3
 EXO_TEST(inf_nick_09, { CHECK_INF("BINF AAAB NIabc NIdef IDGNSSMURMD7K466NGZIHU65TP3S3UZSQ6MN5B2RI PD3A4545WFVGZLSGUXZLG7OS6ULQUVG3HM2T63I7Y\n", status_msg_inf_error_nick_multiple); });
 EXO_TEST(inf_nick_10, {
 	const char* line = "BINF AAAB IDGNSSMURMD7K466NGZIHU65TP3S3UZSQ6MN5B2RI PD3A4545WFVGZLSGUXZLG7OS6ULQUVG3HM2T63I7Y\n";
+	int ok;
 	char nick[10];
+	struct adc_message* msg;
+
 	nick[0] = 0xf7; nick[1] = 0x80; nick[2] = 0x7f; nick[3] = 0x81; nick[4] = 0x98; nick[5] = 0x00;
-	struct adc_message* msg = adc_msg_parse_verify(inf_user, line, strlen(line));
+	msg = adc_msg_parse_verify(inf_user, line, strlen(line));
 	
 	adc_msg_add_named_argument(msg, "NI", nick);
-	int ok = hub_handle_info_login(inf_hub, inf_user, msg);
+	ok = hub_handle_info_login(inf_hub, inf_user, msg);
 	adc_msg_free(msg);
 	if (ok != status_msg_inf_error_nick_not_utf8)
 		printf("Expected %d, got %d\n", status_msg_inf_error_nick_not_utf8, ok);

autotest/test_ipfilter.tcc

@@ -429,44 +429,51 @@ EXO_TEST(check_ban_ipv4_5, {
 });
 
 EXO_TEST(check_ban_ipv6_1, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:0", &addr);
+	ip_convert_to_binary("2001::201:2ff:fefa:0", &addr);
 	return ip_in_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_ipv6_2, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:1", &addr);
+	ip_convert_to_binary("2001::201:2ff:fefa:1", &addr);
 	return ip_in_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_ipv6_3, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:fffe", &addr);
+	ip_convert_to_binary("2001::201:2ff:fefa:fffe", &addr);
 	return ip_in_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_ipv6_4, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:ffff", &addr);
+	ip_convert_to_binary("2001::201:2ff:fefa:ffff", &addr);
 	return ip_in_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_ipv6_5, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefb:0", &addr);
+	ip_convert_to_binary("2001::201:2ff:fefb:0", &addr);
 	return !ip_in_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_ipv6_6, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fef9:ffff", &addr);
+	ip_convert_to_binary("2001::201:2ff:fef9:ffff", &addr);
 	return !ip_in_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_afmix_1, {
+	struct ip_addr_encap addr;
 	if (!ipv6) return 1;
-	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fef9:ffff", &addr);
+	ip_convert_to_binary("2001::201:2ff:fef9:ffff", &addr);
 	return !ip_in_range(&addr, &ban4);
 });
 
@@ -610,8 +617,10 @@ EXO_TEST(ip_range_3, {
 });
 
 EXO_TEST(ip_range_4, {
-	struct ip_range range1; memset(&range1, 0, sizeof(range1));
+	struct ip_range range1;
-	struct ip_range range2; memset(&range2, 0, sizeof(range2));
+	struct ip_range range2;
+	memset(&range1, 0, sizeof(range1));
+	memset(&range2, 0, sizeof(range2));
 	return ip_convert_address_to_range("192.168.0.0/16", &range1) && ip_convert_address_to_range("192.168.0.0-192.168.255.255", &range2) && memcmp(&range1, &range2, sizeof(struct ip_range)) == 0;
 });
 

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_message.tcc

@@ -174,91 +174,102 @@ EXO_TEST(adc_message_parse_24, {
 
 
 EXO_TEST(adc_message_add_arg_1, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_add_argument(msg, "XXwtf?");
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat XXwtf?\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat XXwtf?\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_add_arg_2, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_add_named_argument(msg, "XX", "wtf?");
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat XXwtf?\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat XXwtf?\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_remove_arg_1, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "AA");
-	int ok = strcmp(msg->cache, "IINF BBbar CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF BBbar CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_remove_arg_2, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "BB");
-	int ok = strcmp(msg->cache, "IINF AAfoo CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_remove_arg_3, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "CC");
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_remove_arg_4, {
 	/* this ensures we can remove the last element also */
+	int ok;
 	struct adc_message* msg = adc_msg_parse_verify(g_user, test_string3, strlen(test_string3));
 	adc_msg_remove_named_argument(msg, "AW");
-	int ok = strcmp(msg->cache, "BINF AAAB IDAN7ZMSLIEBL53OPTM7WXGSTXUS3XOY6KQS5LBGX NIFriend DEstuff SL3 SS0 SF0 VEQuickDC/0.4.17 US6430 SUADC0,TCP4,UDP4 I4127.0.0.1 HO5 HN1\n") == 0;
+	ok = strcmp(msg->cache, "BINF AAAB IDAN7ZMSLIEBL53OPTM7WXGSTXUS3XOY6KQS5LBGX NIFriend DEstuff SL3 SS0 SF0 VEQuickDC/0.4.17 US6430 SUADC0,TCP4,UDP4 I4127.0.0.1 HO5 HN1\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_replace_arg_1, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "AA");
-	int ok = strcmp(msg->cache, "IINF BBbar CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF BBbar CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_replace_arg_2, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "BB");
-	int ok = strcmp(msg->cache, "IINF AAfoo CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_replace_arg_3, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_remove_named_argument(msg, "CC");
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_get_arg_1, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	char* c = adc_msg_get_argument(msg, 0);
-	int ok = strcmp(c, "AAfoo") == 0;
+	ok = strcmp(c, "AAfoo") == 0;
 	adc_msg_free(msg);
 	hub_free(c);
 	return ok;
 });
 
 EXO_TEST(adc_message_get_arg_2, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	char* c = adc_msg_get_argument(msg, 1);
-	int ok = strcmp(c, "BBbar") == 0;
+	ok = strcmp(c, "BBbar") == 0;
 	adc_msg_free(msg);
 	hub_free(c);
 	return ok;
@@ -340,28 +351,31 @@ EXO_TEST(adc_message_has_named_arg_3, {
 });
 
 EXO_TEST(adc_message_has_named_arg_4, {
+	int n;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_add_argument(msg, "XXwtf?");
-	int n = adc_msg_has_named_argument(msg, "XX");
+	n = adc_msg_has_named_argument(msg, "XX");
 	adc_msg_free(msg);
 	return n == 1;
 });
 
 EXO_TEST(adc_message_has_named_arg_5, {
+	int n;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_add_argument(msg, "XXone");
 	adc_msg_add_argument(msg, "XXtwo");
-	int n = adc_msg_has_named_argument(msg, "XX");
+	n = adc_msg_has_named_argument(msg, "XX");
 	adc_msg_free(msg);
 	return n == 2;
 });
 
 EXO_TEST(adc_message_has_named_arg_6, {
+	int n;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_add_argument(msg, "XXone");
 	adc_msg_add_argument(msg, "XXtwo");
 	adc_msg_add_argument(msg, "XXthree");
-	int n = adc_msg_has_named_argument(msg, "XX");
+	n = adc_msg_has_named_argument(msg, "XX");
 	adc_msg_free(msg);
 	return n == 3;
 });
@@ -374,63 +388,70 @@ EXO_TEST(adc_message_has_named_arg_7, {
 });
 
 EXO_TEST(adc_message_terminate_1, {
+	int ok;
 	struct adc_message* msg = adc_msg_create("IINF AAfoo BBbar CCwhat");
 	adc_msg_unterminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_terminate_2, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_unterminate(msg);
 	adc_msg_terminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_terminate_3, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_unterminate(msg);
 	adc_msg_terminate(msg);
 	adc_msg_unterminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_terminate_4, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_unterminate(msg);
 	adc_msg_terminate(msg);
 	adc_msg_terminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_terminate_5, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_terminate(msg);
 	adc_msg_terminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat\n") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_terminate_6, {
+	int ok;
 	struct adc_message* msg = adc_msg_create(test_string1);
 	adc_msg_unterminate(msg);
 	adc_msg_unterminate(msg);
-	int ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
+	ok = strcmp(msg->cache, "IINF AAfoo BBbar CCwhat") == 0;
 	adc_msg_free(msg);
 	return ok;
 });
 
 EXO_TEST(adc_message_escape_1, {
+	int ok;
 	char* s = adc_msg_escape(test_string1);
-	int ok = strcmp(s, "IINF\\sAAfoo\\sBBbar\\sCCwhat\\n") == 0;
+	ok = strcmp(s, "IINF\\sAAfoo\\sBBbar\\sCCwhat\\n") == 0;
 	hub_free(s);
 	return ok;
 });

autotest/test_misc.tcc

@@ -97,15 +97,82 @@ EXO_TEST(base32_invalid_31, { return !is_valid_base32_char('@'); });
 EXO_TEST(utf8_valid_1, { return is_valid_utf8("abcdefghijklmnopqrstuvwxyz"); });
 EXO_TEST(utf8_valid_2, { return is_valid_utf8("ABCDEFGHIJKLMNOPQRSTUVWXYZ"); });
 EXO_TEST(utf8_valid_3, { return is_valid_utf8("0123456789"); });
-EXO_TEST(utf8_valid_4, { return is_valid_utf8( (char[]) { 0x65, 0x00} ); });
-EXO_TEST(utf8_valid_5, { return !is_valid_utf8( (char[]) { 0xD8, 0x00} ); });
 
-EXO_TEST(utf8_valid_6, { return is_valid_utf8( (char[]) { 0x24, 0x00} ); });
+static const char test_utf_seq_1[] = { 0x65, 0x00 }; // valid
-EXO_TEST(utf8_valid_7, { return !is_valid_utf8( (char[]) { 0xC2, 0x24, 0x00} ); });
+static const char test_utf_seq_2[] = { 0xD8, 0x00 }; // invalid
-EXO_TEST(utf8_valid_8, { return is_valid_utf8( (char[]) { 0xC2, 0xA2, 0x00} ); });
+static const char test_utf_seq_3[] = { 0x24, 0x00 }; // valid
-EXO_TEST(utf8_valid_9, { return is_valid_utf8( (char[]) { 0xE2, 0x82, 0xAC, 0x00} ); });
+static const char test_utf_seq_4[] = { 0xC2, 0x24, 0x00}; // invalid
-EXO_TEST(utf8_valid_10, { return !is_valid_utf8( (char[]) { 0xC2, 0x32, 0x00} ); });
+static const char test_utf_seq_5[] = { 0xC2, 0xA2, 0x00}; // valid
-EXO_TEST(utf8_valid_11, { return !is_valid_utf8( (char[]) { 0xE2, 0x82, 0x32, 0x00} ); });
+static const char test_utf_seq_6[] = { 0xE2, 0x82, 0xAC, 0x00}; // valid
-EXO_TEST(utf8_valid_12, { return !is_valid_utf8( (char[]) { 0xE2, 0x32, 0x82, 0x00} ); });
+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); });
+EXO_TEST(utf8_valid_6, { return is_valid_utf8(test_utf_seq_3); });
+EXO_TEST(utf8_valid_7, { return !is_valid_utf8(test_utf_seq_4); });
+EXO_TEST(utf8_valid_8, { return is_valid_utf8(test_utf_seq_5); });
+EXO_TEST(utf8_valid_9, { return is_valid_utf8(test_utf_seq_6); });
+EXO_TEST(utf8_valid_10, { return !is_valid_utf8(test_utf_seq_7); });
+EXO_TEST(utf8_valid_11, { return !is_valid_utf8(test_utf_seq_8); });
+EXO_TEST(utf8_valid_12, { return !is_valid_utf8(test_utf_seq_9); });
+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

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

@@ -7,13 +7,15 @@
 static int match_str(const char* str1, char* str2)
 {
 	size_t i;
+	int ret;
+
 	for (i = 0; i < strlen(str2); i++)
 		if (str2[i] == '_')
 			str2[i] = ' ';
 		else if (str2[i] == '|')
 			str2[i] = '\t';
 
-	int ret = strcmp(str1, str2);
+	ret = strcmp(str1, str2);
 	if (ret) {
 		fprintf(stderr, "\n    Mismatch: \"%s\" != \"%s\"\n", str1, str2);
 	}
@@ -29,10 +31,11 @@ static int count(const char* STR, size_t EXPECT) {
 
 static int compare(const char* str, const char* ref) {
 	size_t i, max;
+	int pass;
 	struct linked_list* compare = list_create();
 	SETUP(tokens, str);
 	split_string(ref, " ", compare, 0);
-	int pass = cfg_token_count(tokens) == list_size(compare);
+	pass = cfg_token_count(tokens) == list_size(compare);
 	if (pass) {
 		max = cfg_token_count(tokens);
 		for (i = 0; i < max; i++) {

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
+

autotest/update.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+./exotic *.tcc > test.c
+

cmake/Modules/FindSqlite3.cmake

@@ -0,0 +1,78 @@
+# - 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 libraries 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/lib/${CMAKE_LIBRARY_ARCHITECTURE}
+		/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 )

debian/control

@@ -20,5 +20,5 @@ Description: High performance ADC p2p hub
   - Advanced access control support
   - Easy configuration
  .
-Homepage: http://www.uhub.org/
+Homepage: https://www.uhub.org/
 

debian/copyright

@@ -12,7 +12,7 @@ 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/>.
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 On Debian GNU/Linux systems, the complete text of the GNU General Public
 License can be found in `/usr/share/common-licenses/GPL'.

doc/architecture.txt

@@ -67,7 +67,7 @@ Accepting new users
  |            |                           |
  |            V                           |
  |  ---------------------         ---------------------
- |  |   Send password   | ------> | Reveive and check |
+ |  |   Send password   | ------> | Receive and check |
  |  | request, if needed|         | password.         |
  |  ---------------------         ---------------------
  |                                         |

doc/compile.txt

@@ -1,7 +1,7 @@
 How to compile:
 ---------------
 
-See the official compiling howto: http://www.uhub.org/compile.php
+See the official compiling howto: https://www.uhub.org/compile.php
 
 Prerequisites
 
@@ -12,7 +12,7 @@ Before you try to compile µHub, please make sure the following prerequisites ar
   * openssl > 0.9.8 (or use  "make USE_SSL=NO")
   * sqlite > 3.x
 
-or read  http://www.uhub.org/compile.php for more info.
+or read  https://www.uhub.org/compile.php for more info.
 
 
 Linux, Mac OSX, FreeBSD, NetBSD and OpenBSD

doc/extensions.txt

@@ -28,10 +28,10 @@ The UDP packet SHOULD be echoed by the hub.
 This UDP packet should contain simply 'HECH {cid} {token}' (Hub echo).
 
 The hub should send a packet containing the token back:
-'IECH {token} {host:port}', aswell as the same message via TCP.
+'IECH {token} {host:port}', as well as the same message via TCP.
 
 If the client receives the message via UDP, it should now be able to determine the type of NAT.
-If the client receives the message via TCP only it knows it has a firewall blocking incomming communication.
+If the client receives the message via TCP only it knows it has a firewall blocking incoming communication.
 If the client does not receive the message, it should assume a firewall is blocking all UDP communication,
 and resume in passive mode.
 

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,17 +43,25 @@ 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.
 
-In linux can add the following lines to /etc/security/limits.conf (allows for ~4000 users)
+In Linux can add the following lines to /etc/security/limits.conf (allows for ~4000 users)
       *     soft nofile 4096
       *     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/init.d.RedHat/etc/init.d/uhub

@@ -1,7 +1,7 @@
 #!/bin/sh
 #
 # chkconfig: - 91 35
-# description: Starts and stops the Uhub ( http://www.uhub.org ) daemons on RHEL\CentOS \
+# description: Starts and stops the Uhub ( https://www.uhub.org ) daemons on RHEL\CentOS \
 #	       used to provide p2p network services.
 #
 # pidfile: /var/run/uhub.pid

doc/plugins.conf

@@ -11,18 +11,28 @@
 # Parameters:
 # file: path/filename for database.
 #
-plugin /var/lib/uhub/mod_auth_sqlite.so "file=/etc/uhub/users.db"
+plugin /usr/lib/uhub/mod_auth_sqlite.so "file=/etc/uhub/users.db"
 
+# 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
 #
 # Parameters:
 # file: path/filename for log file.
 # syslog: if true then syslog is used instead of writing to a file (Unix only)
-plugin /var/lib/uhub/mod_logging.so "file=/var/log/uhub.log"
+plugin /usr/lib/uhub/mod_logging.so "file=/var/log/uhub.log"
 
 # A simple example plugin
-# plugin /var/lib/uhub/mod_example.so
+#plugin /usr/lib/uhub/mod_example.so
+
 # A plugin sending a welcome message.
 #
 # This plugin provides the following commands:
@@ -31,7 +41,7 @@ plugin /var/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.
 #
@@ -46,7 +56,7 @@ plugin /var/lib/uhub/mod_logging.so "file=/var/log/uhub.log"
 # %p - 'am' or 'pm'
 # %M - Minutes (00-59) (Hub local time)
 # %S - Seconds (00-60) (Hub local time)
-plugin /var/lib/uhub/mod_welcome.so "motd=/etc/uhub/motd.txt rules=/etc/uhub/rules.txt"
+plugin /usr/lib/uhub/mod_welcome.so "motd=/etc/uhub/motd.txt rules=/etc/uhub/rules.txt"
 
 # Load the chat history plugin.
 #
@@ -58,5 +68,4 @@ plugin /var/lib/uhub/mod_welcome.so "motd=/etc/uhub/motd.txt rules=/etc/uhub/rul
 # history_max:     the maximum number of messages to keep in history
 # history_default: when !history is provided without arguments, then this default number of messages are returned.
 # history_connect: the number of chat history messages to send when users connect (0 = do not send any history)
-plugin /var/lib/uhub/mod_chat_history.so "history_max=200 history_default=10 history_connect=5"
+plugin /usr/lib/uhub/mod_chat_history.so "history_max=200 history_default=10 history_connect=5"
-

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

@@ -2,10 +2,10 @@
 # You should normally place this file in /etc/uhub/uhub.conf
 # and customize some of the settings below.
 #
-# This file is read only to the uhub deamon, and if you
+# This file is read only to the uhub daemon, and if you
 # make changes to it while uhub is running you can send a
 # HUP signal to it ( $ killall -HUP uhub ), to reparse configuration (only on UNIX).
-# All configuration directives: http://www.uhub.org/config.php
+# All configuration directives: https://www.uhub.org/config.php
 
 # Bind to this port and address
 # server_bind_addr=any means listen to "::" if IPv6 is supported
@@ -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_low	       = User has too few upload slots
-msg_user_slots_high	       = User have too many 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.

doc/uhub.ebuild

@@ -4,7 +4,7 @@
 inherit eutils
 
 if [ "$PV" != "9999" ]; then
-        SRC_URI="http://www.extatic.org/downloads/uhub/${P}-src.tar.bz2"
+        SRC_URI="https://www.extatic.org/downloads/uhub/${P}-src.tar.bz2"
         KEYWORDS="~amd64 ~x86"
 else
         inherit git
@@ -16,7 +16,7 @@ fi
 EAPI="2"
 
 DESCRIPTION="High performance ADC hub"
-HOMEPAGE="http://www.uhub.org/"
+HOMEPAGE="https://www.uhub.org/"
 
 LICENSE="GPL-3"
 SLOT="0"

doc/uhub.spec

@@ -5,7 +5,7 @@ Release: 2
 License: GPLv3
 Group: Networking/File transfer
 Source: uhub-%{version}.tar.gz
-URL: http://www.uhub.org
+URL: https://www.uhub.org
 BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root
 
 BuildRequires: sqlite-devel
@@ -41,7 +41,7 @@ mkdir -p $RPM_BUILD_ROOT/etc/init.d
 mkdir -p $RPM_BUILD_ROOT/etc/logrotate.d
 mkdir -p $RPM_BUILD_ROOT/etc/sysconfig
 mkdir -p $RPM_BUILD_ROOT/usr/share/man/man1
-mkdir -p $RPM_BUILD_ROOT/var/lib/uhub
+mkdir -p $RPM_BUILD_ROOT/usr/lib/uhub
 
 install uhub $RPM_BUILD_ROOT/usr/bin/
 install uhub-passwd $RPM_BUILD_ROOT/usr/bin/
@@ -52,7 +52,7 @@ install -m644 doc/init.d.RedHat/etc/sysconfig/uhub  $RPM_BUILD_ROOT/etc/sysconfi
 install -m644 doc/init.d.RedHat/etc/logrotate.d/uhub $RPM_BUILD_ROOT/etc/logrotate.d/
 /bin/gzip -9c doc/uhub.1 > doc/uhub.1.gz &&
 install -m644 doc/uhub.1.gz $RPM_BUILD_ROOT/usr/share/man/man1
-install -m644 mod_*.so $RPM_BUILD_ROOT/var/lib/uhub
+install -m644 mod_*.so $RPM_BUILD_ROOT/usr/lib/uhub
 
 
 %files
@@ -80,7 +80,7 @@ rm -rf $RPM_BUILD_ROOT
 if [ $1 -gt 1 ] ; then
     /etc/rc.d/init.d/uhub restart >/dev/null || :
 fi
-# need more informations about add services and users in system
+# need more information about add services and users in system
 /usr/sbin/adduser -M -d /tmp -G nobody -s /sbin/nologin -c 'The Uhub ADC p2p hub Daemon' uhub >/dev/null 2>&1 ||:
 # write SSL create 
 echo "PLS see /usr/share/doc/uhub/"

doc/upstart/etc/init/uhub.conf

@@ -8,7 +8,7 @@ start on filesystem or runlevel [2345]
 stop on runlevel [!2345]
 
 # Allow the service to respawn, but if its happening too often
-# (10 times in 5 seconds) theres a problem and we should stop trying.
+# (10 times in 5 seconds) there's a problem and we should stop trying.
 respawn
 respawn limit 10 5
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -111,12 +111,15 @@ 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 */
-#define ADC_INF_FLAG_UPLOAD_SPEED       "US" /* maximum upload speed acheived in bytes/sec */
+#define ADC_INF_FLAG_UPLOAD_SPEED       "US" /* maximum upload speed achieved in bytes/sec */
-#define ADC_INF_FLAG_DOWNLOAD_SPEED     "DS" /* maximum download speed acheived in bytes/sec */
+#define ADC_INF_FLAG_DOWNLOAD_SPEED     "DS" /* maximum download speed achieved in bytes/sec */
 #define ADC_INF_FLAG_UPLOAD_SLOTS       "SL" /* maximum upload slots (concurrent uploads) */
 #define ADC_INF_FLAG_AUTO_SLOTS         "AS" /* automatic slot if upload speed is less than this in bytes/sec */
 #define ADC_INF_FLAG_AUTO_SLOTS_MAX     "AM" /* maximum number of automatic slots */
@@ -131,7 +134,7 @@ typedef uint32_t fourcc_t;
 #define ADC_MSG_FLAG_PRIVATE            "PM" /* message is a private message */
 
 #define ADC_SCH_FLAG_INCLUDE            "AN" /* include given search term */
-#define ADC_SCH_FLAG_EXCLUDE            "NO" /* exclude given serach term */
+#define ADC_SCH_FLAG_EXCLUDE            "NO" /* exclude given search term */
 #define ADC_SCH_FLAG_FILE_EXTENSION     "EX" /* search only for files with the given file extension */
 #define ADC_SCH_FLAG_FILE_TYPE          "TY" /* search only for files with this file type (separate type) */
 #define ADC_SCH_FLAG_LESS_THAN          "LE" /* search for files with this size or less */
@@ -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_BOT              "1"
-#define ADC_CLIENT_TYPE_REGISTERED_USER "2"
+#define ADC_CLIENT_TYPE_REGISTERED_USER  "2"
-#define ADC_CLIENT_TYPE_OPERATOR        "4"
+#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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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);
+		LIST_FOREACH(char*, tmp, cmd->feature_cast_include,
-		while (tmp)
 		{
 			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);
+		LIST_FOREACH(char*, tmp, cmd->feature_cast_exclude,
-		while (tmp)
 		{
 			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 */
 
@@ -532,9 +527,9 @@ struct adc_message* adc_msg_create(const char* line)
 	return adc_msg_parse(line, strlen(line));
 }
 
-extern struct adc_message* adc_msg_construct_source(fourcc_t fourcc, sid_t source, size_t size)
+struct adc_message* adc_msg_construct_source(fourcc_t fourcc, sid_t source, size_t size)
 {
-	struct adc_message* msg = adc_msg_construct(fourcc, size + 4);
+	struct adc_message* msg = adc_msg_construct(fourcc, size + 4 + 1);
 	if (!msg)
 		return NULL;
 
@@ -543,6 +538,20 @@ extern struct adc_message* adc_msg_construct_source(fourcc_t fourcc, sid_t sourc
 	return msg;
 }
 
+struct adc_message* adc_msg_construct_source_dest(fourcc_t fourcc, sid_t source, sid_t dest, size_t size)
+{
+	struct adc_message* msg = adc_msg_construct(fourcc, size + 4 + 4 + 1);
+	if (!msg)
+		return NULL;
+
+	adc_msg_add_argument(msg, sid_to_string(source));
+	adc_msg_add_argument(msg, sid_to_string(dest));
+	msg->source = source;
+	msg->target = dest;
+	return msg;
+}
+
+
 struct adc_message* adc_msg_construct(fourcc_t fourcc, size_t size)
 {
 	struct adc_message* msg = (struct adc_message*) msg_malloc_zero(sizeof(struct adc_message));
@@ -585,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]);
@@ -601,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++;
@@ -622,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;
 }
 
@@ -673,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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -51,7 +51,7 @@ enum msg_status_level
 extern struct adc_message* adc_msg_incref(struct adc_message* msg);
 
 /**
- * Decrease the reference counter, and free the memory when apropriate.
+ * Decrease the reference counter, and free the memory when appropriate.
  */
 extern void adc_msg_free(struct adc_message* msg);
 
@@ -96,6 +96,7 @@ extern struct adc_message* adc_msg_construct(fourcc_t fourcc, size_t size);
  * in addition pre-allocate 'size' bytes at the end of the message.
  */
 extern struct adc_message* adc_msg_construct_source(fourcc_t fourcc, sid_t source, size_t size);
+extern struct adc_message* adc_msg_construct_source_dest(fourcc_t fourcc, sid_t source, sid_t dest, size_t size);
 
 /**
  * Remove a named argument from the command.
@@ -158,7 +159,7 @@ extern char* adc_msg_get_argument(struct adc_message* cmd, int offset);
  *
  * @arg prefix a 2 character argument prefix
  * @arg string must be escaped (see adc_msg_escape).
- * @return  0 if successful, or -1 if an error occured.
+ * @return  0 if successful, or -1 if an error occurred.
  */
 extern int adc_msg_replace_named_argument(struct adc_message* cmd, const char prefix[2], const char* string);
 
@@ -166,7 +167,7 @@ extern int adc_msg_replace_named_argument(struct adc_message* cmd, const char pr
  * Append an argument
  *
  * @arg string must be escaped (see adc_msg_escape).
- * @return  0 if successful, or -1 if an error occured (out of memory).
+ * @return  0 if successful, or -1 if an error occurred (out of memory).
  */
 extern int adc_msg_add_argument(struct adc_message* cmd, const char* string);
 
@@ -175,7 +176,7 @@ extern int adc_msg_add_argument(struct adc_message* cmd, const char* string);
  *
  * @arg prefix a 2 character argument prefix
  * @arg string must be escaped (see adc_msg_escape).
- * @return  0 if successful, or -1 if an error occured (out of memory).
+ * @return  0 if successful, or -1 if an error occurred (out of memory).
  */
 extern int adc_msg_add_named_argument(struct adc_message* cmd, const char prefix[2], const char* string);
 
@@ -185,7 +186,7 @@ extern int adc_msg_add_named_argument(struct adc_message* cmd, const char prefix
  *
  * @arg prefix a 2 character argument prefix
  * @arg string must NOT be escaped
- * @return  0 if successful, or -1 if an error occured (out of memory).
+ * @return  0 if successful, or -1 if an error occurred (out of memory).
  */
 extern int adc_msg_add_named_argument_string(struct adc_message* cmd, const char prefix[2], const char* string);
 
@@ -228,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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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); \
+		LIST_FOREACH(char*, str, LIST, \
-		while (str) \
 		{ \
 			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);
-	
+	LIST_FOREACH(struct ip_range*, info, handle->networks,
-	while (info)
 	{
 		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);
-	
+	LIST_FOREACH(struct ip_range*, info, handle->nat_override,
-	while (info)
 	{
 		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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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))
+			LIST_FOREACH(char*, tmp, tokens, { size += (strlen(tmp) + 1); });
-				size += (strlen(tmp) + 1);
 			token = hub_malloc_zero(size);
 
 			while ((tmp = list_get_first(tokens)))
 			{
-				if (*token)
+				if (offset > 0)
-					strcat(token, " ");
+					token[offset++] = ' ';
-				strcat(token, tmp);
+				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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -30,7 +30,7 @@ struct command_base;
  *
  * @param cbase Command base pointer.
  * @param user User who invoked the command.
- * @param message The message that is to be interpreted as a command (including the invokation prefix '!' or '+')
+ * @param message The message that is to be interpreted as a command (including the invocation prefix '!' or '+')
  *
  * @return a hub_command that must be freed with command_free(). @See struct hub_command.
  */

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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);
+	LIST_FOREACH(struct hub_user*, u, users,
-	while (u)
 	{
 		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);
+	LIST_FOREACH(struct hub_user*, target, cbase->hub->users->list,
-	while (target)
 	{
 		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);
+	LIST_FOREACH(struct hub_logout_info*, log, messages,
-	while (log)
 	{
 		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)
 	{
@@ -557,14 +549,28 @@ static int command_stats(struct command_base* cbase, struct hub_user* user, stru
 {
 	struct cbuffer* buf = cbuf_create(128);
 	struct hub_info* hub = cbase->hub;
+	static char rxbuf[64] = { "0 B" };
+	static char txbuf[64] = { "0 B" };
+
+	cbuf_append(buf, "Hub statistics: ");
+	cbuf_append_format(buf, PRINTF_SIZE_T "/" PRINTF_SIZE_T " users (peak %d). ", hub->users->count, hub->config->max_users, hub->users->count_peak);
+
+	format_size(hub->stats.net_rx, rxbuf, sizeof(rxbuf));
+	format_size(hub->stats.net_tx, txbuf, sizeof(txbuf));
+
+	cbuf_append_format(buf, "Network: tx=%s/s, rx=%s/s", txbuf, rxbuf);
+
+#ifdef SHOW_PEAK_NET_STATS /* currently disabled */
+	format_size(hub->stats.net_rx_peak, rxbuf, sizeof(rxbuf));
+	format_size(hub->stats.net_tx_peak, txbuf, sizeof(txbuf));
+	cbuf_append_format(buf, ", peak_tx=%s/s, peak_rx=%s/s", txbuf, rxbuf);
+#endif
+
+	format_size(hub->stats.net_rx_total, rxbuf, sizeof(rxbuf));
+	format_size(hub->stats.net_tx_total, txbuf, sizeof(txbuf));
+	cbuf_append_format(buf, ", total_tx=%s", txbuf);
+	cbuf_append_format(buf, ", total_rx=%s", rxbuf);
 
-	cbuf_append_format(buf, PRINTF_SIZE_T " users, peak: " PRINTF_SIZE_T ". Network (up/down): %d/%d KB/s, peak: %d/%d KB/s",
-		hub->users->count,
-		hub->users->count_peak,
-		(int) hub->stats.net_tx / 1024,
-		(int) hub->stats.net_rx / 1024,
-		(int) hub->stats.net_tx_peak / 1024,
-		(int) hub->stats.net_rx_peak / 1024);
 	return command_status(cbase, user, cmd, buf);
 }
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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.
@@ -170,7 +170,7 @@
 		<check min="1024" max="1048576" />
 		<short>Max read buffer before parse, per user</short>
 		<description><![CDATA[
-			Maximum receive buffer allowed before commands are procesed. If a single ADC message exceeds this limit, it will be discarded by the hub. Use with caution.
+			Maximum receive buffer allowed before commands are processed. If a single ADC message exceeds this limit, it will be discarded by the hub. Use with caution.
 		]]></description>
 		<since>0.1.3</since>
 	</option>
@@ -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[
@@ -534,7 +567,7 @@
 	</option>
 
 	<option name="msg_inf_error_nick_taken" type="message" default="Nickname is already in use">
-		<description><![CDATA[This message will be sent to clients if their provided nickname is alredy in use on the hub.]]></description>
+		<description><![CDATA[This message will be sent to clients if their provided nickname is already in use on the hub.]]></description>
 		<since>0.2.0</since>
 	</option>
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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);
+	LIST_FOREACH(struct event_data*, data, queue->q1,
-	while (data)
 	{
 #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);
+	list_append_list(queue->q1, queue->q2);
-	while (data)
+
-	{
-		list_remove(queue->q2, data);
-		list_append(queue->q1, data);
-		data = (struct event_data*) list_get_first(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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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) \
 		{ \
@@ -600,6 +600,31 @@ static void hub_event_dispatcher(void* callback_data, struct event_data* message
 	}
 }
 
+
+static void hub_update_stats(struct hub_info* hub)
+{
+	const int factor = TIMEOUT_STATS;
+	struct net_statistics* total;
+	struct net_statistics* intermediate;
+	net_stats_get(&intermediate, &total);
+
+	hub->stats.net_tx = (intermediate->tx / factor);
+	hub->stats.net_rx = (intermediate->rx / factor);
+	hub->stats.net_tx_peak = MAX(hub->stats.net_tx, hub->stats.net_tx_peak);
+	hub->stats.net_rx_peak = MAX(hub->stats.net_rx, hub->stats.net_rx_peak);
+	hub->stats.net_tx_total = total->tx;
+	hub->stats.net_rx_total = total->rx;
+
+	net_stats_reset();
+}
+
+static void hub_timer_statistics(struct timeout_evt* t)
+{
+	struct hub_info* hub = (struct hub_info*) t->ptr;
+	hub_update_stats(hub);
+	timeout_queue_reschedule(net_backend_get_timeout_queue(), hub->stats.timeout, TIMEOUT_STATS);
+}
+
 static struct net_connection* start_listening_socket(const char* bind_addr, uint16_t port, int backlog, struct hub_info* hub)
 {
 	struct net_connection* server;
@@ -706,41 +731,29 @@ static int load_ssl_certificates(struct hub_info* hub, struct hub_config* config
 {
 	if (config->tls_enable)
 	{
-		hub->ssl_method = (SSL_METHOD*) SSLv23_method(); /* TLSv1_method() */
+		hub->ctx = net_ssl_context_create(config->tls_version, config->tls_ciphersuite);
-		hub->ssl_ctx = SSL_CTX_new(hub->ssl_method);
 
-		/* Disable SSLv2 */
+		if (!hub->ctx)
-		SSL_CTX_set_options(hub->ssl_ctx, SSL_OP_NO_SSLv2);
+		  return 0;
-		SSL_CTX_set_quiet_shutdown(hub->ssl_ctx, 1);
 
-		if (SSL_CTX_use_certificate_file(hub->ssl_ctx, config->tls_certificate, SSL_FILETYPE_PEM) < 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))
 		{
-			LOG_ERROR("SSL_CTX_use_certificate_file: %s", ERR_error_string(ERR_get_error(), NULL));
+			LOG_INFO("Enabling TLS (%s), using certificate: %s, private key: %s", net_ssl_get_provider(), config->tls_certificate, config->tls_private_key);
+			return 1;
 		}
-
+		return 0;
-		if (SSL_CTX_use_PrivateKey_file(hub->ssl_ctx, config->tls_private_key, SSL_FILETYPE_PEM) < 0)
-		{
-			LOG_ERROR("SSL_CTX_use_PrivateKey_file: %s", ERR_error_string(ERR_get_error(), NULL));
-		}
-
-		if (SSL_CTX_check_private_key(hub->ssl_ctx) != 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;
-		}
-		LOG_INFO("Enabling TLS, using certificate: %s, private key: %s", config->tls_certificate, config->tls_private_key);
 	}
 	return 1;
 }
 
 static void unload_ssl_certificates(struct hub_info* hub)
 {
-	if (hub->ssl_ctx)
+	if (hub->ctx)
-	{
+		net_ssl_context_destroy(hub->ctx);
-		SSL_CTX_free(hub->ssl_ctx);
-	}
 }
-#endif
+#endif /* SSL_SUPPORT */
 
 struct hub_info* hub_start_service(struct hub_config* config)
 {
@@ -816,6 +829,13 @@ struct hub_info* hub_start_service(struct hub_config* config)
 
 	g_hub = hub;
 
+	if (net_backend_get_timeout_queue())
+	{
+		hub->stats.timeout = hub_malloc_zero(sizeof(struct timeout_evt));
+		timeout_evt_initialize(hub->stats.timeout, hub_timer_statistics, hub);
+		timeout_queue_insert(net_backend_get_timeout_queue(), hub->stats.timeout, TIMEOUT_STATS);
+	}
+
 	// Start the hub command sub-system
 	hub->commands = command_initialize(hub);
 	return hub;
@@ -826,6 +846,12 @@ void hub_shutdown_service(struct hub_info* hub)
 {
 	LOG_DEBUG("hub_shutdown_service()");
 
+	if (net_backend_get_timeout_queue())
+	{
+		timeout_queue_remove(net_backend_get_timeout_queue(), hub->stats.timeout);
+		hub_free(hub->stats.timeout);
+	}
+
 #ifdef SSL_SUPPORT
 	unload_ssl_certificates(hub);
 #endif
@@ -883,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);
@@ -1298,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_first(hub->logout_info, hub_free);
-		list_remove(hub->logout_info, entry);
-		hub_free(entry);
 	}
 }
 

src/core/hub.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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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_low        = -44, /* User is on too few hubs. */
-	status_msg_user_hub_limit_high       = -45, /* Use is on too many 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 */
-	
+
 
 };
 
@@ -81,6 +81,7 @@ struct hub_stats
 	size_t net_rx_peak;
 	size_t net_tx_total;
 	size_t net_rx_total;
+	struct timeout_evt* timeout;    /**<< "Timeout handler for statistics" */
 };
 
 struct hub_logout_info
@@ -115,8 +116,7 @@ struct hub_info
 	struct uhub_plugins* plugins;        /* Plug-ins loaded for this hub instance. */
 
 #ifdef SSL_SUPPORT
-	SSL_METHOD* ssl_method;
+	struct ssl_context_handle* ctx;
-	SSL_CTX* ssl_ctx;
 #endif /*  SSL_SUPPORT */
 };
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -88,7 +88,7 @@ static int check_hash_tiger(const char* cid, const char* pid)
 
 
 /*
- * FIXME: Only works for tiger hash. If a client doesnt support tiger we cannot let it in!
+ * FIXME: Only works for tiger hash. If a client doesn't support tiger we cannot let it in!
  */
 static int check_cid(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
 {
@@ -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,19 +327,29 @@ 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)
 		{
-			LOG_DEBUG("check_logged_in: exact same user is logged in: %s", user->id.nick);
+			if (user_flag_get(lookup1, flag_choke))
-			hub_disconnect_user(hub, lookup1, quit_ghost_timeout);
+			{
-			return 0;
+				LOG_DEBUG("check_logged_in: exact same user is already logged in, but likely ghost: %s", user->id.nick);
+
+				// Old user unable to swallow data.
+				// Disconnect the existing user, and allow new user to enter.
+				hub_disconnect_user(hub, lookup1, quit_ghost_timeout);
+			}
+			else
+			{
+				LOG_DEBUG("check_logged_in: exact same user is already logged in: %s", user->id.nick);
+				return status_msg_inf_error_cid_taken;
+			}
 		}
 		else
 		{
@@ -366,21 +376,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_name_encoded = 0;
-	char* ua = 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);
+	ua_name_encoded = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_USER_AGENT_PRODUCT);
-	if (ua_encoded)
+	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);
+		str = adc_msg_unescape(ua_name_encoded);
-		if (ua)
+		if (str)
 		{
-			memcpy(user->id.user_agent, ua, MIN(strlen(ua), MAX_UA_LEN));
+			offset = strlen(str);
-			hub_free(ua);
+			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 +417,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 +427,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 +496,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 +560,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 +576,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 +596,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 +616,7 @@ static int set_credentials(struct hub_info* hub, struct hub_user* user, struct a
 		case auth_cred_link:
 			break;
  	}
-	
+
 	return ret;
 }
 
@@ -611,10 +649,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 +660,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 +674,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 +719,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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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);
@@ -141,13 +141,13 @@ void ioq_send_remove(struct ioq_send* q, struct adc_message* msg)
 	q->offset = 0;
 }
 
-int ioq_send_send(struct ioq_send* q, struct hub_user* user)
+int ioq_send_send(struct ioq_send* q, struct net_connection* con)
 {
 	int ret;
 	struct adc_message* msg = list_get_first(q->queue);
 	if (!msg) return 0;
 	uhub_assert(msg->cache && *msg->cache);
-	ret = net_con_send(user->connection, msg->cache + q->offset, msg->length - q->offset);
+	ret = net_con_send(con, msg->cache + q->offset, msg->length - q->offset);
 
 	if (ret > 0)
 	{

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -60,7 +60,7 @@ extern void ioq_send_add(struct ioq_send*, struct adc_message* msg);
  * Process the send queue, and send as many messages as possible.
  * @returns -1 on error, 0 if unable to send more, 1 if more can be sent.
  */
-extern int  ioq_send_send(struct ioq_send*, struct hub_user*);
+extern int  ioq_send_send(struct ioq_send*, struct net_connection* con);
 
 /**
  * @returns 1 if send queue is empty, 0 otherwise.

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
@@ -13,12 +13,16 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 #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;
@@ -83,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)
@@ -120,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;
 
@@ -136,10 +140,25 @@ int main_loop()
 		{
 			hub = hub_start_service(&configuration);
 			if (!hub)
+			{
+				acl_shutdown(&acl);
+				free_config(&configuration);
+				net_destroy();
+				hub_log_shutdown();
 				return -1;
+			}
 #if !defined(WIN32)
 			setup_signal_handlers(hub);
-#endif
+#ifdef SYSTEMD
+                        /* Notify the service manager that this daemon has
+                         * been successfully initialized 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);
@@ -155,7 +174,7 @@ int main_loop()
 #if !defined(WIN32)
 	shutdown_signal_handlers(hub);
 #endif
-	
+
 	if (hub)
 	{
 		hub_shutdown_service(hub);
@@ -210,13 +229,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"
@@ -265,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;
@@ -274,7 +297,7 @@ void parse_command_line(int argc, char** argv)
 			case 'l':
 				arg_log = optarg;
 				break;
-				
+
 			case 'L':
 				arg_log_syslog = 1;
 				break;
@@ -448,7 +471,7 @@ int main(int argc, char** argv)
 		}
 		else if (ret == 0)
 		{
-			/* child process - detatch from TTY */
+			/* child process - detach from TTY */
 			fclose(stdin);
 			fclose(stdout);
 			fclose(stderr);

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -55,7 +55,7 @@ int handle_net_read(struct hub_user* user)
 
 		while ((pos = memchr(start, '\n', remaining)))
 		{
-			lastPos = pos;
+			lastPos = pos+1;
 			pos[0] = '\0';
 
 #ifdef DEBUG_SENDQ
@@ -109,7 +109,7 @@ int handle_net_write(struct hub_user* user)
 	int ret = 0;
 	while (ioq_send_get_bytes(user->send_queue))
 	{
-		ret = ioq_send_send(user->send_queue, user);
+		ret = ioq_send_send(user->send_queue, user->connection);
 		if (ret <= 0)
 			break;
 	}
@@ -137,6 +137,12 @@ void net_event(struct net_connection* con, int event, void *arg)
 	LOG_TRACE("net_event() : fd=%d, ev=%d, arg=%p", con->sd, (int) event, arg);
 #endif
 
+	if (event == NET_EVENT_ERROR)
+	{
+		hub_disconnect_user(user->hub, user, quit_socket_error);
+		return;
+	}
+
 	if (event == NET_EVENT_TIMEOUT)
 	{
 		if (user_is_connecting(user))

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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);
+	LIST_FOREACH(struct plugin_command_handle*, cmdh, data->commands,
-	while (cmdh)
 	{
 		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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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); \
+		struct plugin_handle* plugin;\
-		while (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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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);
+	list_clear(handle->loaded, plugin_unload_ptr);
-	while (plugin)
-	{
-		list_remove(handle->loaded, plugin);
-		plugin_unload(plugin);
-		plugin = (struct plugin_handle*) list_get_first(handle->loaded);
-	}
-
 	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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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])
@@ -81,11 +90,14 @@ static void probe_net_event(struct net_connection* con, int events, void *arg)
 				if (probe->hub->config->tls_enable)
 				{
 					LOG_TRACE("Probed TLS %d.%d connection", (int) probe_recvbuf[9], (int) probe_recvbuf[10]);
-					if (user_create(probe->hub, probe->connection, &probe->addr))
+					if (net_con_ssl_handshake(con, net_con_ssl_mode_server, probe->hub->ctx) < 0)
+					{
+						LOG_TRACE("TLS handshake negotiation failed.");
+					}
+					else if (user_create(probe->hub, probe->connection, &probe->addr))
 					{
 						probe->connection = 0;
 					}
-					net_con_ssl_handshake(con, net_con_ssl_mode_server, probe->hub->ssl_ctx);
 				}
 				else
 				{

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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;
@@ -82,16 +82,19 @@ static int check_send_queue(struct hub_info* hub, struct hub_user* user, struct
 
 	if ((user->send_queue->size + msg->length) > get_max_send_queue(hub))
 	{
+		user_flag_set(user, flag_choke);
 		LOG_WARN("send queue overflowed, message discarded.");
 		return -1;
 	}
 
 	if (user->send_queue->size > get_max_send_queue_soft(hub))
 	{
+		user_flag_set(user, flag_choke);
 		LOG_WARN("send queue soft overflowed.");
 		return 0;
 	}
 
+	user_flag_unset(user, flag_choke);
 	return 1;
 }
 
@@ -139,12 +142,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);
+	struct hub_user* user;
-	while (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 +155,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);
+	struct hub_user* user;
-	while (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);
+			LIST_FOREACH(char*, tmp, command->feature_cast_include,
-			while (tmp)
 			{
 				if (!user_have_feature_cast_support(user, tmp))
 				{
 					do_send = 0;
 					break;
 				}
-				tmp = list_get_next(command->feature_cast_include);;
+			});
-			}
+
-			
+			if (!do_send)
-			if (!do_send) {
-				user = (struct hub_user*) list_get_next(hub->users->list);
 				continue;
-			}
+
-			
+			LIST_FOREACH(char*, tmp, command->feature_cast_exclude,
-			tmp = list_get_first(command->feature_cast_exclude);
-			while (tmp)
 			{
 				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 +203,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);
+		LIST_FOREACH(struct hub_user*, user, hub->users->list,
-		while (user)
 		{
 			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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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);
+	char* tmp;
-	while (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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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) */
@@ -68,7 +68,7 @@ enum user_quit_reason
 	quit_timeout        = 4,     /** User timed out (no data for a while) */
 	quit_send_queue     = 5,     /** User's send queue was overflowed */
 	quit_memory_error   = 6,     /** Not enough memory available */
-	quit_socket_error   = 7,     /** A socket error occured */
+	quit_socket_error   = 7,     /** A socket error occurred */
 	quit_protocol_error = 8,     /** Fatal protocol error */
 	quit_logon_error    = 9,     /** Unable to login (wrong password, CID/PID, etc) */
 	quit_update_error   = 10,    /** Update error. INF update changed share/slot info and no longer satisfies the hub limits. */
@@ -76,7 +76,7 @@ enum user_quit_reason
 	quit_ghost_timeout  = 12,    /** The user is a ghost, and trying to login from another connection */
 };
 
-/** Returns an apropriate string for the given quit reason */
+/** Returns an appropriate string for the given quit reason */
 extern const char* user_get_quit_reason_string(enum user_quit_reason);
 
 struct hub_user_info
@@ -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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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,42 +38,11 @@ static void clear_user_list_callback(void* ptr)
 	}
 }
 
-#ifdef STATS_SUPPORT
+static int uman_map_compare(const void* a, const void* b)
-void uman_update_stats(struct hub_user_manager* users)
 {
-	const int factor = TIMEOUT_STATS;
+	return strcmp((const char*) a, (const char*) b);
-	struct net_statistics* total;
-	struct net_statistics* intermediate;
-	net_stats_get(&intermediate, &total);
-
-	users->stats.net_tx = (intermediate->tx / factor);
-	users->stats.net_rx = (intermediate->rx / factor);
-	users->stats.net_tx_peak = MAX(users->stats.net_tx, users->stats.net_tx_peak);
-	users->stats.net_rx_peak = MAX(users->stats.net_rx, users->stats.net_rx_peak);
-	users->stats.net_tx_total = total->tx;
-	users->stats.net_rx_total = total->rx;
-	
-	net_stats_reset();
 }
 
-void uman_print_stats(struct hub_user_manager* users)
-{
-	LOG_INFO("Statistics  users=" PRINTF_SIZE_T " (peak_users=" PRINTF_SIZE_T "), net_tx=%d KB/s, net_rx=%d KB/s (peak_tx=%d KB/s, peak_rx=%d KB/s)",
-		users->users->count,
-		users->users->count_peak,
-		(int) users->stats.net_tx / 1024,
-		(int) users->stats.net_rx / 1024,
-		(int) users->stats.net_tx_peak / 1024,
-		(int) users->stats.net_rx_peak / 1024);
-}
-
-static void timer_statistics(struct timeout_evt* t)
-{
-	struct hub_user_manager* users = (struct hub_user_manager*) t->ptr;
-	uman_update_stats(users);
-	timeout_queue_reschedule(net_backend_get_timeout_queue(), users->timeout, TIMEOUT_STATS);
-}
-#endif // STATS_SUPPORT
 
 struct hub_user_manager* uman_init()
 {
@@ -82,24 +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;
-	}
-
-#ifdef STATS_SUPPORT
-	if (net_backend_get_timeout_queue())
-	{
-		users->timeout = hub_malloc_zero(sizeof(struct timeout_evt));
-		timeout_evt_initialize(users->timeout, timer_statistics, hub);
-		timeout_queue_insert(net_backend_get_timeout_queue(), users->timeout, TIMEOUT_STATS);
-	}
-#endif // STATS_SUPPORT
-
 	return users;
 }
 
@@ -109,19 +64,18 @@ int uman_shutdown(struct hub_user_manager* users)
 	if (!users)
 		return -1;
 
-#ifdef STATS_SUPPORT
+	if (users->nickmap)
-	if (net_backend_get_timeout_queue())
+		rb_tree_destroy(users->nickmap);
-	{
+
-		timeout_queue_remove(net_backend_get_timeout_queue(), users->timeout);
+	if (users->cidmap)
-		hub_free(users->timeout);
+		rb_tree_destroy(users->cidmap);
-	}
-#endif
 
 	if (users->list)
 	{
 		list_clear(users->list, &clear_user_list_callback);
 		list_destroy(users->list);
 	}
+
 	sid_pool_destroy(users->sids);
 
 	hub_free(users);
@@ -134,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);
@@ -149,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)
 	{
@@ -173,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 */
+	struct hub_user* user = (struct hub_user*) rb_tree_get(users->cidmap, (const void*) cid);
-	while (user)
+	return user;
-	{
-		if (strcmp(user->id.cid, cid) == 0)
-			return user;
-		user = (struct hub_user*) list_get_next(users->list);
-	}
-	return NULL;
 }
 
 
 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 */
+	struct hub_user* user = (struct hub_user*) rb_tree_get(users->nickmap, nick);
-	while (user)
+	return user;
-	{
-		if (strcmp(user->id.nick, nick) == 0)
-			return user;
-		user = (struct hub_user*) list_get_next(users->list);
-	}
-	return NULL;
 }
 
 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 */
+	struct hub_user* user;
-	while (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;
 }
 
@@ -217,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))
 		{
@@ -226,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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -24,13 +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" */
-#ifdef STATS_SUPPORT
+	struct rb_tree* nickmap;        /**<< "Maps nicknames to users (red black tree)" */
-	struct timeout_evt* timeout;    /**<< "Timeout handler for statistics" */
+	struct rb_tree* cidmap;         /**<< "Maps CIDs to users (red black tree)" */
-#endif
 };
 
 /**
@@ -43,7 +42,7 @@ extern struct hub_user_manager* uman_init();
  * Shuts down the user manager.
  * All users will be disconnected and deleted as part of this.
  *
- * @return 0 on success, or -1 in an error occured (invalid pointer).
+ * @return 0 on success, or -1 in an error occurred (invalid pointer).
  */
 extern int uman_shutdown(struct hub_user_manager* users);
 
@@ -80,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 ?
@@ -107,7 +106,7 @@ extern struct hub_user* uman_get_user_by_nick(struct hub_user_manager* users, co
  *
  * @param[out] target the list of users matching the address
  * @param range the IP range of users to match
- * @return The number of users matching the addressess, or -1 on error (mask is wrong).
+ * @return The number of users matching the addresses, or -1 on error (mask is wrong).
  */
 extern size_t uman_get_user_by_addr(struct hub_user_manager* users, struct linked_list* target, struct ip_range* range);
 

src/network/backend.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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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)
+void net_backend_update(struct net_connection* con, int events)
-{
-	con->callback = callback;
-	con->ptr = (void*) ptr;
-	net_con_update(con, events);
-}
-
-void net_con_update(struct net_connection* con, int events)
 {
 	g_backend->handler.con_mod(g_backend->data, con, events);
 }
@@ -132,10 +125,11 @@ 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);
 
-	res = g_backend->handler.backend_poll(g_backend->data, secs * 1000);
+	if (g_backend->common.num)
+		res = g_backend->handler.backend_poll(g_backend->data, secs * 1000);
 
 	g_backend->now = time(0);
 	timeout_queue_process(&g_backend->timeout_queue, g_backend->now);
@@ -146,6 +140,9 @@ int net_backend_process()
 		return 0;
 	}
 
+	// Process pending DNS results
+	// net_dns_process();
+
 	g_backend->handler.backend_process(g_backend->data, res);
 
 	net_cleanup_process(g_backend->cleaner);
@@ -162,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_nonblocking(net_con_get_sd(con), 1);
-	net_set_nosigpipe(con->sd, 1);
+	net_set_nosigpipe(net_con_get_sd(con), 1);
 
 	g_backend->handler.con_add(g_backend->data, con, events);
 	g_backend->common.num++;
@@ -181,11 +178,8 @@ void net_con_close(struct net_connection* con)
 
 #ifdef SSL_SUPPORT
 	if (con->ssl)
-	{
+		net_ssl_shutdown(con);
-		SSL_shutdown(con->ssl);
+#endif /* SSL_SUPPORT */
-		SSL_clear(con->ssl);
-	}
-#endif
 
 	net_close(con->sd);
 	con->sd = -1;

src/network/backend.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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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-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
@@ -13,18 +13,17 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 #define NET_WANT_READ             NET_EVENT_READ
 #define NET_WANT_WRITE            NET_EVENT_WRITE
 #define NET_WANT_ACCEPT           NET_EVENT_READ
-#define NET_WANT_SSL_READ         0x0010
+
-#define NET_WANT_SSL_WRITE        0x0020
+#define NET_SSL_ANY NET_WANT_SSL_READ | NET_WANT_SSL_WRITE | NET_WANT_SSL_ACCEPT | NET_WANT_SSL_CONNECT | NET_WANT_SSL_X509_LOOKUP
-#define NET_WANT_SSL_ACCEPT       0x0040
+
-#define NET_WANT_SSL_CONNECT      0x0080
+struct ssl_handle; /* abstract type */
-#define NET_WANT_SSL_X509_LOOKUP  0x0100
 
 #define NET_CLEANUP               0x8000
 
@@ -36,9 +35,7 @@
 	struct timeout_evt*  timeout;   /** timeout event handler */
 
 #define NET_CON_STRUCT_SSL \
-	SSL*                 ssl;       /** SSL handle */ \
+	struct ssl_handle* ssl;         /** SSL handle */
-	uint32_t             ssl_state; /** SSL state */ \
-	size_t               write_len; /** Length of last SSL_write(), only used if flags is NET_WANT_SSL_READ. */ \
 
 #ifdef SSL_SUPPORT
 #define NET_CON_STRUCT_COMMON \

src/network/connection.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
@@ -13,139 +13,26 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 #include "uhub.h"
 #include "network/common.h"
+#include "network/backend.h"
 
-#ifdef SSL_SUPPORT
+static int is_blocked_or_interrupted()
-
-enum uhub_tls_state
 {
-	tls_st_none,
+	int err = net_error();
-	tls_st_error,
+	return
-	tls_st_accepting,
+#ifdef WINSOCK
-	tls_st_connecting,
+				err == WSAEWOULDBLOCK
-	tls_st_connected,
+#else
-	tls_st_disconnecting,
+				err == EWOULDBLOCK
-};
-
-static int handle_openssl_error(struct net_connection* con, int ret)
-{
-	uhub_assert(con);
-
-	int error = SSL_get_error(con->ssl, ret);
-	switch (error)
-	{
-		case SSL_ERROR_ZERO_RETURN:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_ZERO_RETURN", ret, error);
-			con->ssl_state = tls_st_error;
-			return -1;
-
-		case SSL_ERROR_WANT_READ:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_WANT_READ", ret, error);
-			con->flags |= NET_WANT_SSL_READ;
-			net_con_update(con, NET_EVENT_READ);
-			return 0;
-
-		case SSL_ERROR_WANT_WRITE:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_WANT_WRITE", ret, error);
-			con->flags |= NET_WANT_SSL_WRITE;
-			net_con_update(con, NET_EVENT_READ | NET_EVENT_WRITE);
-			return 0;
-
-		case SSL_ERROR_SYSCALL:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_SYSCALL", ret, error);
-			/* if ret == 0, connection closed, if ret == -1, check with errno */
-			if (ret == 0)
-				return -1;
-			else
-				return -net_error();
-
-		case SSL_ERROR_SSL:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_SSL", ret, error);
-			/* internal openssl error */
-			con->ssl_state = tls_st_error;
-			return -1;
-	}
-	return -1;
-}
-
-ssize_t net_con_ssl_accept(struct net_connection* con)
-{
-	uhub_assert(con);
-	con->ssl_state = tls_st_accepting;
-	ssize_t ret = SSL_accept(con->ssl);
-#ifdef NETWORK_DUMP_DEBUG
-	LOG_PROTO("SSL_accept() ret=%d", ret);
 #endif
-	if (ret > 0)
+				|| err == EINTR;
-	{
-		net_con_update(con, NET_EVENT_READ);
-		con->ssl_state = tls_st_connected;
-	}
-	else
-	{
-		return handle_openssl_error(con, ret);
-	}
-	return ret;
 }
 
-ssize_t net_con_ssl_connect(struct net_connection* con)
-{
-	uhub_assert(con);
-
-	con->ssl_state = tls_st_connecting;
-	ssize_t ret = SSL_connect(con->ssl);
-#ifdef NETWORK_DUMP_DEBUG
-	LOG_PROTO("SSL_connect() ret=%d", ret);
-#endif
-	if (ret > 0)
-	{
-		con->ssl_state = tls_st_connected;
-		net_con_update(con, NET_EVENT_READ);
-	}
-	else
-	{
-		return handle_openssl_error(con, ret);
-	}
-	return ret;
-}
-
-ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode ssl_mode, SSL_CTX* ssl_ctx)
-{
-	uhub_assert(con);
-	SSL* ssl = 0;
-
-	if (ssl_mode == net_con_ssl_mode_server)
-	{
-		ssl = SSL_new(ssl_ctx);
-		if (!ssl)
-		{
-			LOG_ERROR("Unable to create new SSL stream\n");
-			return -1;
-		}
-		SSL_set_fd(ssl, con->sd);
-		net_con_set_ssl(con, ssl);
-		return net_con_ssl_accept(con);
-	}
-	else
-	{
-		ssl = SSL_new(SSL_CTX_new(TLSv1_method()));
-		SSL_set_fd(ssl, con->sd);
-		net_con_set_ssl(con, ssl);
-		return net_con_ssl_connect(con);
-	}
-}
-#endif /* SSL_SUPPORT */
-
-#ifdef SSL_SUPPORT
-void net_stats_add_tx(size_t bytes);
-void net_stats_add_rx(size_t bytes);
-#endif
-
 ssize_t net_con_send(struct net_connection* con, const void* buf, size_t len)
 {
 	int ret;
@@ -156,13 +43,7 @@ ssize_t net_con_send(struct net_connection* con, const void* buf, size_t len)
 		ret = net_send(con->sd, buf, len, UHUB_SEND_SIGNAL);
 		if (ret == -1)
 		{
-			if (
+			if (is_blocked_or_interrupted())
-#ifdef WINSOCK
-				net_error() == WSAEWOULDBLOCK
-#else
-				net_error() == EWOULDBLOCK 
-#endif
-				|| net_error() == EINTR)
 				return 0;
 			return -1;
 		}
@@ -170,19 +51,9 @@ ssize_t net_con_send(struct net_connection* con, const void* buf, size_t len)
 	}
 	else
 	{
-		con->write_len = len;
+		ret = net_ssl_send(con, buf, len);
-		ret = SSL_write(con->ssl, buf, len);
-		LOG_PROTO("SSL_write(con=%p, buf=%p, len=" PRINTF_SIZE_T ") => %d", con, buf, len, ret);
-		if (ret <= 0)
-		{
-			return handle_openssl_error(con, ret);
-		}
-		else
-		{
-			 net_stats_add_tx(ret);
-		}
 	}
-#endif
+#endif /* SSL_SUPPORT */
 	return ret;
 }
 
@@ -190,19 +61,13 @@ ssize_t net_con_recv(struct net_connection* con, void* buf, size_t len)
 {
 	int ret;
 #ifdef SSL_SUPPORT
-	if (!net_con_is_ssl(con))
+	if (!con->ssl)
 	{
 #endif
 		ret = net_recv(con->sd, buf, len, 0);
 		if (ret == -1)
 		{
-			if (
+			if (is_blocked_or_interrupted())
-#ifdef WINSOCK
-				net_error() == WSAEWOULDBLOCK
-#else
-				net_error() == EWOULDBLOCK
-#endif
-				|| net_error() == EINTR)
 				return 0;
 			return -net_error();
 		}
@@ -214,22 +79,9 @@ ssize_t net_con_recv(struct net_connection* con, void* buf, size_t len)
 	}
 	else
 	{
-		if (con->ssl_state == tls_st_error)
+		ret = net_ssl_recv(con, buf, len);
-			return -1;
-
-		ret = SSL_read(con->ssl, buf, len);
-		LOG_PROTO("SSL_read(con=%p, buf=%p, len=" PRINTF_SIZE_T ") => %d", con, buf, len, ret);
-		if (ret > 0)
-		{
-			net_con_update(con, NET_EVENT_READ);
-			net_stats_add_rx(ret);
-		}
-		else
-		{
-			return handle_openssl_error(con, ret);
-		}
 	}
-#endif
+#endif /* SSL_SUPPORT */
 	return ret;
 }
 
@@ -238,13 +90,7 @@ ssize_t net_con_peek(struct net_connection* con, void* buf, size_t len)
 	int ret = net_recv(con->sd, buf, len, MSG_PEEK);
 	if (ret == -1)
 	{
-		if (
+		if (is_blocked_or_interrupted())
-#ifdef WINSOCK
-				net_error() == WSAEWOULDBLOCK
-#else
-				net_error() == EWOULDBLOCK 
-#endif
-				|| net_error() == EINTR)
 			return 0;
 		return -net_error();
 	}
@@ -254,19 +100,10 @@ ssize_t net_con_peek(struct net_connection* con, void* buf, size_t len)
 }
 
 #ifdef SSL_SUPPORT
+
 int net_con_is_ssl(struct net_connection* con)
 {
-	return con->ssl != 0;
+	return !!con->ssl;
-}
-
-SSL* net_con_get_ssl(struct net_connection* con)
-{
-	return con->ssl;
-}
-
-void net_con_set_ssl(struct net_connection* con, SSL* ssl)
-{
-	con->ssl = ssl;
 }
 #endif /* SSL_SUPPORT */
 
@@ -280,10 +117,28 @@ void* net_con_get_ptr(struct net_connection* con)
 	return con->ptr;
 }
 
+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
-	SSL_free(con->ssl);
+	if (con && con->ssl)
+		net_ssl_destroy(con);
 #endif
 	hub_free(con);
 }
@@ -301,62 +156,402 @@ void net_con_callback(struct net_connection* con, int events)
 	}
 
 #ifdef SSL_SUPPORT
-	if (!con->ssl)
+	if (con->ssl)
-	{
+		net_ssl_callback(con, events);
+	else
 #endif
 		con->callback(con, events, con->ptr);
-#ifdef SSL_SUPPORT
+}
+
+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_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;
+	}
+	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
 	{
-#ifdef NETWORK_DUMP_DEBUG
+		job->handle->job4 = job->next;
-		LOG_PROTO("net_con_event: events=%d, con=%p, state=%d", events, con, con->ssl_state);
+	}
-#endif
+
-		switch (con->ssl_state)
+	net_connect_job_free(job);
-		{
+}
-			case tls_st_none:
+
-				con->callback(con, events, con->ptr);
+static int net_connect_depleted(struct net_connect_handle* handle)
-				break;
+{
-
+	return (!handle->job6 && !handle->job4);
-			case tls_st_error:
+}
-				con->callback(con, NET_EVENT_READ, con->ptr);
+
-				break;
+static int net_connect_job_process(struct net_connect_job* job)
-
+{
-			case tls_st_accepting:
+	int sd;
-				if (net_con_ssl_accept(con) < 0)
+	if (!job->con)
-				{
+	{
-					con->callback(con, NET_EVENT_READ, con->ptr);
+		sd = net_socket_create(job->addr.ss_family, SOCK_STREAM, IPPROTO_TCP);
-				}
+		if (sd == -1)
-				break;
+		{
-
+			LOG_DEBUG("net_connect_job_process: Unable to create socket!");
-			case tls_st_connecting:
+			net_connect_callback(job->handle, net_connect_status_socket_error, NULL);
-				if (net_con_ssl_connect(con) < 0)
+			return -1; // FIXME
-				{
+		}
-					con->callback(con, NET_EVENT_READ, con->ptr);
+
-				}
+		job->con = 	net_con_create();
-				break;
+		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!
-			case tls_st_connected:
+	}
-				LOG_PROTO("tls_st_connected, events=%s%s, ssl_flags=%s%s", (events & NET_EVENT_READ ? "R" : ""), (events & NET_EVENT_WRITE ? "W" : ""), con->flags & NET_WANT_SSL_READ ? "R" : "", con->flags & NET_WANT_SSL_WRITE ? "W" : "");
+
-				if (events & NET_EVENT_WRITE && con->flags & NET_WANT_SSL_READ)
+	return net_connect_job_check(job);
-				{
+}
-					con->callback(con, events & NET_EVENT_READ, con->ptr);
+
-					return;
+
-				}
+/*
-
+ * Internal callback used to establish an outbound connection.
-				if (events & NET_EVENT_READ && con->flags & NET_WANT_SSL_WRITE)
+ */
-				{
+static void net_connect_job_internal_cb(struct net_connection* con, int event, void* ptr)
-					con->callback(con, events & NET_EVENT_READ, con->ptr);
+{
-					return;
+	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;
-				con->callback(con, events, con->ptr);
+
-				break;
+	if (event == NET_EVENT_TIMEOUT)
-
+	{
-			case tls_st_disconnecting:
+		// FIXME: Try next address, or if no more addresses left declare failure to connect.
-				return;
+		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 void 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);
+	return 0;
+}
+
+
+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;
+
+	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);
+}
+
+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;
 	}
-#endif
 }
 

src/network/connection.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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -23,20 +23,53 @@
 #include "uhub.h"
 #include "network/common.h"
 #include "network/backend.h"
+#include "network/tls.h"
 
 #define NET_EVENT_TIMEOUT         0x0001
 #define NET_EVENT_READ            0x0002
 #define NET_EVENT_WRITE           0x0004
+#define NET_EVENT_ERROR           0x1000
 
 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);
@@ -55,7 +88,7 @@ extern void net_con_close(struct net_connection* con);
  *
  * @return returns the number of bytes sent.
  *         0 if no data is sent, and this function should be called again (EWOULDBLOCK/EINTR)
- *        <0 if an error occured, the negative number contains the error code.
+ *        <0 if an error occurred, the negative number contains the error code.
  */
 extern ssize_t net_con_send(struct net_connection* con, const void* buf, size_t len);
 
@@ -64,7 +97,7 @@ extern ssize_t net_con_send(struct net_connection* con, const void* buf, size_t
  *
  * @return returns the number of bytes sent.
  *         0 if no data is sent, and this function should be called again (EWOULDBLOCK/EINTR)
- *        <0 if an error occured, the negative number contains the error code.
+ *        <0 if an error occurred, the negative number contains the error code.
  */
 extern ssize_t net_con_recv(struct net_connection* con, void* buf, size_t len);
 
@@ -76,36 +109,12 @@ extern ssize_t net_con_recv(struct net_connection* con, void* buf, size_t len);
 extern ssize_t net_con_peek(struct net_connection* con, void* buf, size_t len);
 
 /**
- * Set timeout for connetion.
+ * Set timeout for connection.
  *
  * @param seconds the number of seconds into the future.
  */
 extern void net_con_set_timeout(struct net_connection* con, int seconds);
 extern void net_con_clear_timeout(struct net_connection* con);
 
-#ifdef SSL_SUPPORT
-/**
- * Start SSL_accept()
- */
-extern ssize_t net_con_ssl_accept(struct net_connection*);
-
-/**
- * Start SSL_connect()
- */
-extern ssize_t net_con_ssl_connect(struct net_connection*);
-
-enum net_con_ssl_mode
-{
-	net_con_ssl_mode_server,
-	net_con_ssl_mode_client,
-};
-
-extern ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode, SSL_CTX* ssl_ctx);
-
-extern int   net_con_is_ssl(struct net_connection* con);
-extern SSL* net_con_get_ssl(struct net_connection* con);
-extern void net_con_set_ssl(struct net_connection* con, SSL*);
-#endif /* SSL_SUPPORT */
-
 #endif /* HAVE_UHUB_NETWORK_CONNECTION_H */
 

src/network/dnsresolver.c

@@ -0,0 +1,391 @@
+/*
+ * 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 <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+
+static struct net_dns_job* find_and_remove_job(struct net_dns_job* job);
+static struct net_dns_result* find_and_remove_result(struct net_dns_job* job);
+
+struct net_dns_job
+{
+	net_dns_job_cb callback;
+	void* ptr;
+
+	char* host;
+	int af;
+
+#ifdef DEBUG_LOOKUP_TIME
+	struct timeval time_start;
+	struct timeval time_finish;
+#endif
+
+	uhub_thread_t* thread_handle;
+};
+
+struct net_dns_result
+{
+	struct linked_list* addr_list;
+	struct net_dns_job* job;
+};
+
+static void free_job(struct net_dns_job* job)
+{
+	if (job)
+	{
+		hub_free(job->host);
+		hub_free(job);
+	}
+}
+
+static void shutdown_free_jobs(void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) ptr;
+	uhub_thread_cancel(job->thread_handle);
+	uhub_thread_join(job->thread_handle);
+	free_job(job);
+}
+
+static void shutdown_free_results(void* ptr)
+{
+	struct net_dns_result* result = (struct net_dns_result*) ptr;
+	uhub_thread_join(result->job->thread_handle);
+	net_dns_result_free(result);
+}
+
+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!
+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;
+
+void net_dns_initialize()
+{
+	LOG_TRACE("net_dns_initialize()");
+	g_dns = (struct net_dns_subsystem*) hub_malloc_zero(sizeof(struct net_dns_subsystem));
+	g_dns->jobs = list_create();
+	g_dns->results = list_create();
+	uhub_mutex_init(&g_dns->mutex);
+	g_dns->notify_handle = net_notify_create(notify_callback, g_dns);
+}
+
+void net_dns_destroy()
+{
+	uhub_mutex_lock(&g_dns->mutex);
+	LOG_TRACE("net_dns_destroy(): jobs=%d", (int) list_size(g_dns->jobs));
+	list_clear(g_dns->jobs, &shutdown_free_jobs);
+
+	LOG_TRACE("net_dns_destroy(): results=%d", (int) list_size(g_dns->results));
+	list_clear(g_dns->results, &shutdown_free_results);
+	uhub_mutex_unlock(&g_dns->mutex);
+
+	list_destroy(g_dns->jobs);
+	list_destroy(g_dns->results);
+	uhub_mutex_destroy(&g_dns->mutex);
+	net_notify_destroy(g_dns->notify_handle);
+	hub_free(g_dns);
+	g_dns = NULL;
+}
+
+void net_dns_process()
+{
+	struct net_dns_result* result;
+	uhub_mutex_lock(&g_dns->mutex);
+	LOG_TRACE("net_dns_process(): jobs=%d, results=%d", (int) list_size(g_dns->jobs), (int) list_size(g_dns->results));
+
+	LIST_FOREACH(struct net_dns_result*, result, g_dns->results,
+	{
+		struct net_dns_job* job = result->job;
+#ifdef DEBUG_LOOKUP_TIME
+		struct timeval time_result;
+		timersub(&result->job->time_finish, &result->job->time_start, &time_result);
+		LOG_TRACE("DNS lookup took %d ms", (time_result.tv_sec * 1000) + (time_result.tv_usec / 1000));
+#endif
+
+		// wait for the work thread to finish
+		uhub_thread_join(job->thread_handle);
+
+		// callback - should we delete the data immediately?
+		if (job->callback(job, result))
+		{
+			net_dns_result_free(result);
+		}
+		else
+		{
+			/* Caller wants to keep the result data, and
+			 * thus needs to call net_dns_result_free() to release it later.
+			 * We only clean up the job data here and keep the results intact.
+			 */
+			result->job = NULL;
+			free_job(job);
+		}
+	});
+
+	list_clear(g_dns->results, NULL);
+	uhub_mutex_unlock(&g_dns->mutex);
+}
+
+static void* job_thread_resolve_name(void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) ptr;
+	struct addrinfo hints, *result, *it;
+	struct net_dns_result* dns_results;
+	int ret;
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = job->af;
+	hints.ai_protocol = IPPROTO_TCP;
+
+	ret = getaddrinfo(job->host, NULL, &hints, &result);
+	if (ret != 0 && ret != EAI_NONAME)
+	{
+		LOG_TRACE("getaddrinfo() failed: %s", gai_strerror(ret));
+		return NULL;
+	}
+
+	dns_results = (struct net_dns_result*) hub_malloc(sizeof(struct net_dns_result));
+	dns_results->addr_list = list_create();
+	dns_results->job = job;
+
+	if (ret != EAI_NONAME)
+	{
+		for (it = result; it; it = it->ai_next)
+		{
+			struct ip_addr_encap* ipaddr = hub_malloc_zero(sizeof(struct ip_addr_encap));
+			ipaddr->af = it->ai_family;
+
+			if (it->ai_family == AF_INET)
+			{
+				struct sockaddr_in* addr4 = (struct sockaddr_in*) it->ai_addr;
+				memcpy(&ipaddr->internal_ip_data.in, &addr4->sin_addr, sizeof(struct in_addr));
+			}
+			else if (it->ai_family == AF_INET6)
+			{
+				struct sockaddr_in6* addr6 = (struct sockaddr_in6*) it->ai_addr;
+				memcpy(&ipaddr->internal_ip_data.in6, &addr6->sin6_addr, sizeof(struct in6_addr));
+			}
+			else
+			{
+				LOG_TRACE("getaddrinfo() returned result with unknown address family: %d", it->ai_family);
+				hub_free(ipaddr);
+				continue;
+			}
+
+			LOG_DUMP("getaddrinfo() - Address (%d) %s for \"%s\"", ret++, ip_convert_to_string(ipaddr), job->host);
+			list_append(dns_results->addr_list, ipaddr);
+		}
+		freeaddrinfo(result);
+	}
+	else
+	{
+		/* hm */
+	}
+
+#ifdef DEBUG_LOOKUP_TIME
+	gettimeofday(&job->time_finish, NULL);
+#endif
+
+	uhub_mutex_lock(&g_dns->mutex);
+	list_remove(g_dns->jobs, job);
+	list_append(g_dns->results, dns_results);
+	net_notify_signal(g_dns->notify_handle, 1);
+	uhub_mutex_unlock(&g_dns->mutex);
+
+	return dns_results;
+}
+
+
+extern struct net_dns_job* net_dns_gethostbyname(const char* host, int af, net_dns_job_cb callback, void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) hub_malloc_zero(sizeof(struct net_dns_job));
+	job->host = strdup(host);
+	job->af = af;
+	job->callback = callback;
+	job->ptr = ptr;
+
+#ifdef DEBUG_LOOKUP_TIME
+	gettimeofday(&job->time_start, NULL);
+#endif
+
+	// FIXME - scheduling - what about a max number of threads?
+	uhub_mutex_lock(&g_dns->mutex);
+	job->thread_handle = uhub_thread_create(job_thread_resolve_name, job);
+	if (!job->thread_handle)
+	{
+		LOG_WARN("Unable to create thread");
+		free_job(job);
+		job = NULL;
+	}
+	else
+	{
+		list_append(g_dns->jobs, job);
+	}
+	uhub_mutex_unlock(&g_dns->mutex);
+	return job;
+}
+
+
+
+extern struct net_dns_job* net_dns_gethostbyaddr(struct ip_addr_encap* ipaddr, net_dns_job_cb callback, void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) hub_malloc_zero(sizeof(struct net_dns_job));
+// 	job->host = strdup(addr);
+	job->af = ipaddr->af;
+	job->callback = callback;
+	job->ptr = ptr;
+
+
+// 	if (pthread_create(&job->thread_handle, NULL, start_job, job))
+// 	{
+// 		free_job(job);
+// 		return NULL;
+// 	}
+	return job;
+}
+
+// NOTE: mutex must be locked first!
+static struct net_dns_job* find_and_remove_job(struct net_dns_job* job)
+{
+	struct net_dns_job* it;
+	LIST_FOREACH(struct net_dns_job*, it, g_dns->jobs,
+	{
+		if (it == job)
+		{
+			list_remove(g_dns->jobs, it);
+			return job;
+		}
+	});
+	return NULL;
+}
+
+// NOTE: mutex must be locked first!
+static struct net_dns_result* find_and_remove_result(struct net_dns_job* job)
+{
+	struct net_dns_result* it;
+	LIST_FOREACH(struct net_dns_result*, it, g_dns->results,
+	{
+		if (it->job == job)
+		{
+			list_remove(g_dns->results, it);
+			return it;
+		}
+	});
+	return NULL;
+}
+
+
+extern int net_dns_job_cancel(struct net_dns_job* job)
+{
+	int retval = 0;
+	struct net_dns_result* res;
+
+	LOG_TRACE("net_dns_job_cancel(): job=%p, name=%s", job, job->host);
+
+	/*
+	 * This function looks up the job in the jobs queue (which contains only active jobs)
+	 * If that is found then the thread is cancelled, and the object is deleted.
+	 * If the job was not found, that is either because it was an invalid job, or because
+	 * it was already finished. At which point it was not deleted.
+	 * If the job is already finished, but the result has not been delivered, then this
+	 * deletes the result and the job.
+	 */
+	uhub_mutex_lock(&g_dns->mutex);
+	if (find_and_remove_job(job))
+	{
+		// job still active - cancel it, then close it.
+		uhub_thread_cancel(job->thread_handle);
+		uhub_thread_join(job->thread_handle);
+		free_job(job);
+		retval = 1;
+	}
+	else if ((res = find_and_remove_result(job)))
+	{
+		// job already finished - close it.
+		uhub_thread_join(job->thread_handle);
+		net_dns_result_free(res);
+	}
+	uhub_mutex_unlock(&g_dns->mutex);
+	return retval;
+}
+
+extern struct net_dns_result* net_dns_job_sync_wait(struct net_dns_job* job)
+{
+	struct net_dns_result* res = NULL;
+
+	// Wait for job to finish (if not already)
+	// This should make sure the job is removed from jobs and a result is
+	// present in results.
+	uhub_thread_join(job->thread_handle);
+
+	// Remove the result in order to prevent the callback from being called.
+	uhub_mutex_lock(&g_dns->mutex);
+	res = find_and_remove_result(job);
+	uhub_assert(res != NULL);
+	res->job = NULL;
+	free_job(job);
+	uhub_mutex_unlock(&g_dns->mutex);
+	return res;
+}
+
+void* net_dns_job_get_ptr(const struct net_dns_job* job)
+{
+	return job->ptr;
+}
+
+extern size_t net_dns_result_size(const struct net_dns_result* res)
+{
+	return list_size(res->addr_list);
+}
+
+extern struct ip_addr_encap* net_dns_result_first(const struct net_dns_result* res)
+{
+	struct ip_addr_encap* ipaddr = list_get_first(res->addr_list);
+	LOG_TRACE("net_dns_result_first() - Address: %s", 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", ipaddr ? ip_convert_to_string(ipaddr) : "(no more addresses)");
+	return ipaddr;
+}
+
+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((struct net_dns_result*) res);
+}

src/network/dnsresolver.h

@@ -0,0 +1,119 @@
+/*
+ * 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 <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_NETWORK_DNS_RESOLVER_H
+#define HAVE_UHUB_NETWORK_DNS_RESOLVER_H
+
+struct net_dns_job;
+struct net_dns_result;
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+/// Initialize the DNS subsystem
+void net_dns_initialize();
+
+/// Shutdown and destroy the DNS subsystem. This will cancel any pending DNS jobs.
+void net_dns_destroy();
+
+/// Process finished DNS lookups.
+void net_dns_process();
+
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+/**
+ * Callback to be called when the DNS job has finished.
+ * If the name or address could not be resolved to an IP address (host not found, or found but has no address)
+ * then 'result' contains an empty list (@see net_dns_result_size()).
+ * If resolving caused an error then result is NULL.
+ *
+ * After this callback is called the job is considered done, and is freed.
+ *
+ * @param If 1 is returned then result is deleted immediately after the callback,
+ * otherwise the callback becomes owner of the result data which must be freed with net_dns_result_free().
+ */
+typedef int (*net_dns_job_cb)(struct net_dns_job*, const struct net_dns_result* result);
+
+/**
+ * Resolve a hostname.
+ *
+ * @param host the hostname to be resolved.
+ * @param af the indicated address family. Should be AF_INET, AF_INET6 (or AF_UNSPEC - which means both AF_INET and AF_INET6.
+ * @param callback the callback to be called when the hostname has been resolved.
+ * @param ptr A user-defined pointer value.
+ *
+ * @return A resolve job handle if the job has successfully started or NULL if unable to start resolving.
+ */
+extern struct net_dns_job* net_dns_gethostbyname(const char* host, int af, net_dns_job_cb callback, void* ptr);
+
+/**
+ * Perform a reverse DNS lookup for a given IP address.
+ *
+ * @see net_dns_gethostbyname()
+ * @return A resolve job handle if the job has successfully started or NULL if unable to start resolving.
+ */
+extern struct net_dns_job* net_dns_gethostbyaddr(struct ip_addr_encap* ipaddr, net_dns_job_cb callback, void* ptr);
+
+/**
+ * Cancel a DNS lookup job.
+ *
+ * It is only allowed to call this once after a job has been started (@see net_dns_gethostbyname(), @see net_dns_gethostbyaddr())
+ * but before it has finished and delivered a to the callback address (@see net_dns_job_cb).
+ *
+ * @returns 1 if cancelled, or 0 if not cancelled (because the job was not found!)
+ */
+extern int net_dns_job_cancel(struct net_dns_job* job);
+
+/**
+ * Wait in a synchronous manner for a running DNS job to finished and
+ * return the result here.
+ * The job must be started with net_dns_gethostbyaddr/net_dns_gethostbyname
+ * and not finished or cancelled.
+ *
+ * If this function is invoked then the callback function will not be called and
+ * can therefore be NULL.
+ *
+ * <code>
+ *    struct net_dns_job* job = net_dns_gethostbyname("www.example.com", AF_INET, NULL, NULL);
+ *    struct net_dns_result* net_dns_job_sync_wait(job);
+ * </code>
+ */
+extern struct net_dns_result* net_dns_job_sync_wait(struct net_dns_job* job);
+
+/**
+ * Returns the user specified pointer assigned to the resolving job
+*/
+extern void* net_dns_job_get_ptr(const struct net_dns_job* job);
+
+/// Returns the number of results provided. This is 0 if the host could not be found (or has no matching IP address).
+extern size_t net_dns_result_size(const struct net_dns_result*);
+
+/// Returns the first result (if net_dns_result_size > 0), or NULL if not first result exists.
+extern struct ip_addr_encap* net_dns_result_first(const struct net_dns_result*);
+
+/// Returns the next result or NULL if no next result exists.
+extern struct ip_addr_encap* net_dns_result_next(const struct net_dns_result*);
+
+/// When finished with the results
+extern void net_dns_result_free(const struct net_dns_result*);
+
+#endif /* HAVE_UHUB_NETWORK_DNS_RESOLVER_H */

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -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
@@ -13,12 +13,12 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
 /*
- * 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.
  */
 
@@ -92,7 +92,7 @@ extern int ip_is_valid_ipv6(const char* address);
  *
  * @param text_addr is an ipaddress either ipv6 or ipv4.
  *                  Special magic addresses called "any" and "loopback" exist,
- *                  and will work accross IPv6/IPv4.
+ *                  and will work across IPv6/IPv4.
  * @param port      Fill the struct sockaddr* with the given port, can safely be ignored.
  */
 extern int ip_convert_address(const char* text_address, int port, struct sockaddr* addr, socklen_t* addr_len);

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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 

src/network/network.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2019, 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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -49,21 +49,21 @@ int net_initialize()
 		}
 #endif /* WINSOCK */
 
-		if (!net_backend_init())
+		if (!net_backend_init()
+#ifdef SSL_SUPPORT
+			|| !net_ssl_library_init()
+#endif
+			)
 		{
 #ifdef WINSOCK
 			WSACleanup();
 #endif
 			return -1;
 		}
+
+		net_dns_initialize();
+
 		net_stats_initialize();
-
-#ifdef SSL_SUPPORT
-		LOG_TRACE("Initializing OpenSSL...");
-		SSL_library_init();
-		SSL_load_error_strings();
-#endif /*  SSL_SUPPORT */
-
 		net_initialized = 1;
 		return 0;
 	}
@@ -97,13 +97,13 @@ int net_destroy()
 	{
 		LOG_TRACE("Shutting down network monitor");
 
+		net_dns_destroy();
+
 		net_backend_shutdown();
-		
+
 #ifdef SSL_SUPPORT
-		ERR_free_strings();
+		net_ssl_library_shutdown();
-		EVP_cleanup();
+#endif /* SSL_SUPPORT */
-		CRYPTO_cleanup_all_ex_data();
-#endif
 
 #ifdef WINSOCK
 		WSACleanup();
@@ -449,7 +449,7 @@ int net_is_ipv6_supported()
 				is_ipv6_supported = 0;
 				return 0;
 			}
-			
+
 			net_error_out(ret, "net_is_ipv6_supported");
 		}
 		else
@@ -495,7 +495,6 @@ int net_socket_create(int af, int type, int protocol)
 		}
 	}
 #endif
-
 	return sd;
 }
 
@@ -509,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:
@@ -532,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;
@@ -603,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;
@@ -806,4 +805,22 @@ void net_stats_add_close()
 	stats.closed++;
 }
 
+void net_stats_tls_add_accept()
+{
+	stats.tls_accept++;
+}
 
+void net_stats_tls_add_connect()
+{
+	stats.tls_connect++;
+}
+
+void net_stats_tls_add_error()
+{
+	stats.tls_error++;
+}
+
+void net_stats_tls_add_close()
+{
+	stats.tls_close++;
+}

src/network/network.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2019, 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
@@ -13,7 +13,7 @@
  * 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/>.
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  *
  */
 
@@ -28,9 +28,14 @@ struct net_statistics
 	size_t accept;
 	size_t closed;
 	size_t errors;
+	size_t tls_accept;
+	size_t tls_connect;
+	size_t tls_error;
+	size_t tls_close;
 };
 
 struct net_socket_t;
+struct ip_addr_encap;
 
 /**
  * Initialize the socket monitor subsystem.
@@ -52,7 +57,7 @@ extern int net_initialize();
 extern int net_destroy();
 
 /**
- * @return the number of sockets currrently being monitored.
+ * @return the number of sockets currently being monitored.
  */
 extern int net_monitor_count();
 
@@ -62,7 +67,7 @@ extern int net_monitor_count();
 extern int net_monitor_capacity();
 
 /**
- * @return the last error code occured.
+ * @return the last error code occurred.
  *
  * NOTE: On Windows this is the last error code from the socket library, but
  *       on UNIX this is the errno variable that can be overwritten by any
@@ -246,9 +251,14 @@ extern void net_stats_report();
 extern void net_stats_reset();
 extern void net_stats_add_tx(size_t bytes);
 extern void net_stats_add_rx(size_t bytes);
+extern void net_stats_tls_add_accept();
+extern void net_stats_tls_add_connect();
+extern void net_stats_tls_add_error();
+extern void net_stats_tls_add_close();
 extern void net_stats_add_accept();
 extern void net_stats_add_error();
 extern void net_stats_add_close();
+extern void net_stats_add_connect();
 extern int net_stats_timeout();
 extern void net_stats_get(struct net_statistics** intermediate, struct net_statistics** total);
 

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 <https://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 <https://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 */