Updated changelog for 0.4.1 release.

for certain lookups.

The rb_tree will act as a general purpose key/value storage, and
also give a performance boost in the cases where the other
simple alternative would be to use a linked_list.

On average this should give on average O(log n) lookups, while the linked_list
would be O(n) at worst.

.gitignore

@@ -1,8 +1,24 @@
 *~
 *.[oa]
+*.lib
 *.exe
+*.manifest
 *.gch
+CMakeFiles/*
+CMakeCache.txt
+cmake_install.cmake
+mod_*.dll
+mod_*.exp
+mod_*.so
 uhub-admin
 adcrush
 uhub
-
+build-stamp
+debian/files
+debian/uhub.debhelper.log
+debian/uhub.postinst.debhelper
+debian/uhub.postrm.debhelper
+debian/uhub.prerm.debhelper
+debian/uhub.substvars
+uhub-passwd
+src/version.h

.gitmodules

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

AUTHORS

@@ -1,6 +1,11 @@
-Authors of uHub
+Authors of uhub
 ===============
 
 Jan Vidar Krey, Design and implementation
 E_zombie, Centos/RedHat customization scripts and heavy load testing
-
+FleetCommand, Hub topic plugin code
+MiMic, Implemented user commands
+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

BSDmakefile

@@ -1,8 +0,0 @@
-
-GMAKE=gmake
-
-all:
-	@${GMAKE} ${.TARGETS}
-
-${.TARGETS}: all
-

CMakeLists.txt

@@ -0,0 +1,198 @@
+ ##
+## Makefile for uhub
+## Copyright (C) 2007-2012, Jan Vidar Krey <janvidar@extatic.org>
+ #
+
+cmake_minimum_required (VERSION 2.8.3)
+
+project (uhub NONE)
+enable_language(C)
+
+set (UHUB_VERSION_MAJOR 0)
+set (UHUB_VERSION_MINOR 4)
+set (UHUB_VERSION_PATCH 1)
+
+set (PROJECT_SOURCE_DIR "${CMAKE_SOURCE_DIR}/src")
+
+option(RELEASE "Release build, debug build if disabled" ON)
+option(LINK_SUPPORT "Allow hub linking" OFF)
+option(SSL_SUPPORT "Enable SSL support" ON)
+option(USE_OPENSSL "Use OpenSSL's SSL support" ON )
+option(SQLITE_SUPPORT "Enable SQLite support" ON)
+option(ADC_STRESS "Enable the stress tester client" OFF)
+
+find_package(Git)
+
+if (SSL_SUPPORT)
+	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 are not found!")
+	endif()
+endif()
+
+if (MSVC)
+	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+endif()
+
+include_directories("${PROJECT_SOURCE_DIR}")
+
+file (GLOB uhub_SOURCES ${PROJECT_SOURCE_DIR}/core/*.c)
+list (REMOVE_ITEM uhub_SOURCES
+	${PROJECT_SOURCE_DIR}/core/gen_config.c
+	${PROJECT_SOURCE_DIR}/core/main.c
+)
+
+file (GLOB adc_SOURCES ${PROJECT_SOURCE_DIR}/adc/*.c)
+file (GLOB network_SOURCES ${PROJECT_SOURCE_DIR}/network/*.c)
+file (GLOB utils_SOURCES ${PROJECT_SOURCE_DIR}/util/*.c)
+
+set (adcclient_SOURCES
+	${PROJECT_SOURCE_DIR}/tools/adcclient.c
+	${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_COMPILER_IS_GNUCC)
+	set_target_properties(utils PROPERTIES COMPILE_FLAGS -fPIC)
+	set_target_properties(network PROPERTIES COMPILE_FLAGS -fPIC)
+endif()
+
+add_dependencies(adc utils)
+add_dependencies(network utils)
+
+add_executable(uhub ${PROJECT_SOURCE_DIR}/core/main.c ${uhub_SOURCES} )
+add_executable(test ${CMAKE_SOURCE_DIR}/autotest/test.c ${uhub_SOURCES} )
+
+add_library(mod_example MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_example.c)
+add_library(mod_welcome MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_welcome.c)
+add_library(mod_logging MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_logging.c ${PROJECT_SOURCE_DIR}/adc/sid.c)
+add_library(mod_auth_simple MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_auth_simple.c )
+add_library(mod_chat_history MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_chat_history.c )
+add_library(mod_chat_only MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_chat_only.c)
+add_library(mod_topic MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_topic.c)
+add_library(mod_no_guest_downloads MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_no_guest_downloads.c)
+
+if (SQLITE_SUPPORT)
+	add_library(mod_auth_sqlite MODULE ${PROJECT_SOURCE_DIR}/plugins/mod_auth_sqlite.c)
+	add_executable(uhub-passwd ${PROJECT_SOURCE_DIR}/tools/uhub-passwd.c)
+
+	target_link_libraries(mod_auth_sqlite sqlite3 utils)
+	target_link_libraries(uhub-passwd sqlite3 utils)
+	set_target_properties(mod_auth_sqlite PROPERTIES PREFIX "")
+endif()
+
+
+if(WIN32)
+	target_link_libraries(uhub ws2_32)
+	target_link_libraries(test 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_chat_history
+	mod_chat_only
+	mod_no_guest_downloads
+	mod_topic
+	PROPERTIES PREFIX "")
+
+target_link_libraries(uhub ${CMAKE_DL_LIBS} adc network utils)
+target_link_libraries(test ${CMAKE_DL_LIBS} adc network utils)
+target_link_libraries(mod_example utils)
+target_link_libraries(mod_welcome utils)
+target_link_libraries(mod_auth_simple utils)
+target_link_libraries(mod_chat_history utils)
+target_link_libraries(mod_no_guest_downloads utils)
+target_link_libraries(mod_chat_only utils)
+target_link_libraries(mod_logging utils)
+target_link_libraries(mod_topic utils)
+target_link_libraries(utils network)
+target_link_libraries(mod_welcome network)
+target_link_libraries(mod_logging network)
+
+if(UNIX)
+	add_library(adcclient STATIC ${adcclient_SOURCES})
+	add_executable(uhub-admin ${PROJECT_SOURCE_DIR}/tools/admin.c)
+	target_link_libraries(uhub-admin adcclient adc network utils pthread)
+	target_link_libraries(uhub pthread)
+	target_link_libraries(test pthread)
+
+	if (ADC_STRESS)
+		add_executable(adcrush ${PROJECT_SOURCE_DIR}/tools/adcrush.c ${adcclient_SOURCES})
+		target_link_libraries(adcrush adcclient adc network utils pthread)
+	endif()
+endif()
+
+if (NOT UHUB_REVISION AND GIT_FOUND)
+	execute_process(COMMAND ${GIT_EXECUTABLE} show -s --pretty=format:%h
+					WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+					OUTPUT_VARIABLE UHUB_REVISION_TEMP
+					OUTPUT_STRIP_TRAILING_WHITESPACE)
+	if (UHUB_REVISION_TEMP)
+		set (UHUB_REVISION "git-${UHUB_REVISION_TEMP}")
+	endif()
+endif()
+
+if (NOT UHUB_REVISION)
+	set (UHUB_REVISION "release")
+endif()
+
+set (UHUB_GIT_VERSION "${UHUB_VERSION_MAJOR}.${UHUB_VERSION_MINOR}.${UHUB_VERSION_PATCH}-${UHUB_REVISION}")
+message (STATUS "Configuring uhub version: ${UHUB_GIT_VERSION}")
+
+if(OPENSSL_FOUND)
+	set(SSL_LIBS ${OPENSSL_LIBRARIES})
+	add_definitions(-DSSL_SUPPORT=1 -DSSL_USE_OPENSSL=1)
+	include_directories(${OPENSSL_INCLUDE_DIR})
+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(test ${SSL_LIBS})
+	if(UNIX)
+		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()
+endif()
+
+configure_file ("${PROJECT_SOURCE_DIR}/version.h.in" "${PROJECT_SOURCE_DIR}/version.h")
+
+mark_as_advanced(FORCE CMAKE_BUILD_TYPE)
+if (RELEASE)
+	set(CMAKE_BUILD_TYPE Release)
+else()
+	set(CMAKE_BUILD_TYPE Debug)
+	# add_definitions(-DDEBUG)
+endif()
+
+if (UNIX)
+	install( TARGETS uhub RUNTIME DESTINATION bin )
+	install( TARGETS mod_example mod_welcome mod_logging mod_auth_simple mod_auth_sqlite mod_chat_history mod_chat_only mod_topic mod_no_guest_downloads DESTINATION /usr/lib/uhub/ OPTIONAL )
+	install( FILES ${CMAKE_SOURCE_DIR}/doc/uhub.conf ${CMAKE_SOURCE_DIR}/doc/plugins.conf ${CMAKE_SOURCE_DIR}/doc/rules.txt ${CMAKE_SOURCE_DIR}/doc/motd.txt DESTINATION /etc/uhub OPTIONAL )
+
+	if (SQLITE_SUPPORT)
+		install( TARGETS uhub-passwd RUNTIME DESTINATION bin )
+	endif()
+endif()
+
+

COPYING.OpenSSL

@@ -0,0 +1,25 @@
+OpenSSL License Exception
+-------------------------
+
+Copyright (c) 2007-2012, Jan Vidar Krey
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License 3 (GPL) as published by
+the Free Software Foundation.
+The full text the GPL can be found in the COPYING file.
+
+In addition this distribution of uhub may be linked against OpenSSL
+according to the terms described here:
+
+You have permission to copy, modify, propagate, and distribute a work
+formed by combining OpenSSL with uhub, or a work derivative of such a
+combination, even if such copying, modification, propagation, or
+distribution would otherwise violate the terms of the GPL. You must
+comply with the GPL in all respects for all of the code used other than
+OpenSSL.
+
+You may include this OpenSSL exception and its grant of permissions when
+you distribute uhub. Inclusion of this notice with such a distribution
+constitutes a grant of such permission.  If you do not wish to grant these
+permissions, delete this file.
+

ChangeLog

@@ -1,3 +1,68 @@
+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
+- Print error message in case of shutting down due to errors loading plugins.
+- Fix Windows file read discrepancy.
+- convert_to_sqlite.pl: Update to the latest SQL schema + be more Perlish
+- Fix VS2010 project file - missing .c file.
+- Merge https://github.com/Tilka/uhub
+- use "I64u" instead of PRIu64 on Windows
+- remove obsolete settings in uhub.conf
+- fix uhub_itoa() and uhub_ulltoa()
+- 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 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
+- don't show error on SIGTERM in select() backend
+- fix dependency of 'install' target
+- changed all calls to assert() to uhub_assert()
+- Don't strip the U4/U6 port numbers if updated after login.
+- Fix compile issue with double typedefs.
+- Remove list assertion when removing element that is not in the list. Breaks autotest.
+- Cleaned up command handling code, by splitting into multiple files.
+- Fix bug #183 - Added proper OpenSSL license exception for the GPL.
+- OMG OPTIMIZED
+- use dh_prep instead of dh_clean -k
+- fix double free
+- use "0" instead of "false"
+- fix use of uninitialized struct ip_range
+- fix random crashes upon !reload
+- fix command syntax
+- use arg parser in !broadcast
+- Fixed tiny memory leak on reload/shutdown.
+- Merge https://github.com/Tilka/uhub
+- fix multiple optional arguments
+- small cleanup
+- also clean uhub-passwd
+- ignore files generated by dpkg-buildpackage
+- automatically clean up plugin commands
+- minimal documentation fixes
+- update client software link
+- update compile howto link
+- fix debian changelog
+- Fix bug #158 - Added plugin for setting topic (hub description).
+- Command arguments handling + cleanups
+
+
 0.3.2:
 - Fixed bugs in the kqueue network backend (OSX/BSD)
 - Rewrote the configuration backend code.

GNUmakefile

@@ -1,263 +0,0 @@
- ##
-## Makefile for uhub (Use GNU make)
-## Copyright (C) 2007-2010, Jan Vidar Krey <janvidar@extatic.org>
- #
-
--include Makefile.private
-
-CC            = gcc
-LD            := $(CC)
-MV            := mv
-RANLIB        := ranlib
-CFLAGS        += -pipe -Wall
-USE_SSL       ?= NO
-USE_BIGENDIAN ?= AUTO
-BITS          ?= AUTO
-SILENT        ?= YES
-TERSE         ?= NO
-STACK_PROTECT ?= NO
-
-ifeq ($(OS), Windows_NT)
-WINDOWS       ?= YES
-OPSYS ?= Windows
-else
-OPSYS ?= $(shell uname)
-endif
-
-ifeq ($(OPSYS),SunOS)
-LDLIBS        += -lsocket -lnsl
-endif
-
-ifeq ($(OPSYS),Haiku)
-LDLIBS        += -lnetwork
-endif
-
-CFLAGS        += -I./src/
-
-ifeq ($(OPSYS),Windows)
-USE_BIGENDIAN := NO
-LDLIBS        += -lws2_32
-UHUB_CONF_DIR ?= c:/uhub/
-UHUB_PREFIX   ?= c:/uhub/
-CFLAGS        += -mno-cygwin
-LDFLAGS       += -mno-cygwin
-BIN_EXT       ?= .exe
-else
-DESTDIR       ?= /
-UHUB_CONF_DIR ?= $(DESTDIR)/etc/uhub
-UHUB_PREFIX   ?= $(DESTDIR)/usr/local
-CFLAGS        += -I/usr/local/include
-LDFLAGS       += -L/usr/local/lib
-BIN_EXT       ?=
-endif
-
-ifeq ($(SILENT),YES)
-	MSG_CC=@echo "  CC:" $(notdir $<) &&
-	MSG_LD=@echo "  LD:" $(notdir $@) &&
-	MSG_AR=@echo "  AR:" $(notdir $@) &&
-else
-	MSG_CC=
-	MSG_LD=
-	MSG_AR=
-endif
-
-ifeq ($(TERSE), YES)
-	MSG_CC=@
-	MSG_LD=@
-	MSG_AR=@
-	MSG_CLEAN=-n ""
-else
-	MSG_CLEAN="Clean as a whistle"
-endif
-
-ifeq ($(RELEASE),YES)
-CFLAGS        += -O3 -DNDEBUG
-else
-CFLAGS        += -ggdb -DDEBUG
-endif
-
-ifeq ($(STACK_PROTECT),YES)
-CFLAGS        += -fstack-protector-all
-endif
-
-
-ifeq ($(PROFILING),YES)
-CFLAGS        += -pg
-LDFLAGS       += -pg
-endif
-
-ifeq ($(FUNCTRACE),YES)
-CFLAGS        += -finstrument-functions
-CFLAGS        += -DDEBUG_FUNCTION_TRACE
-endif
-
-ifneq ($(BITS), AUTO)
-ifeq ($(BITS), 64)
-CFLAGS        += -m64
-LDFLAGS       += -m64
-else
-ifeq ($(BITS), 32)
-CFLAGS        += -m32
-LDFLAGS       += -m32
-endif
-endif
-endif
-
-ifeq ($(USE_BIGENDIAN),AUTO)
-ifeq ($(shell perl -e 'print pack("L", 0x554E4958)'),UNIX)
-CFLAGS        += -DARCH_BIGENDIAN
-endif
-else
-ifeq ($(USE_BIGENDIAN),YES)
-CFLAGS        += -DARCH_BIGENDIAN
-endif
-endif
-
-ifeq ($(USE_SSL),YES)
-CFLAGS        += -DSSL_SUPPORT
-LDLIBS        += -lssl
-endif
-
-GIT_VERSION=$(shell git describe --tags 2>/dev/null || echo "")
-GIT_REVISION=$(shell git show --abbrev-commit  2>/dev/null | head -n 1 | cut -f 2 -d " " || echo "")
-OLD_REVISION=$(shell grep GIT_REVISION revision.h 2>/dev/null | cut -f 3 -d " " | tr -d "\"")
-
-# Sources
-libuhub_SOURCES := \
-		src/core/auth.c \
-		src/core/commands.c \
-		src/core/config.c \
-		src/core/eventqueue.c \
-		src/core/floodctl.c \
-		src/core/hub.c \
-		src/core/hubevent.c \
-		src/core/hubio.c \
-		src/core/inf.c \
-		src/core/netevent.c \
-		src/core/probe.c \
-		src/core/route.c \
-		src/core/user.c \
-		src/core/usermanager.c \
-		src/network/backend.c \
-		src/network/connection.c \
-		src/network/epoll.c \
-		src/network/kqueue.c \
-		src/network/network.c \
-		src/network/select.c \
-		src/network/timeout.c \
-		src/network/timer.c \
-		src/util/ipcalc.c \
-		src/util/list.c \
-		src/util/log.c \
-		src/util/memory.c \
-		src/util/misc.c \
-		src/util/rbtree.c \
-		src/util/tiger.c
-
-libadc_common_SOURCES := \
-		src/adc/message.c \
-		src/adc/sid.c
-
-libadc_client_SOURCES := \
-		src/tools/adcclient.c
-
-uhub_SOURCES := src/core/main.c
-
-adcrush_SOURCES := src/tools/adcrush.c
-
-admin_SOURCES := src/tools/admin.c
-
-autotest_SOURCES := \
-		autotest/test_eventqueue.tcc \
-		autotest/test_hub.tcc \
-		autotest/test_inf.tcc \
-		autotest/test_ipfilter.tcc \
-		autotest/test_list.tcc \
-		autotest/test_memory.tcc \
-		autotest/test_message.tcc \
-		autotest/test_misc.tcc \
-		autotest/test_sid.tcc \
-		autotest/test_tiger.tcc \
-		autotest/test_timer.tcc \
-		autotest/test_usermanager.tcc
-
-autotest_OBJECTS = autotest.o
-
-# Source to objects
-libuhub_OBJECTS       := $(libuhub_SOURCES:.c=.o)
-libadc_client_OBJECTS := $(libadc_client_SOURCES:.c=.o)
-libadc_common_OBJECTS := $(libadc_common_SOURCES:.c=.o)
-
-uhub_OBJECTS          := $(uhub_SOURCES:.c=.o)
-adcrush_OBJECTS       := $(adcrush_SOURCES:.c=.o)
-admin_OBJECTS         := $(admin_SOURCES:.c=.o)
-
-all_OBJECTS     := $(libuhub_OBJECTS) $(uhub_OBJECTS) $(adcrush_OBJECTS) $(autotest_OBJECTS) $(admin_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
-
-uhub_BINARY=uhub$(BIN_EXT)
-adcrush_BINARY=adcrush$(BIN_EXT)
-admin_BINARY=uhub-admin$(BIN_EXT)
-autotest_BINARY=autotest/test$(BIN_EXT)
-
-.PHONY: revision.h.tmp
-
-%.o: %.c version.h revision.h
-	$(MSG_CC) $(CC) -c $(CFLAGS) -o $@ $<
-
-all: $(uhub_BINARY)
-
-$(adcrush_BINARY): $(adcrush_OBJECTS) $(libuhub_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
-	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
-
-$(admin_BINARY): $(admin_OBJECTS) $(libuhub_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
-	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
-
-$(uhub_BINARY): $(uhub_OBJECTS) $(libuhub_OBJECTS) $(libadc_common_OBJECTS)
-	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
-
-autotest.c: $(autotest_SOURCES)
-	$(shell exotic --standalone $(autotest_SOURCES) > $@)
-
-revision.h.tmp:
-	@rm -f $@
-	@echo "/* AUTOGENERATED FILE - DO NOT EDIT */" > $@
-	@if [ -n '$(GIT_VERSION)' ]; then echo \#define GIT_VERSION \"$(GIT_VERSION)\" >> $@; fi
-	@if [ -n '$(GIT_REVISION)' ]; then echo \#define GIT_REVISION \"$(GIT_REVISION)\" >> $@; fi
-
-version.h: revision.h
-
-revision.h: revision.h.tmp
-	@if [ '$(GIT_REVISION)' != '$(OLD_REVISION)' ]; then cp $@.tmp $@; fi
-	@if [ ! -f $@ ]; then cp $@.tmp $@; fi
-
-$(autotest_OBJECTS): autotest.c
-	$(MSG_CC) $(CC) -c $(CFLAGS) -Isrc -o $@ $<
-
-$(autotest_BINARY): $(autotest_OBJECTS) $(libuhub_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
-	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
-
-autotest: $(autotest_BINARY)
-	@./$(autotest_BINARY) -s -f
-
-ifeq ($(WINDOWS),YES)
-install:
-	@echo "Cannot install automatically on windows."
-else
-install: $(uhub_BINARY)
-	@echo Copying $(uhub_BINARY) to $(UHUB_PREFIX)/bin/
-	@cp $(uhub_BINARY) $(UHUB_PREFIX)/bin/
-	@if [ ! -d $(UHUB_CONF_DIR) ]; then echo Creating $(UHUB_CONF_DIR); mkdir -p $(UHUB_CONF_DIR); fi
-	@if [ ! -f $(UHUB_CONF_DIR)/uhub.conf ]; then cp doc/uhub.conf $(UHUB_CONF_DIR); fi
-	@if [ ! -f $(UHUB_CONF_DIR)/users.conf ]; then cp doc/users.conf  $(UHUB_CONF_DIR); fi
-	@touch $(UHUB_CONF_DIR)/motd.txt
-	@echo done.
-endif
-
-dist-clean:
-	@rm -rf $(all_OBJECTS) *~ core
-
-clean:
-	@rm -rf $(libuhub_OBJECTS) *~ core $(uhub_BINARY) $(admin_BINARY) $(autotest_BINARY) $(adcrush_BINARY) $(all_OBJECTS) autotest.c revision.h revision.h.tmp && \
-	echo $(MSG_CLEAN)
-
-

README

@@ -4,5 +4,5 @@ For the official documentation, bugs and other information, please visit:
 http://www.uhub.org/
 
 For a list of compatible ADC clients, see:
-http://www.adcportal.com/wiki/index.php/ADC_Software_List#Client_Software
+http://en.wikipedia.org/wiki/Advanced_Direct_Connect#Client_software
 

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

@@ -0,0 +1,251 @@
+#include <uhub.h>
+
+static struct hub_info* hub = NULL;
+static struct hub_command* cmd = NULL;
+static struct hub_user user;
+static struct command_base* cbase = NULL;
+static struct command_handle* c_test1 = NULL;
+static struct command_handle* c_test2 = NULL;
+static struct command_handle* c_test3 = NULL;
+static struct command_handle* c_test4 = NULL;
+static struct command_handle* c_test5 = NULL;
+static struct command_handle* c_test6 = NULL;
+static struct command_handle* c_test7 = NULL;
+
+// for results:
+static int result = 0;
+
+EXO_TEST(setup, {
+	hub = hub_malloc_zero(sizeof(struct hub_info));
+	cbase = command_initialize(hub);
+	hub->commands = cbase;
+	hub->users = uman_init();
+	return cbase && hub && hub->users;
+});
+
+static int test_handler(struct command_base* cbase, struct hub_user* user, struct hub_command* hcmd)
+{
+	printf("test_handler\n");
+	result = 1;
+	return 0;
+}
+
+static struct command_handle* create_handler(const char* prefix, const char* args, enum auth_credentials cred)
+{
+	struct command_handle* c = hub_malloc_zero(sizeof(struct command_handle));
+	c->prefix = prefix;
+	c->length = strlen(prefix);
+	c->args = args;
+	c->cred = cred;
+	c->handler = test_handler;
+	c->description = "A handler added by autotest.";
+	c->origin = "exotic test";
+	c->ptr = &c->ptr;
+	return c;
+}
+
+EXO_TEST(command_setup_user, {
+	memset(&user, 0, sizeof(user));
+	user.id.sid = 1;
+	strcpy(user.id.nick, "tester");
+	strcpy(user.id.cid, "3AGHMAASJA2RFNM22AA6753V7B7DYEPNTIWHBAY");
+	user.credentials = auth_cred_guest;
+	return 1;
+});
+
+#define ADD_TEST(var, prefix, args, cred) \
+	var = create_handler(prefix, args, cred); \
+	if (!command_add(cbase, var, NULL)) \
+		return 0;
+
+#define DEL_TEST(var) \
+		if (var) \
+		{ \
+			if (!command_del(cbase, var)) \
+				return 0; \
+			hub_free(var); \
+			var = NULL; \
+		}
+
+EXO_TEST(command_create, {
+	ADD_TEST(c_test1, "test1", "", auth_cred_guest);
+	ADD_TEST(c_test2, "test2", "", auth_cred_operator);
+	ADD_TEST(c_test3, "test3", "N?N?N", auth_cred_guest);
+	ADD_TEST(c_test4, "test4", "u", auth_cred_guest);
+	ADD_TEST(c_test5, "test5", "i", auth_cred_guest);
+	ADD_TEST(c_test6, "test6", "?c", auth_cred_guest);
+	ADD_TEST(c_test6, "test7", "C", auth_cred_guest);
+	return 1;
+});
+
+extern void command_destroy(struct hub_command* cmd);
+
+static int verify(const char* str, enum command_parse_status expected)
+{
+	struct hub_command* cmd = command_parse(cbase, hub, &user, str);
+	enum command_parse_status status = cmd->status;
+	command_free(cmd);
+	return status == expected;
+}
+
+static struct hub_command_arg_data* verify_argument(struct hub_command* cmd, enum hub_command_arg_type type)
+{
+	return  hub_command_arg_next(cmd, type);
+}
+
+static int verify_arg_integer(struct hub_command* cmd, int expected)
+{
+	struct hub_command_arg_data* data = verify_argument(cmd, type_integer);
+	return data->data.integer == expected;
+}
+
+static int verify_arg_user(struct hub_command* cmd, struct hub_user* expected)
+{
+	struct hub_command_arg_data* data = verify_argument(cmd, type_user);
+	return data->data.user == expected;
+}
+
+static int verify_arg_cred(struct hub_command* cmd, enum auth_credentials cred)
+{
+	struct hub_command_arg_data* data = verify_argument(cmd, type_credentials);
+	return data->data.credentials == cred;
+}
+
+
+EXO_TEST(command_access_1, { return verify("!test1", cmd_status_ok); });
+EXO_TEST(command_access_2, { return verify("!test2", cmd_status_access_error); });
+EXO_TEST(command_access_3, { user.credentials = auth_cred_operator; return verify("!test2", cmd_status_ok); });
+
+EXO_TEST(command_syntax_1, { return verify("", cmd_status_syntax_error); });
+EXO_TEST(command_syntax_2, { return verify("!", cmd_status_syntax_error); });
+
+EXO_TEST(command_missing_args_1, { return verify("!test3", cmd_status_missing_args); });
+EXO_TEST(command_missing_args_2, { return verify("!test3 12345", cmd_status_ok); });
+EXO_TEST(command_missing_args_3, { return verify("!test3 1 2 345", cmd_status_ok); });
+EXO_TEST(command_number_1, { return verify("!test3 abc", cmd_status_arg_number); });
+EXO_TEST(command_number_2, { return verify("!test3 -", cmd_status_arg_number); });
+EXO_TEST(command_number_3, { return verify("!test3 -12", cmd_status_ok); });
+
+EXO_TEST(command_user_1, { return verify("!test4 tester", cmd_status_arg_nick); });
+EXO_TEST(command_user_2, { return verify("!test5 3AGHMAASJA2RFNM22AA6753V7B7DYEPNTIWHBAY", cmd_status_arg_cid); });
+EXO_TEST(command_user_3, { return uman_add(hub->users, &user) == 0; });
+EXO_TEST(command_user_4, { return verify("!test4 tester", cmd_status_ok); });
+EXO_TEST(command_user_5, { return verify("!test5 3AGHMAASJA2RFNM22AA6753V7B7DYEPNTIWHBAY", cmd_status_ok); });
+
+EXO_TEST(command_command_1, { return verify("!test6 test1", cmd_status_ok); });
+EXO_TEST(command_command_2, { return verify("!test6 test2", cmd_status_ok); });
+EXO_TEST(command_command_3, { return verify("!test6 test3", cmd_status_ok); });
+EXO_TEST(command_command_4, { return verify("!test6 test4", cmd_status_ok); });
+EXO_TEST(command_command_5, { return verify("!test6 test5", cmd_status_ok); });
+EXO_TEST(command_command_6, { return verify("!test6 test6", cmd_status_ok); });
+EXO_TEST(command_command_7, { return verify("!test6 fail", cmd_status_arg_command); });
+EXO_TEST(command_command_8, { return verify("!test6", cmd_status_ok); });
+
+EXO_TEST(command_cred_1, { return verify("!test7 guest", cmd_status_ok); });
+EXO_TEST(command_cred_2, { return verify("!test7 user", cmd_status_ok); });
+EXO_TEST(command_cred_3, { return verify("!test7 operator", cmd_status_ok); });
+EXO_TEST(command_cred_4, { return verify("!test7 super", cmd_status_ok); });
+EXO_TEST(command_cred_5, { return verify("!test7 admin", cmd_status_ok); });
+EXO_TEST(command_cred_6, { return verify("!test7 nobody", cmd_status_arg_cred); });
+EXO_TEST(command_cred_7, { return verify("!test7 bot", cmd_status_ok); });
+EXO_TEST(command_cred_8, { return verify("!test7 link", cmd_status_ok); });
+
+
+#if 0
+	cmd_status_arg_cred,       /** <<< "A credentials argument is not valid ('C')" */
+};
+#endif
+
+// command not found
+EXO_TEST(command_parse_3, { return verify("!fail", cmd_status_not_found); });
+
+// built-in command
+EXO_TEST(command_parse_4, { return verify("!help", cmd_status_ok); });
+
+
+#define SETUP_COMMAND(string) \
+	do { \
+		if (cmd) command_free(cmd); \
+		cmd = command_parse(cbase, hub, &user, string); \
+	} while(0)
+
+EXO_TEST(command_argument_integer_1, {
+	SETUP_COMMAND("!test3");
+	return verify_argument(cmd, type_integer) == NULL;
+});
+
+EXO_TEST(command_argument_integer_2, {
+	SETUP_COMMAND("!test3 10 42");
+	return verify_arg_integer(cmd, 10) && verify_arg_integer(cmd, 42) && verify_argument(cmd, type_integer) == NULL;
+});
+
+EXO_TEST(command_argument_integer_3, {
+	SETUP_COMMAND("!test3 10 42 6784");
+	return verify_arg_integer(cmd, 10) && verify_arg_integer(cmd, 42) && verify_arg_integer(cmd, 6784);
+});
+
+EXO_TEST(command_argument_user_1, {
+	SETUP_COMMAND("!test4 tester");
+	return verify_arg_user(cmd, &user) ;
+});
+
+EXO_TEST(command_argument_cid_1, {
+	SETUP_COMMAND("!test5 3AGHMAASJA2RFNM22AA6753V7B7DYEPNTIWHBAY");
+	return verify_arg_user(cmd, &user) ;
+});
+
+EXO_TEST(command_argument_cred_1, {
+	SETUP_COMMAND("!test7 admin");
+	return verify_arg_cred(cmd, auth_cred_admin);;
+});
+
+EXO_TEST(command_argument_cred_2, {
+	SETUP_COMMAND("!test7 op");
+	return verify_arg_cred(cmd, auth_cred_operator);;
+});
+
+EXO_TEST(command_argument_cred_3, {
+	SETUP_COMMAND("!test7 operator");
+	return verify_arg_cred(cmd, auth_cred_operator);
+});
+
+EXO_TEST(command_argument_cred_4, {
+	SETUP_COMMAND("!test7 super");
+	return verify_arg_cred(cmd, auth_cred_super);
+});
+
+EXO_TEST(command_argument_cred_5, {
+	SETUP_COMMAND("!test7 guest");
+	return verify_arg_cred(cmd, auth_cred_guest);
+});
+
+EXO_TEST(command_argument_cred_6, {
+	SETUP_COMMAND("!test7 user");
+	return verify_arg_cred(cmd, auth_cred_user);
+});
+
+#undef SETUP_COMMAND
+
+EXO_TEST(command_user_destroy, { return uman_remove(hub->users, &user) == 0; });
+
+EXO_TEST(command_destroy, {
+
+	command_free(cmd);
+	cmd = NULL;
+
+	DEL_TEST(c_test1);
+	DEL_TEST(c_test2);
+	DEL_TEST(c_test3);
+	DEL_TEST(c_test4);
+	DEL_TEST(c_test5);
+	DEL_TEST(c_test6);
+	DEL_TEST(c_test7);
+	return 1;
+});
+
+EXO_TEST(cleanup, {
+	uman_shutdown(hub->users);
+	command_shutdown(hub->commands);
+	hub_free(hub);
+	return 1;
+});

autotest/test_credentials.tcc

@@ -0,0 +1,24 @@
+#include <uhub.h>
+
+EXO_TEST(cred_to_string_1, { return !strcmp(auth_cred_to_string(auth_cred_none),     "none");     });
+EXO_TEST(cred_to_string_2, { return !strcmp(auth_cred_to_string(auth_cred_bot),      "bot");      });
+EXO_TEST(cred_to_string_3, { return !strcmp(auth_cred_to_string(auth_cred_guest),    "guest");    });
+EXO_TEST(cred_to_string_4, { return !strcmp(auth_cred_to_string(auth_cred_user),     "user");     });
+EXO_TEST(cred_to_string_5, { return !strcmp(auth_cred_to_string(auth_cred_operator), "operator"); });
+EXO_TEST(cred_to_string_6, { return !strcmp(auth_cred_to_string(auth_cred_super),    "super");    });
+EXO_TEST(cred_to_string_7, { return !strcmp(auth_cred_to_string(auth_cred_link),     "link");     });
+EXO_TEST(cred_to_string_8, { return !strcmp(auth_cred_to_string(auth_cred_admin),    "admin");    });
+
+#define CRED_FROM_STRING(STR, EXPECT) enum auth_credentials cred; return auth_string_to_cred(STR, &cred) && cred == EXPECT;
+
+EXO_TEST(cred_from_string_1,  { CRED_FROM_STRING("none",     auth_cred_none);     });
+EXO_TEST(cred_from_string_2,  { CRED_FROM_STRING("bot",      auth_cred_bot);      });
+EXO_TEST(cred_from_string_3,  { CRED_FROM_STRING("guest",    auth_cred_guest);    });
+EXO_TEST(cred_from_string_4,  { CRED_FROM_STRING("user",     auth_cred_user);     });
+EXO_TEST(cred_from_string_5,  { CRED_FROM_STRING("reg",      auth_cred_user);     });
+EXO_TEST(cred_from_string_6,  { CRED_FROM_STRING("operator", auth_cred_operator); });
+EXO_TEST(cred_from_string_7,  { CRED_FROM_STRING("op",       auth_cred_operator); });
+EXO_TEST(cred_from_string_8,  { CRED_FROM_STRING("super",    auth_cred_super);    });
+EXO_TEST(cred_from_string_9,  { CRED_FROM_STRING("link",     auth_cred_link);     });
+EXO_TEST(cred_from_string_10, { CRED_FROM_STRING("admin",    auth_cred_admin);    });
+

autotest/test_inf.tcc

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

autotest/test_ipfilter.tcc

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

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

autotest/test_rbtree.tcc

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

autotest/test_tokenizer.tcc

@@ -0,0 +1,110 @@
+#include <uhub.h>
+
+#define SETUP(X, STR) struct cfg_tokens* tokens = cfg_tokenize(STR)
+#define CLEANUP_LIST(X) do { list_clear(X, hub_free); list_destroy(X); } while(0)
+#define CLEANUP_TOKENS(X) do { cfg_tokens_free(X); } while(0)
+
+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';
+
+	ret = strcmp(str1, str2);
+	if (ret) {
+		fprintf(stderr, "\n    Mismatch: \"%s\" != \"%s\"\n", str1, str2);
+	}
+	return ret;
+}
+
+static int count(const char* STR, size_t EXPECT) {
+	SETUP(tokens, STR);
+	int pass = cfg_token_count(tokens) == EXPECT;
+	CLEANUP_TOKENS(tokens);
+	return pass;
+}
+
+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);
+	pass = cfg_token_count(tokens) == list_size(compare);
+	if (pass) {
+		max = cfg_token_count(tokens);
+		for (i = 0; i < max; i++) {
+			char* token = (char*) cfg_token_get(tokens, i);
+			char* refer = (char*) list_get_index(compare, i);
+			if (match_str(token, refer)) {
+				pass = 0;
+				break;
+			}
+		}
+	}
+	CLEANUP_TOKENS(tokens);
+	CLEANUP_LIST(compare);
+	return pass;
+}
+
+EXO_TEST(tokenizer_basic_0,  { return count("", 0); });
+EXO_TEST(tokenizer_basic_1,  { return count("a", 1); });
+EXO_TEST(tokenizer_basic_1a, { return count(" a", 1); })
+EXO_TEST(tokenizer_basic_1b, { return count("\ta", 1); })
+EXO_TEST(tokenizer_basic_1c, { return count("      a", 1); })
+EXO_TEST(tokenizer_basic_1d, { return count(" a ", 1); })
+EXO_TEST(tokenizer_basic_1e, { return count("  a  ", 1); })
+EXO_TEST(tokenizer_basic_2,  { return count("a b", 2); });
+EXO_TEST(tokenizer_basic_2a, { return count("  a   b  ", 2); });
+EXO_TEST(tokenizer_basic_3,  { return count("a b c", 3); });
+EXO_TEST(tokenizer_basic_3a, { return count("a b   c", 3); });
+EXO_TEST(tokenizer_basic_3b, { return count("a b\tc", 3); });
+EXO_TEST(tokenizer_basic_3c, { return count("a b c ", 3); });
+EXO_TEST(tokenizer_basic_3d, { return count("a b c   ", 3); });
+
+EXO_TEST(tokenizer_basic_compare_0, { return compare("value1 value2 value3", "value1 value2 value3"); });
+EXO_TEST(tokenizer_basic_compare_1, { return compare("a b c", "a b c"); });
+EXO_TEST(tokenizer_basic_compare_2, { return compare("a b    c", "a b c"); });
+EXO_TEST(tokenizer_basic_compare_3, { return compare("   a	 b    c", "a b c"); });
+EXO_TEST(tokenizer_basic_compare_4, { return compare("   a	 b    c    ", "a b c"); });
+EXO_TEST(tokenizer_basic_compare_5, { return compare("a	b c ", "a b c"); });
+EXO_TEST(tokenizer_basic_compare_6, { return compare("a	b c  ", "a b c"); });
+
+EXO_TEST(tokenizer_comment_1, { return compare("value1 value2 # value3", "value1 value2"); });
+EXO_TEST(tokenizer_comment_2, { return compare("value1 value2\\# value3", "value1 value2# value3"); });
+EXO_TEST(tokenizer_comment_3, { return compare("value1 \"value2#\" value3", "value1 value2# value3"); });
+
+EXO_TEST(tokenizer_escape_1, { return compare("\"value1\" value2", "value1 value2"); });
+EXO_TEST(tokenizer_escape_2, { return compare("\"value1\\\"\" value2", "value1\" value2"); });
+EXO_TEST(tokenizer_escape_3, { return compare("\"value1\" \"value 2\"", "value1 value_2"); });
+EXO_TEST(tokenizer_escape_4, { return compare("\"value1\" value\\ 2", "value1 value_2"); });
+EXO_TEST(tokenizer_escape_5, { return compare("\"value1\" value\\\\2", "value1 value\\2"); });
+EXO_TEST(tokenizer_escape_6, { return compare("\"value1\" value\\\t2", "value1 value|2"); });
+EXO_TEST(tokenizer_escape_7, { return compare("\"value1\" \"value\t2\"", "value1 value|2"); });
+
+static int test_setting(const char* str, const char* expected_key, const char* expected_value)
+{
+	int success = 0;
+	struct cfg_settings* setting = cfg_settings_split(str);
+	if (!setting) return expected_key == NULL;
+	success = (!strcmp(cfg_settings_get_key(setting), expected_key) && !strcmp(cfg_settings_get_value(setting), expected_value));
+	cfg_settings_free(setting);
+	return success;
+}
+
+EXO_TEST(tokenizer_settings_1, { return test_setting("foo=bar", "foo", "bar"); });
+EXO_TEST(tokenizer_settings_2, { return test_setting("foo =bar", "foo", "bar"); });
+EXO_TEST(tokenizer_settings_3, { return test_setting("foo= bar", "foo", "bar"); });
+EXO_TEST(tokenizer_settings_4, { return test_setting("\tfoo=bar", "foo", "bar"); });
+EXO_TEST(tokenizer_settings_5, { return test_setting("foo=bar\t", "foo", "bar"); });
+EXO_TEST(tokenizer_settings_6, { return test_setting("\tfoo=bar\t", "foo", "bar"); });
+EXO_TEST(tokenizer_settings_7, { return test_setting("\tfoo\t=\tbar\t", "foo", "bar"); });
+EXO_TEST(tokenizer_settings_8, { return test_setting("foo=", "foo", ""); });
+EXO_TEST(tokenizer_settings_9, { return test_setting("=bar", NULL, ""); });
+
+

autotest/test_usermanager.tcc

@@ -2,32 +2,19 @@
 
 #define MAX_USERS 64
 
-static struct hub_info um_hub;
+static struct hub_user_manager* uman = 0;
 static struct hub_user um_user[MAX_USERS];
-// static struct net_connection um_cons[MAX_USERS];
-
-EXO_TEST(um_test_setup, {
-	int i = 0;
-	memset(&um_hub,  0, sizeof(um_hub));
-	
-	for (i = 0; i < MAX_USERS; i++)
-	{
-/*		memset(&um_cons[i], 0, sizeof(struct net_connection));
-		um_cons[i].sd = -1;
-
-		memset(&um_user[i], 0, sizeof(struct hub_user));
-		um_user[i].id.sid = i+1;
-		um_user[i].connection = &um_cons[i];*/
-	}
-	return 1;
-});
 
 EXO_TEST(um_init_1, {
-	return uman_init(0) != 0;
-});
-
-EXO_TEST(um_init_2, {
-	return uman_init(&um_hub) == 0;
+	sid_t s;
+	uman = uman_init();
+	
+	for (s = 0; s < MAX_USERS; s++)
+	{
+		memset(&um_user[s], 0, sizeof(struct hub_user));
+		um_user[s].id.sid = s;
+	}
+	return !!uman;
 });
 
 EXO_TEST(um_shutdown_1, {
@@ -35,32 +22,29 @@ EXO_TEST(um_shutdown_1, {
 });
 
 EXO_TEST(um_shutdown_2, {
-	return uman_shutdown(&um_hub) == 0;
+	return uman_shutdown(uman) == 0;
 });
 
-EXO_TEST(um_shutdown_3, {
-	return uman_shutdown(&um_hub) == -1;
-});
-
-EXO_TEST(um_init_3, {
-	return uman_init(&um_hub) == 0;
+EXO_TEST(um_init_2, {
+	uman = uman_init();
+	return !!uman;
 });
 
 EXO_TEST(um_add_1, {
-	return uman_add(&um_hub, &um_user[0]) == 0;
+	return uman_add(uman, &um_user[0]) == 0;
 });
 
 EXO_TEST(um_size_1, {
-	return hub_get_user_count(&um_hub) == 1;
+	return uman->count == 1;
 });
 
 
 EXO_TEST(um_remove_1, {
-	return uman_remove(&um_hub, &um_user[0]) == 0;
+	return uman_remove(uman, &um_user[0]) == 0;
 });
 
 EXO_TEST(um_size_2, {
-	return hub_get_user_count(&um_hub) == 0;
+	return uman->count == 0;
 });
 
 
@@ -68,25 +52,21 @@ EXO_TEST(um_add_2, {
 	int i;
 	for (i = 0; i < MAX_USERS; i++)
 	{
-		if (uman_add(&um_hub, &um_user[i]) != 0)
+		if (uman_add(uman, &um_user[i]) != 0)
 			return 0;
 	}
 	return 1;
 });
 
 EXO_TEST(um_size_3, {
-	return hub_get_user_count(&um_hub) == MAX_USERS;
-});
-
-EXO_TEST(um_add_3, {
-	return uman_add(&um_hub, &um_user[5]) != 0;
+	return uman->count == MAX_USERS;
 });
 
 EXO_TEST(um_remove_2, {
 	int i;
 	for (i = 0; i < MAX_USERS; i++)
 	{
-		if (uman_remove(&um_hub, &um_user[i]) != 0)
+		if (uman_remove(uman, &um_user[i]) != 0)
 			return 0;
 	}
 	return 1;
@@ -105,5 +85,5 @@ EXO_TEST(um_remove_2, {
 
 /* Last test */
 EXO_TEST(um_shutdown_4, {
-	return uman_shutdown(&um_hub) == 0;
+	return uman_shutdown(uman) == 0;
 });

autotest/update.sh

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

debian/changelog

@@ -2,13 +2,13 @@ uhub (0.3.2-1) unstable; urgency=low
 
   * Updated upstream version.
 
- -- Jan Vidar Krey <janvidar@extatic.org>  Mon 30 May 2010 18:00:00 +0200
+ -- Jan Vidar Krey <janvidar@extatic.org>  Mon, 30 May 2010 18:00:00 +0200
 
 uhub (0.3.1-1) unstable; urgency=low
 
   * Updated version number.
 
- -- Jan Vidar Krey <janvidar@extatic.org>  Mon 04 Apr 2010 16:44:21 +0200
+ -- Jan Vidar Krey <janvidar@extatic.org>  Mon, 04 Apr 2010 16:44:21 +0200
 
 uhub (0.3.0-2) unstable; urgency=low
 

debian/rules

@@ -24,7 +24,7 @@ binary-indep: build
 binary-arch: build
 	dh_testdir
 	dh_testroot
-	dh_clean -k
+	dh_prep
 	dh_installdirs
 	$(MAKE) install $(makeopts)
 	dh_installdocs

debian/uhub.init

@@ -5,7 +5,8 @@
 # Required-Stop:     $remote_fs $network
 # Default-Start:     2 3 4 5
 # Default-Stop:      0 1 6
-# Short-Description: uhub - High performance ADC p2p hub.
+# Short-Description: Start daemon at boot time
+# Description:       Enable service provided by daemon.
 ### END INIT INFO
 
 PATH=/sbin:/bin:/usr/sbin:/usr/bin
@@ -83,8 +84,12 @@ case "$1" in
 		$0 start
 		;;
 
+	status)
+		status_of_proc $DAEMON $NAME && exit 0 || exit $?
+		;;
+
 	*)
-		echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2
+		echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload|status}" >&2
 		exit 1
 		;;
 esac

debian/uhub.manpages

@@ -1 +1,2 @@
 doc/uhub.1
+doc/uhub-passwd.1

doc/architecture.txt

@@ -1,13 +1,13 @@
 = Architecture of uHub =
 
-uHub is single threaded and handles network and timer events using the 
+uHub is single-threaded and handles network and timer events using the
 libevent library.
 For each state there is a read event (and sometimes a write event) and timeout
 event in case an expected read (or write) event does not occur.
 
 
 == Protocol overview ==
-uHub use "speak" the ADC protocol, which works in short as follows:
+uHub "speaks" the ADC protocol, which works in short as follows:
 (C = client, S = server aka uHub).
 
 C: HSUP ADBASE

doc/compile.txt

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

doc/extensions.txt

@@ -31,7 +31,7 @@ The hub should send a packet containing the token back:
 'IECH {token} {host:port}', aswell 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 icomming communication.
+If the client receives the message via TCP only it knows it has a firewall blocking incomming 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/init.d.RedHat/etc/init.d/uhub

@@ -1,7 +1,7 @@
 #!/bin/sh
 #
 # chkconfig: - 91 35
-# description: Starts and stops the Uhub ( http://www.extatic.org/uhub ) daemons on RHEL\CentOS \
+# description: Starts and stops the Uhub ( http://www.uhub.org ) daemons on RHEL\CentOS \
 #	       used to provide p2p network services.
 #
 # pidfile: /var/run/uhub.pid
@@ -31,7 +31,8 @@ fi
 # Check that networking is up.
 [ ${NETWORKING} = "no" ] && exit 1
 
-# Check that uhub.conf exists.
+# Check that bin and uhub.conf exists.
+[ -f $UHUBBINFILE ] || exit 6
 [ -f /etc/uhub/uhub.conf ] || exit 6
 
 RETVAL=0
@@ -40,7 +41,7 @@ RETVAL=0
 start() {
         KIND="Uhub"
 	echo -n $"Starting $KIND services: "
-	daemon uhub $UHUBOPTIONS
+	daemon $UHUBBINFILE $UHUBOPTIONS
 	RETVAL=$?
         echo "" 
 	return $RETVAL
@@ -49,7 +50,7 @@ start() {
 stop() {
         KIND="Uhub"
 	echo -n $"Shutting down $KIND services: "
-	killproc uhub
+	killproc  $UHUBBINFILE
 	RETVAL=$?
 	echo ""
 	return $RETVAL
@@ -68,13 +69,21 @@ reload() {
 	return $RETVAL
 }	
 
+relog() {
+    echo -n $"Reopen main log file: "
+     killproc uhub -SIGHUP
+     RETVAL=$?
+     echo ""
+     return $RETVAL
+}
+
 rhstatus() {
-	status uhub                                                                                                                                                   
-        RETVAL=$?                                                                                                                                                     
-        if [ $RETVAL -ne 0 ] ; then                                                                                                                                   
-                return $RETVAL                                                                                                                                        
-        fi                                                                                                                                                            
-}                 
+	status  $UHUBBINFILE
+        RETVAL=$?
+        if [ $RETVAL -ne 0 ] ; then
+                return $RETVAL
+        fi
+}
 
 
 case "$1" in
@@ -90,11 +99,14 @@ case "$1" in
   reload)
   	reload
 	;;
+  relog)
+	relog
+	;;
   status)
   	rhstatus
 	;;
   *)
-	echo $"Usage: $0 {start|stop|restart|reload|status}"
+	echo $"Usage: $0 {start|stop|restart|reload|relog|status}"
 	exit 2
 esac
 

doc/init.d.RedHat/etc/sysconfig/uhub

@@ -1,3 +1,6 @@
+# locate bin file
+UHUBBINFILE=/usr/bin/uhub
+
 # Options to UHUB
 #  -v          Verbose mode. Add more -v's for higher verbosity.
 #  -q          Quiet mode - no output

doc/plugins.conf

@@ -0,0 +1,62 @@
+# ATTENTION!
+# Plugins are invoked in the order of listing in the plugin config file.
+
+
+# Sqlite based user authentication.
+#
+# This plugin provides a Sqlite based authentication database for
+# registered users.
+# Use the uhub-passwd utility to create the database and add/remove users.
+#
+# Parameters:
+# file: path/filename for database.
+#
+plugin /usr/lib/uhub/mod_auth_sqlite.so "file=/etc/uhub/users.db"
+
+
+# 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 /usr/lib/uhub/mod_logging.so "file=/var/log/uhub.log"
+
+# A simple example plugin
+# plugin /usr/lib/uhub/mod_example.so
+# A plugin sending a welcome message.
+#
+# This plugin provides the following commands:
+# !motd - Message of the day
+# !rules - Show hub rules.
+#
+# Parameters:
+# motd: path/filename for the welcome message (message of the day)
+# rules: path/filenam for the rules file
+#
+# NOTE: The files MUST exist, however if you do not wish to provide one then these parameters can be omitted.
+#
+# The motd/rules files can do the following substitutions:
+# %n - Nickname of the user who entered the hub or issued the command.
+# %a - IP address of the user
+# %c - The credentials of the user (guest, user, op, super, admin).
+# %% - Becomes '%'
+# %H - Hour 24-hour format (00-23) (Hub local time)
+# %I - Hour 12-hour format (01-12) (Hub local time)
+# %P - 'AM' or 'PM'
+# %p - 'am' or 'pm'
+# %M - Minutes (00-59) (Hub local time)
+# %S - Seconds (00-60) (Hub local time)
+plugin /usr/lib/uhub/mod_welcome.so "motd=/etc/uhub/motd.txt rules=/etc/uhub/rules.txt"
+
+# Load the chat history plugin.
+#
+# This plugin provides chat history when users are connecting, or
+# when users invoke the !history command.
+# The history command can optionally take a parameter to indicate how many lines of history is requested.
+#
+# Parameters:
+# 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 /usr/lib/uhub/mod_chat_history.so "history_max=200 history_default=10 history_connect=5"
+

doc/uhub-passwd.1

@@ -0,0 +1,42 @@
+.TH UHUB-PASSWD "1" "May 2012"
+.SH NAME
+uhub-passwd \- small utility for manipulating passwords which are
+used by uhub daemon
+.SH SYNOPSIS
+.B uhub-passwd
+\fIfilename command \fR[...]
+.SH DESCRIPTION
+uHub is a high performance peer-to-peer hub for the ADC network.
+Its low memory footprint allows it to handle several thousand users
+on high-end servers, or a small private hub on embedded hardware.
+.SH "OPTIONS"
+.TP
+.BI \^create
+.TP
+.BI \^add " username password [credentials = user]"
+.TP
+.BI \^del " username"
+.TP
+.BI \^mod " username credentials"
+.TP
+.BI \^pass " username password"
+.TP
+.BI \^list
+.SH "PARAMETERS"
+.TP
+.B 'filename'
+is a database file
+.TP
+.B 'username'
+is a nickname (UTF\-8, up to 64 bytes)
+.TP
+.B 'password'
+is a password (UTF\-8, up to 64 bytes)
+.TP
+.B 'credentials'
+is one of 'admin', 'super', 'op', 'user'
+.SH AUTHOR
+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/

doc/uhub.1

@@ -23,7 +23,7 @@ on high-end servers, or a small private hub on embedded hardware.
 .SH "OPTIONS"
 .TP
 .BI \^\-v
-Verbose mode, add more -v's for higher verbosity.
+Verbose mode, add more \-v's for higher verbosity.
 .TP
 .BI \^\-q 
 Quiet mode, if quiet mode is enabled no output or logs are made.

doc/uhub.conf

@@ -1,6 +1,6 @@
 # uhub.conf - A example configuration file.
 # You should normally place this file in /etc/uhub/uhub.conf
-# And change the file_acl and file_motd below.
+# and customize some of the settings below.
 #
 # This file is read only to the uhub deamon, and if you
 # make changes to it while uhub is running you can send a
@@ -38,17 +38,8 @@ hub_enabled=1
 # Access control list (user database)
 file_acl=/etc/uhub/users.conf
 
-# This file can contain a message of the day. A welcome
-# message send to any client when connecting.
-# If the file does not exist, is empty, or cannot be opened
-# the motd will not be sent to the clients.
-# Normally this message is sent to clients when connecting.
-file_motd=/etc/uhub/motd.txt
-
-# This file can contain a rules of the hub.
-# Normally this message is sent to clients when write in chat !rules
-file_rules=/etc/uhub/rules.txt
-
+# This file can contain a conf for plugin subsystem
+file_plugins = /etc/uhub/plugins.conf
 
 # Slots/share/hubs limits
 limit_max_hubs_user = 0
@@ -82,9 +73,6 @@ flood_ctl_extras=5
 # if chat_is_privileged=yes only registered users may write in main chat
 chat_is_privileged = no
 
-# if chat_only = yes then search and transfer functionality is disabled for
-# non-operator users.
-chat_only = no
 
 # if obsolete_clients=1 allows old clients to enter , 0 gives an error message (msg_proto_obsolete_adc0) if they try connect
 # defaults obsolete_clients=1

doc/uhub.spec

@@ -1,13 +1,15 @@
 Summary: High performance ADC p2p hub.
 Name: uhub
-Version: 0.3.2
-Release: 3
+Version: 0.4.0
+Release: 2
 License: GPLv3
 Group: Networking/File transfer
 Source: uhub-%{version}.tar.gz
 URL: http://www.uhub.org
 BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root
 
+BuildRequires: sqlite-devel
+BuildRequires: openssl-devel
 
 %description
 uhub is a high performance peer-to-peer hub for the ADC network.
@@ -20,7 +22,10 @@ Key features:
 - Experimental SSL support (optional)
 - Advanced access control support
 - Easy configuration
-
+- plugin support
+ - mod_welcome  - MOTD\RULES messages
+ - mod_auth_sipmle - auth with sqlite DB
+ - mod_logging - log hub activity
 
 %prep
 %setup -q -n %{name}-%{version}
@@ -36,15 +41,18 @@ 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/usr/lib/uhub
 
 install uhub $RPM_BUILD_ROOT/usr/bin/
+install uhub-passwd $RPM_BUILD_ROOT/usr/bin/
 > doc/motd.txt
-install -m644 doc/uhub.conf doc/users.conf doc/rules.txt doc/motd.txt $RPM_BUILD_ROOT/etc/uhub
+install -m644 doc/uhub.conf doc/users.conf doc/rules.txt doc/motd.txt doc/plugins.conf doc/users.db $RPM_BUILD_ROOT/etc/uhub
 install doc/init.d.RedHat/etc/init.d/uhub $RPM_BUILD_ROOT/etc/init.d
 install -m644 doc/init.d.RedHat/etc/sysconfig/uhub  $RPM_BUILD_ROOT/etc/sysconfig/
 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/usr/lib/uhub
 
 
 %files
@@ -55,12 +63,14 @@ install -m644 doc/uhub.1.gz $RPM_BUILD_ROOT/usr/share/man/man1
 %config(noreplace) %{_sysconfdir}/uhub/users.conf
 %config(noreplace) %{_sysconfdir}/uhub/motd.txt
 %config(noreplace) %{_sysconfdir}/uhub/rules.txt
+%config(noreplace) %{_sysconfdir}/uhub/plugins.conf
+%config(noreplace) %{_sysconfdir}/uhub/users.db
 %{_sysconfdir}/init.d/uhub
 %config(noreplace) %{_sysconfdir}/logrotate.d/uhub
 %config(noreplace) %{_sysconfdir}/sysconfig/uhub
 /usr/share/man/man1/uhub.1.gz
 %{_bindir}/uhub
-
+%{_libdir}/uhub/mod_*.so
 
 %clean
 rm -rf $RPM_BUILD_ROOT
@@ -72,8 +82,15 @@ if [ $1 -gt 1 ] ; then
 fi
 # need more informations 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/"
 
 %changelog
+* Fri Dec 30 2011 E_zombie
+- add users.db 
+- add new doc
+* Tue Jun 26 2010 E_zombie
+- add plugins.conf
 * Tue Jan 31 2010 E_zombie
 - change GROUP
 - chmod for files

doc/upstart/etc/init/uhub.conf

@@ -0,0 +1,28 @@
+# uHub - a lightweight but high-performance hub for the ADC
+#        peer-to-peer protocol.
+
+description "uHub - High performance ADC peer-to-peer hub"
+
+# Start and stop conditions.
+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.
+respawn
+respawn limit 10 5
+
+# The program is going to fork, and upstart needs to know this
+# so it can track the change in PID.
+expect fork
+
+# Set the mode the process should create files in.
+umask 022
+
+# Make sure the log folder exists.
+pre-start script
+    mkdir -p -m0755 /var/log/uhub
+end script
+
+# Command to run it.
+exec /usr/bin/uhub -f -u uhub -g uhub -l /var/log/uhub/uhub.log -c /etc/uhub/uhub.conf

src/adc/adcconst.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,7 +20,11 @@
 #ifndef HAVE_UHUB_ADC_CONSTANTS_H
 #define HAVE_UHUB_ADC_CONSTANTS_H
 
+#ifndef SID_T_DEFINED
 typedef uint32_t sid_t;
+#define SID_T_DEFINED
+#endif
+
 typedef uint32_t fourcc_t;
 
 /* Internal uhub limit */
@@ -29,7 +33,7 @@ typedef uint32_t fourcc_t;
 #define FOURCC(a,b,c,d) (fourcc_t) ((a << 24) | (b << 16) | (c << 8) | d)
 
 /* default welcome protocol support message, as sent by this server */
-#define ADC_PROTO_SUPPORT "ADBASE ADTIGR ADPING"
+#define ADC_PROTO_SUPPORT "ADBASE ADTIGR ADPING ADUCMD"
 
 /* Server sent commands */
 #define ADC_CMD_ISID FOURCC('I','S','I','D')
@@ -60,6 +64,11 @@ typedef uint32_t fourcc_t;
 #define ADC_CMD_FSCH FOURCC('F','S','C','H')
 #define ADC_CMD_DRES FOURCC('D','R','E','S')
 
+/* invalid search results (spam) */
+#define ADC_CMD_BRES FOURCC('B','R','E','S')
+#define ADC_CMD_ERES FOURCC('E','R','E','S')
+#define ADC_CMD_FRES FOURCC('F','R','E','S')
+
 /* connection setup */
 #define ADC_CMD_DCTM FOURCC('D','C','T','M')
 #define ADC_CMD_DRCM FOURCC('D','R','C','M')
@@ -76,10 +85,23 @@ typedef uint32_t fourcc_t;
 #define ADC_CMD_DINF FOURCC('D','I','N','F')
 #define ADC_CMD_EINF FOURCC('E','I','N','F')
 #define ADC_CMD_FINF FOURCC('F','I','N','F')
+#define ADC_CMD_BQUI FOURCC('B','Q','U','I')
+#define ADC_CMD_DQUI FOURCC('D','Q','U','I')
+#define ADC_CMD_EQUI FOURCC('E','Q','U','I')
+#define ADC_CMD_FQUI FOURCC('F','Q','U','I')
 
 /* Extension messages */
 #define ADC_CMD_HCHK FOURCC('H','C','H','K')
 
+/* UCMD Extension */
+#define ADC_CMD_BCMD FOURCC('B','C','M','D')
+#define ADC_CMD_DCMD FOURCC('D','C','M','D')
+#define ADC_CMD_ECMD FOURCC('E','C','M','D')
+#define ADC_CMD_FCMD FOURCC('F','C','M','D')
+#define ADC_CMD_HCMD FOURCC('H','C','M','D')
+#define ADC_CMD_ICMD FOURCC('I','C','M','D')
+
+
 #define ADC_INF_FLAG_IPV4_ADDR          "I4" /* ipv4 address */
 #define ADC_INF_FLAG_IPV6_ADDR          "I6" /* ipv6 address */
 #define ADC_INF_FLAG_IPV4_UDP_PORT      "U4" /* port number */

src/adc/message.c

@@ -63,6 +63,33 @@ static void msg_free(void* ptr)
 #define msg_free(X)         hub_free(X)
 #endif /* MSG_MEMORY_DEBUG */
 
+static int msg_check_escapes(const char* string, size_t len)
+{
+        char* start = (char*) string;
+        while ((start = memchr(start, '\\', len - (start - string))))
+        {
+                if (start+1 == (string + len))
+                        return 0;
+
+                switch (*(++start))
+                {
+                        case '\\':
+                        case 'n':
+                        case 's':
+                                /* Increment so we don't check the escaped
+                                * character next time around. Not doing so
+                                * leads to messages with escaped backslashes
+                                * being incorrectly reported as having invalid
+                                * escapes. */
+                                ++start;
+                                break;
+                        default:
+                                return 0;
+                }
+        }
+        return 1;
+}
+
 
 struct adc_message* adc_msg_incref(struct adc_message* msg)
 {
@@ -127,7 +154,7 @@ static int adc_msg_cache_append(struct adc_message* msg, const char* string, siz
 	memcpy(&msg->cache[msg->length], string, len);
 	adc_msg_set_length(msg, msg->length + len);
 
-	assert(msg->capacity > msg->length);
+	uhub_assert(msg->capacity > msg->length);
 	msg->cache[msg->length] = 0;
 	return 1;
 }
@@ -319,6 +346,13 @@ struct adc_message* adc_msg_parse(const char* line, size_t length)
 		return NULL;
 	}
 
+	if (!msg_check_escapes(line, length))
+	{
+		LOG_DEBUG("Dropped message with invalid ADC escape.");
+		msg_free(command);
+		return NULL;
+	}
+
 	if (line[length-1] != '\n')
 	{
 		need_terminate = 1;
@@ -498,6 +532,30 @@ struct adc_message* adc_msg_create(const char* line)
 	return adc_msg_parse(line, strlen(line));
 }
 
+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 + 1);
+	if (!msg)
+		return NULL;
+
+	adc_msg_add_argument(msg, sid_to_string(source));
+	msg->source = source;
+	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)
 {
@@ -505,9 +563,7 @@ struct adc_message* adc_msg_construct(fourcc_t fourcc, size_t size)
 	if (!msg)
 		return NULL; /* OOM */
 
-	if (size < sizeof(fourcc)) size = sizeof(fourcc);
-
-	if (!adc_msg_grow(msg, size+1))
+	if (!adc_msg_grow(msg, sizeof(fourcc) + size + 1))
 	{
 		msg_free(msg);
 		return NULL; /* OOM */
@@ -600,7 +656,7 @@ int adc_msg_has_named_argument(struct adc_message* cmd, const char prefix_[2])
 	while (start)
 	{
 		count++;
-		if ((&start[0] - &cmd->cache[0]) < 1+cmd->length)
+		if ((size_t) (&start[0] - &cmd->cache[0]) < 1+cmd->length)
 			start = memmem(&start[1], (&cmd->cache[cmd->length] - &start[0]), prefix, 3);
 		else
 			start = NULL;
@@ -877,12 +933,47 @@ char* adc_msg_unescape(const char* string)
 	return new_string;
 }
 
+int adc_msg_unescape_to_target(const char* string, char* target, size_t target_size)
+{
+	size_t w = 0;
+	char* ptr = (char*) target;
+	char* str = (char*) string;
+	int escaped = 0;
+
+	while (*str && w < (target_size-1))
+	{
+		if (escaped) {
+			if (*str == 's')
+				*ptr++ = ' ';
+			else if (*str == '\\')
+				*ptr++ = '\\';
+			else if (*str == 'n')
+				*ptr++ = '\n';
+			else
+				*ptr++ = *str;
+			w++;
+			escaped = 0;
+		} else {
+			if (*str == '\\')
+				escaped = 1;
+			else
+			{
+				*ptr++ = *str;
+				w++;
+			}
+		}
+		str++;
+	}
+	*ptr = 0;
+	w++;
+	return w;
+}
 
 char* adc_msg_escape(const char* string)
 {
 	char* str = hub_malloc(adc_msg_escape_length(string)+1);
-	int n = 0;
-	int i = 0;
+	size_t n = 0;
+	size_t i = 0;
 	for (i = 0; i < strlen(string); i++)
 	{
 		switch (string[i]) {

src/adc/message.h

@@ -91,6 +91,13 @@ extern struct adc_message* adc_msg_create(const char* string);
  */
 extern struct adc_message* adc_msg_construct(fourcc_t fourcc, size_t size);
 
+/**
+ * Construct a message for the given 'fourcc' and add a source SID to it,
+ * 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.
  *
@@ -195,6 +202,14 @@ extern int adc_msg_add_named_argument_uint64(struct adc_message* cmd, const char
  */
 extern char* adc_msg_unescape(const char* string);
 
+/**
+ * Convert a ADC command escaped string to a regular string.
+ * @return The number of bytes written to target. If the target is not large enough then
+ * the -1 is returned, but the string is guaranteed to always be \0 terminated.
+ */
+extern int adc_msg_unescape_to_target(const char* string, char* target, size_t target_size);
+
+
 /**
  * Convert a string to a ADC command escaped string.
  * @return adc command escaped string or NULL if out of memory.

src/adc/sid.c

@@ -119,6 +119,7 @@ void sid_pool_destroy(struct sid_pool* pool)
 
 sid_t sid_alloc(struct sid_pool* pool, struct hub_user* user)
 {
+	sid_t n;
 	if (pool->count >= (pool->max - pool->min))
 	{
 #ifdef DEBUG_SID
@@ -127,7 +128,7 @@ sid_t sid_alloc(struct sid_pool* pool, struct hub_user* user)
 		return 0;
 	}
 
-	sid_t n = (++pool->count);
+	n = (++pool->count);
 	for (; (pool->map[n % pool->max]); n++) ;
 
 #ifdef DEBUG_SID

src/adc/sid.h

@@ -25,7 +25,6 @@
 struct sid_pool;
 struct hub_user;
 
-extern const char* BASE32_ALPHABET;
 extern char* sid_to_string(sid_t sid_);
 extern sid_t string_to_sid(const char* sid);
 

src/core/auth.c

@@ -23,32 +23,13 @@
 #define ACL_ADD_BOOL(S, L)    do { ret = check_cmd_bool(S,    L, line, line_count); if (ret != 0) return ret; } while(0)
 #define ACL_ADD_ADDR(S, L)    do { ret = check_cmd_addr(S,    L, line, line_count); if (ret != 0) return ret; } while(0)
 
-const char* get_user_credential_string(enum user_credentials cred)
-{
-	switch (cred)
-	{
-		case cred_none:         return "none";
-		case cred_bot:          return "bot";
-		case cred_guest:        return "guest";
-		case cred_user:         return "user";
-		case cred_operator:     return "operator";
-		case cred_super:        return "super";
-		case cred_admin:        return "admin";
-		case cred_link:         return "link";
-	}
-	
-	return "";
-};
-
 static int check_cmd_bool(const char* cmd, struct linked_list* list, char* line, int line_count)
 {
 	char* data;
-	char* data_extra;
 	
 	if (!strncmp(line, cmd, strlen(cmd)))
 	{
 		data = &line[strlen(cmd)];
-		data_extra = 0;
 		data[0] = '\0';
 		data++;
 		
@@ -70,30 +51,30 @@ static int check_cmd_user(const char* cmd, int status, struct linked_list* list,
 {
 	char* data;
 	char* data_extra;
-	struct hub_user_access_info* info = 0;
-	
+	struct auth_info* info = 0;
+
 	if (!strncmp(line, cmd, strlen(cmd)))
 	{
 		data = &line[strlen(cmd)];
 		data_extra = 0;
 		data[0] = '\0';
 		data++;
-		
+
 		data = strip_white_space(data);
 		if (!*data)
 		{
 			LOG_FATAL("ACL parse error on line %d", line_count);
 			return -1;
 		}
-		
-		info = hub_malloc_zero(sizeof(struct hub_user_access_info));
-		
+
+		info = hub_malloc_zero(sizeof(struct auth_info));
+
 		if (!info)
 		{
 			LOG_ERROR("ACL parse error. Out of memory!");
 			return -1;
 		}
-		
+
 		if (strncmp(cmd, "user_", 5) == 0)
 		{
 			data_extra = strrchr(data, ':');
@@ -103,12 +84,13 @@ static int check_cmd_user(const char* cmd, int status, struct linked_list* list,
 				data_extra++;
 			}
 		}
-		
-		info->username = hub_strdup(data);
-		info->password = data_extra ? hub_strdup(data_extra) : 0;
-		info->status = status;
+
+		strncpy(info->nickname, data, MAX_NICK_LEN);
+		if (data_extra)
+			strncpy(info->password, data_extra, MAX_PASS_LEN);
+		info->credentials = status;
 		list_append(list, info);
-		LOG_DEBUG("ACL: Added user '%s' (%s)", info->username, get_user_credential_string(info->status));
+		LOG_DEBUG("ACL: Added user '%s' (%s)", info->nickname, auth_cred_to_string(info->credentials));
 		return 1;
 	}
 	return 0;
@@ -187,12 +169,12 @@ 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, cred_bot);
-	ACL_ADD_USER("user_admin", handle->users, cred_admin);
-	ACL_ADD_USER("user_super", handle->users, cred_super);
-	ACL_ADD_USER("user_op",    handle->users, cred_operator);
-	ACL_ADD_USER("user_reg",   handle->users, cred_user);
-	ACL_ADD_USER("link",       handle->users, cred_link);
+	ACL_ADD_USER("bot",        handle->users, auth_cred_bot);
+	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);
+	ACL_ADD_USER("user_reg",   handle->users, auth_cred_user);
+	ACL_ADD_USER("link",       handle->users, auth_cred_link);
 	ACL_ADD_BOOL("deny_nick",  handle->users_denied);
 	ACL_ADD_BOOL("ban_nick",   handle->users_banned);
 	ACL_ADD_BOOL("ban_cid",    handle->cids);
@@ -243,11 +225,9 @@ int acl_initialize(struct hub_config* config, struct acl_handle* handle)
 
 static void acl_free_access_info(void* ptr)
 {
-	struct hub_user_access_info* info = (struct hub_user_access_info*) ptr;
+	struct auth_info* info = (struct auth_info*) ptr;
 	if (info)
 	{
-		hub_free(info->username);
-		hub_free(info->password);
 		hub_free(info);
 	}
 }
@@ -294,31 +274,59 @@ int acl_shutdown(struct acl_handle* handle)
 		list_clear(handle->networks, &acl_free_ip_info);
 		list_destroy(handle->networks);
 	}
-	
+
 	if (handle->nat_override)
 	{
 		list_clear(handle->nat_override, &acl_free_ip_info);
 		list_destroy(handle->nat_override);
 	}
-	
-	
+
 	memset(handle, 0, sizeof(struct acl_handle));
 	return 0;
 }
 
-
-struct hub_user_access_info* acl_get_access_info(struct acl_handle* handle, const char* name)
+extern int acl_register_user(struct hub_info* hub, struct auth_info* info)
 {
-	struct hub_user_access_info* info = (struct hub_user_access_info*) list_get_first(handle->users);
-	while (info)
+	if (plugin_auth_register_user(hub, info) != st_allow)
 	{
-		if (strcasecmp(info->username, name) == 0)
-		{
-			return info;
-		}
-		info = (struct hub_user_access_info*) list_get_next(handle->users);
+		return 0;
 	}
-	return NULL;
+	return 1;
+}
+
+extern int acl_update_user(struct hub_info* hub, struct auth_info* info)
+{
+	if (plugin_auth_update_user(hub, info) != st_allow)
+	{
+		return 0;
+	}
+	return 1;
+}
+
+extern int acl_delete_user(struct hub_info* hub, const char* name)
+{
+	struct auth_info data;
+	strncpy(data.nickname, name, MAX_NICK_LEN);
+	data.nickname[MAX_NICK_LEN] = '\0';
+	data.password[0] = '\0';
+	data.credentials = auth_cred_none;
+	if (plugin_auth_delete_user(hub, &data) != st_allow)
+	{
+		return 0;
+	}
+	return 1;
+}
+
+struct auth_info* acl_get_access_info(struct hub_info* hub, const char* name)
+{
+	struct auth_info* info = 0;
+	info = (struct auth_info*) hub_malloc(sizeof(struct auth_info));
+	if (plugin_auth_get_user(hub, name, info) != st_allow)
+	{
+		hub_free(info);
+		return NULL;
+	}
+	return info;
 }
 
 #define STR_LIST_CONTAINS(LIST, STR) \
@@ -430,7 +438,7 @@ int acl_is_ip_nat_override(struct acl_handle* handle, const char* ip_address)
  * seconds since the unix epoch (modulus 1 million)
  * and the SID of the user (0-1 million).
  */
-const char* acl_password_generate_challenge(struct acl_handle* acl, struct hub_user* user)
+const char* acl_password_generate_challenge(struct hub_info* hub, struct hub_user* user)
 {
 	char buf[64];
 	uint64_t tiger_res[3];
@@ -446,36 +454,38 @@ const char* acl_password_generate_challenge(struct acl_handle* acl, struct hub_u
 }
 
 
-int acl_password_verify(struct acl_handle* acl, struct hub_user* user, const char* password)
+int acl_password_verify(struct hub_info* hub, struct hub_user* user, const char* password)
 {
 	char buf[1024];
-	struct hub_user_access_info* access;
+	struct auth_info* access;
 	const char* challenge;
 	char raw_challenge[64];
 	char password_calc[64];
 	uint64_t tiger_res[3];
-	
+	size_t password_len;
+
 	if (!password || !user || strlen(password) != MAX_CID_LEN)
 		return 0;
 
-	access = acl_get_access_info(acl, user->id.nick);
-	if (!access || !access->password)
+	access = acl_get_access_info(hub, user->id.nick);
+	if (!access)
 		return 0;
 
-	if (TIGERSIZE+strlen(access->password) >= 1024)
-		return 0;
-
-	challenge = acl_password_generate_challenge(acl, user);
+	challenge = acl_password_generate_challenge(hub, user);
 
 	base32_decode(challenge, (unsigned char*) raw_challenge, MAX_CID_LEN);
 
-	memcpy(&buf[0], (char*) access->password, strlen(access->password));
-	memcpy(&buf[strlen(access->password)], raw_challenge, TIGERSIZE);
+	password_len = strlen(access->password);
 	
-	tiger((uint64_t*) buf, TIGERSIZE+strlen(access->password), (uint64_t*) tiger_res);
+	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;
 
+	hub_free(access);
+
 	if (strcasecmp(password, password_calc) == 0)
 	{
 		return 1;

src/core/auth.h

@@ -21,30 +21,10 @@
 #define HAVE_UHUB_ACL_H
 
 struct hub_config;
+struct hub_info;
 struct hub_user;
 struct ip_addr_encap;
 
-enum user_credentials
-{
-	cred_none,                 /**<<< "User has no credentials (not yet logged in)" */
- 	cred_bot,                  /**<<< "User is a robot" */
-	cred_guest,                /**<<< "User is a guest (unregistered user)" */
- 	cred_user,                 /**<<< "User is identified as a registered user" */
-	cred_operator,             /**<<< "User is identified as a hub operator" */
-	cred_super,                /**<<< "User is a super user" (not used) */
-	cred_admin,                /**<<< "User is identified as a hub administrator/owner" */
- 	cred_link,                 /**<<< "User is a link (not used currently)" */
-};
-
-const char* get_user_credential_string(enum user_credentials cred);
-
-struct hub_user_access_info
-{
-	char* username;          /* name of user, cid or IP range */
-	char* password;          /* password */
-	enum user_credentials status;
-};
-
 struct acl_handle
 {
 	struct linked_list* users;          /* Known users. See enum user_status */
@@ -59,7 +39,12 @@ struct acl_handle
 extern int acl_initialize(struct hub_config* config, struct acl_handle* handle);
 extern int acl_shutdown(struct acl_handle* handle);
 
-extern struct hub_user_access_info* acl_get_access_info(struct acl_handle* handle, const char* name);
+extern struct auth_info* acl_get_access_info(struct hub_info* hub, const char* name);
+extern int acl_register_user(struct hub_info* hub, struct auth_info* info);
+extern int acl_update_user(struct hub_info* hub, struct auth_info* info);
+extern int acl_delete_user(struct hub_info* hub, const char* name);
+
+
 extern int acl_is_cid_banned(struct acl_handle* handle, const char* cid);
 extern int acl_is_ip_banned(struct acl_handle* handle, const char* ip_address);
 extern int acl_is_ip_nat_override(struct acl_handle* handle, const char* ip_address);
@@ -72,14 +57,14 @@ extern int acl_user_ban_cid(struct acl_handle* handle, const char* cid);
 extern int acl_user_unban_nick(struct acl_handle* handle, const char* nick);
 extern int acl_user_unban_cid(struct acl_handle* handle, const char* cid);
 
-extern const char* acl_password_generate_challenge(struct acl_handle* acl, struct hub_user* user);
-
 /**
  * Verify a password.
  *
  * @param password the hashed password (based on the nonce).
  * @return 1 if the password matches, or 0 if the password is incorrect.
  */
-extern int acl_password_verify(struct acl_handle* acl, struct hub_user* user, const char* password);
+extern int acl_password_verify(struct hub_info* hub, struct hub_user* user, const char* password);
+extern const char* acl_password_generate_challenge(struct hub_info* hub, struct hub_user* user);
+
 
 #endif /* HAVE_UHUB_ACL_H */

src/core/command_parser.c

@@ -0,0 +1,298 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+
+static void hub_command_args_free(struct hub_command* cmd)
+{
+	struct hub_command_arg_data* data = NULL;
+
+	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))
+	{
+		switch (data->type)
+		{
+			case type_string:
+				hub_free(data->data.string);
+				break;
+			case type_range:
+				hub_free(data->data.range);
+				break;
+			default:
+				break;
+		}
+	}
+
+	list_clear(cmd->args, hub_free);
+	list_destroy(cmd->args);
+	cmd->args = NULL;
+}
+
+void command_free(struct hub_command* cmd)
+{
+	if (!cmd) return;
+
+	hub_free(cmd->prefix);
+	hub_command_args_free(cmd);
+	hub_free(cmd);
+}
+
+static enum command_parse_status command_extract_arguments(struct hub_info* hub, const struct hub_user* user, struct command_handle* command, struct linked_list* tokens, struct linked_list* args)
+{
+	int arg = 0;
+	int opt = 0;
+	int greedy = 0;
+	char arg_code;
+	char* token = NULL;
+	char* tmp = NULL;
+	size_t size = 0;
+	struct hub_command_arg_data* data = NULL;
+	enum command_parse_status status = cmd_status_ok;
+
+	// Ignore the first token since it is the prefix.
+	token = list_get_first(tokens);
+	list_remove(tokens, token);
+	hub_free(token);
+
+	while (status == cmd_status_ok && (arg_code = command->args[arg++]))
+	{
+		if (greedy)
+		{
+			size = 1;
+			for (tmp = (char*) list_get_first(tokens); tmp; tmp = (char*) list_get_next(tokens))
+				size += (strlen(tmp) + 1);
+			token = hub_malloc_zero(size);
+
+			while ((tmp = list_get_first(tokens)))
+			{
+				if (*token)
+					strcat(token, " ");
+				strcat(token, tmp);
+				list_remove(tokens, tmp);
+				hub_free(tmp);
+			}
+		}
+		else
+		{
+			token = list_get_first(tokens);
+		}
+
+		if (!token || !*token)
+		{
+			if (arg_code == '?' || opt == 1)
+				status = cmd_status_ok;
+			else
+				status = cmd_status_missing_args;
+			break;
+		}
+
+		switch (arg_code)
+		{
+			case '?':
+				opt = 1;
+				continue;
+
+			case '+':
+				greedy = 1;
+				continue;
+
+			case 'u':
+				data = hub_malloc(sizeof(*data));
+				data->type = type_user;
+				data->data.user = uman_get_user_by_nick(hub->users, token);
+				if (!data->data.user)
+				{
+					hub_free(data);
+					data = NULL;
+					status = cmd_status_arg_nick;
+				}
+				break;
+
+			case 'i':
+				data = hub_malloc(sizeof(*data));
+				data->type = type_user;
+				data->data.user = uman_get_user_by_cid(hub->users, token);
+				if (!data->data.user)
+				{
+					hub_free(data);
+					data = NULL;
+					status = cmd_status_arg_cid;
+				}
+				break;
+
+			case 'a':
+				data = hub_malloc(sizeof(*data));
+				data->type = type_address;
+				if (ip_convert_to_binary(token, data->data.address) == -1)
+				{
+					hub_free(data);
+					data = NULL;
+					status = cmd_status_arg_address;
+				}
+				break;
+
+			case 'r':
+				data = hub_malloc(sizeof(*data));
+				data->type = type_range;
+				data->data.range = hub_malloc_zero(sizeof(struct ip_range));
+				if (!ip_convert_address_to_range(token, data->data.range))
+				{
+					hub_free(data->data.range);
+					hub_free(data);
+					data = NULL;
+					status = cmd_status_arg_address;
+				}
+				break;
+
+			case 'n':
+			case 'm':
+			case 'p':
+				data = hub_malloc(sizeof(*data));
+				data->type = type_string;
+				data->data.string = strdup(token);
+				break;
+
+			case 'c':
+				data = hub_malloc(sizeof(*data));
+				data->type = type_command;
+				data->data.command = command_handler_lookup(hub->commands, token);
+				if (!data->data.command)
+				{
+					hub_free(data);
+					data = NULL;
+					status = cmd_status_arg_command;
+				}
+				break;
+
+			case 'C':
+				data = hub_malloc(sizeof(*data));
+				data->type = type_credentials;
+				if (!auth_string_to_cred(token, &data->data.credentials))
+				{
+					hub_free(data);
+					data = NULL;
+					status = cmd_status_arg_cred;
+				}
+				break;
+
+			case 'N':
+				data = hub_malloc(sizeof(*data));
+				data->type = type_integer;
+				if (!is_number(token, &data->data.integer))
+				{
+					hub_free(data);
+					data = NULL;
+					status = cmd_status_arg_number;
+				}
+				break;
+
+			case '\0':
+				if (!opt)
+				{
+					status = cmd_status_missing_args;
+				}
+				else
+				{
+					status = cmd_status_ok;
+				}
+		}
+
+		if  (data)
+		{
+			list_append(args, data);
+			data = NULL;
+		}
+
+		list_remove(tokens, token);
+		hub_free(token);
+	}
+
+	hub_free(data);
+	return status;
+}
+
+static struct command_handle* command_get_handler(struct command_base* cbase, const char* prefix, const struct hub_user* user, struct hub_command* cmd)
+{
+	struct command_handle* handler = NULL;
+	uhub_assert(cmd != NULL);
+
+	if (prefix && prefix[0] && prefix[1])
+	{
+		handler = command_handler_lookup(cbase, prefix + 1);
+		if (handler)
+		{
+			cmd->ptr = handler->ptr;
+			cmd->handler = handler->handler;
+			cmd->status = command_is_available(handler, user->credentials) ? cmd_status_ok : cmd_status_access_error;
+		}
+		else
+		{
+			cmd->status = cmd_status_not_found;
+		}
+	}
+	else
+	{
+		cmd->status = cmd_status_syntax_error;
+	}
+	return handler;
+}
+
+
+/**
+ * Parse a command and break it down into a struct hub_command.
+ */
+struct hub_command* command_parse(struct command_base* cbase, struct hub_info* hub, const struct hub_user* user, const char* message)
+{
+	struct linked_list* tokens = list_create();
+	struct hub_command* cmd = NULL;
+	struct command_handle* handle = NULL;
+
+	cmd = hub_malloc_zero(sizeof(struct hub_command));
+	cmd->status = cmd_status_ok;
+	cmd->message = message;
+	cmd->prefix = NULL;
+	cmd->args = list_create();
+	cmd->user = user;
+
+	if (split_string(message, " ", tokens, 0) <= 0)
+	{
+		cmd->status = cmd_status_syntax_error;
+		goto command_parse_cleanup;
+	}
+
+	// Setup hub command.
+	cmd->prefix = strdup(((char*) list_get_first(tokens)) + 1);
+
+	// Find a matching command handler
+	handle = command_get_handler(cbase, list_get_first(tokens), user, cmd);
+	if (cmd->status != cmd_status_ok)
+		goto command_parse_cleanup;
+
+	// Parse arguments
+	cmd->status = command_extract_arguments(hub, user, handle, tokens, cmd->args);
+	goto command_parse_cleanup;
+
+command_parse_cleanup:
+	list_clear(tokens, &hub_free);
+	list_destroy(tokens);
+	return cmd;
+}
+

src/core/command_parser.h

@@ -0,0 +1,131 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_COMMAND_PARSER_H
+#define HAVE_UHUB_COMMAND_PARSER_H
+
+struct hub_command;
+struct hub_user;
+struct command_base;
+
+/**
+ * Parse a message as a command and return a status indicating if the command
+ * is valid and that the arguments are sane.
+ *
+ * @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 '+')
+ *
+ * @return a hub_command that must be freed with command_free(). @See struct hub_command.
+ */
+extern struct hub_command* command_parse(struct command_base* cbase, struct hub_info* hub, const struct hub_user* user, const char* message);
+
+/**
+ * Free a hub_command that was created in command_parse().
+ */
+extern void command_free(struct hub_command* command);
+
+
+enum command_parse_status
+{
+	cmd_status_ok,             /** <<< "Everything seems to OK" */
+	cmd_status_not_found,      /** <<< "Command was not found" */
+	cmd_status_access_error,   /** <<< "You don't have access to this command" */
+	cmd_status_syntax_error,   /** <<< "Not a valid command." */
+	cmd_status_missing_args,   /** <<< "Missing some or all required arguments." */
+	cmd_status_arg_nick,       /** <<< "A nick argument does not match an online user. ('n')" */
+	cmd_status_arg_cid,        /** <<< "A cid argument does not match an online user. ('i')." */
+	cmd_status_arg_address,    /** <<< "A address range argument is not valid ('a')." */
+	cmd_status_arg_number,     /** <<< "A number argument is not valid ('N')" */
+	cmd_status_arg_cred,       /** <<< "A credentials argument is not valid ('C')" */
+	cmd_status_arg_command,    /** <<< "A command argument is not valid ('c')" */
+};
+
+enum hub_command_arg_type
+{
+		type_integer,
+		type_string,
+		type_user,
+		type_address,
+		type_range,
+		type_credentials,
+		type_command
+};
+
+struct hub_command_arg_data
+{
+	enum hub_command_arg_type type;
+	union {
+		int integer;
+		char* string;
+		struct hub_user* user;
+		struct ip_addr_encap* address;
+		struct ip_range* range;
+		enum auth_credentials credentials;
+		struct command_handle* command;
+	} data;
+};
+
+typedef int (*command_handler)(struct command_base* cbase, struct hub_user* user, struct hub_command* cmd);
+
+/**
+ * This struct contains all information needed to invoke
+ * a command, which includes the whole message, the prefix,
+ * the decoded arguments (according to parameter list), and
+ * the user pointer (ptr) which comes from the command it was matched to.
+ *
+ * The message and prefix is generally always available, but args only
+ * if status == cmd_status_ok.
+ * Handler and ptr are NULL if status == cmd_status_not_found, or status == cmd_status_access_error.
+ * Ptr might also be NULL if cmd_status_ok because the command that handles it was added with a NULL ptr.
+ */
+struct hub_command
+{
+	const char* message;                /**<<< "The complete message." */
+	char* prefix;                       /**<<< "The prefix extracted from the message." */
+	struct linked_list* args;           /**<<< "List of arguments of type struct hub_command_arg_data. Parsed from message." */
+	enum command_parse_status status;   /**<<< "Status of the parsed hub_command." */
+	command_handler handler;            /**<<< "The function handler to call in order to invoke this command." */
+	const struct hub_user* user;        /**<<< "The user who invoked this command." */
+	void* ptr;                          /**<<< "A pointer of data which came from struct command_handler" */
+};
+
+/**
+ * Reset the command argument iterator and return the number of arguments
+ * that can be extracted from a parsed command.
+ *
+ * @param cmd the command to start iterating arguments
+ * @return returns the number of arguments provided for the command
+ */
+extern size_t hub_command_arg_reset(struct hub_command* cmd);
+
+/**
+ * Obtain the current argument and place it in data and increments the iterator.
+ * If no argument exists, or the argument is of a different type than \param type, then 0 is returned.
+ *
+ * NOTE: when calling hub_command_arg_next the first time during a command callback it is safe to assume
+ * that the first argument will be extracted. Thus you don't need to call hub_command_arg_reset().
+ *
+ * @param cmd the command used for iterating arguments.
+ * @param type the expected type of this argument
+ * @return NULL if no argument is found or if the argument found does not match the expected type.
+ */
+extern struct hub_command_arg_data* hub_command_arg_next(struct hub_command* cmd, enum hub_command_arg_type type);
+
+#endif /* HAVE_UHUB_COMMAND_PARSER_H */

src/core/commands.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,6 +17,93 @@
  *
  */
 
-#include "uhub.h"
+#ifndef HAVE_UHUB_COMMANDS_H
+#define HAVE_UHUB_COMMANDS_H
 
-extern int command_dipatcher(struct hub_info* hub, struct hub_user* user, const char* message);
+struct command_base;
+struct command_handle;
+struct hub_command;
+
+/**
+ * Argument codes are used to automatically parse arguments
+ * for a a hub command.
+ *
+ * u = user (must exist in hub session, or will cause error)
+ * n = nick name (string)
+ * i = CID (must exist in hub)
+ * a = (IP) address (must be a valid IPv4 or IPv6 address)
+ * r = (IP) address range (either: IP-IP or IP/mask, both IPv4 or IPv6 work)
+ * m = message (string)
+ * p = password (string)
+ * C = credentials (see auth_string_to_cred).
+ * c = command (name of command)
+ * N = number (integer)
+ *
+ * Prefix an argument with ? to make it optional.
+ * Prefix with + to make the argument greedy, which causes it to grab the rest of the line ignoring boundaries (only supported for string types).
+ *
+ * NOTE: if an argument is optional then all following arguments must also be optional.
+ * NOTE: You can combine optional and greedy, example: "?+m" would match "", "a", "a b c", etc.
+ *
+ * Example:
+ * "nia" means "nick cid ip"
+ * "n?p" means "nick [password]" where password is optional.
+ * "?N?N" means zero, one, or two integers.
+ * "?NN" means zero or two integers.
+ * "?+m" means an optional string which may contain spaces that would otherwise be split into separate arguments.
+ */
+struct command_handle
+{
+	const char* prefix;             /**<<< "Command prefix, for instance 'help' would be the prefix for the !help command." */
+	size_t length;                  /**<<< "Length of the prefix" */
+	const char* args;               /**<<< "Argument codes (see above)" */
+	enum auth_credentials cred;     /**<<< "Minimum access level for the command" */
+	command_handler handler;        /**<<< "Function pointer for the command" */
+	const char* description;        /**<<< "Description for the command" */
+	const char* origin;             /**<<< "Name of module where the command is implemented." */
+	void* ptr;                      /**<<< "A pointer which will be passed along to the handler. @See hub_command::ptr" */
+};
+
+/**
+ * Returns NULL on error, or handle
+ */
+extern struct command_base* command_initialize(struct hub_info* hub);
+extern void command_shutdown(struct command_base* cbase);
+
+/**
+ * Add a new command to the command base.
+ * Returns 1 on success, or 0 on error.
+ */
+extern int command_add(struct command_base*, struct command_handle*, void* ptr);
+
+/**
+ * Remove a command from the command base.
+ * Returns 1 on success, or 0 on error.
+ */
+extern int command_del(struct command_base*, struct command_handle*);
+
+/**
+ * Dispatch a message and forward it as a command.
+ * Returns 1 if the message should be forwarded as a chat message, or 0 if
+ * it is supposed to be handled internally in the dispatcher.
+ *
+ * This will break the message down into a struct hub_command and invoke the command handler
+ * for that command if the sufficient access credentials are met.
+ */
+extern int command_invoke(struct command_base*, struct hub_user* user, const char* message);
+
+/**
+ * Returns 1 if the command handle can be used with the given credentials, 0 otherwise.
+ */
+int command_is_available(struct command_handle* handle, enum auth_credentials credentials);
+
+/**
+ * Lookup a command handle based on prefix.
+ * If no matching command handle is found then NULL is returned.
+ */
+struct command_handle* command_handler_lookup(struct command_base* cbase, const char* prefix);
+
+extern void commands_builtin_add(struct command_base*);
+extern void commands_builtin_remove(struct command_base*);
+
+#endif /* HAVE_UHUB_COMMANDS_H */

src/core/config.c

@@ -31,17 +31,7 @@
 
 static int apply_boolean(const char* key, const char* data, int* target)
 {
-	if      (strlen(data) == 1 && (data[0] == '1')) *target = 1;
-	else if (strlen(data) == 1 && (data[0] == '0')) *target = 0;
-	else if (strncasecmp(data, "true",  4) == 0) *target = 1;
-	else if (strncasecmp(data, "false", 5) == 0) *target = 0;
-	else if (strncasecmp(data, "yes",   3) == 0) *target = 1;
-	else if (strncasecmp(data, "no",    2) == 0) *target = 0;
-	else if (strncasecmp(data, "on",    2) == 0) *target = 1;
-	else if (strncasecmp(data, "off",   3) == 0) *target = 0;
-	else
-		return 0;
-	return 1;
+	return string_to_boolean(data, target);
 }
 
 static int apply_string(const char* key, const char* data, char** target, char* regexp)
@@ -110,6 +100,7 @@ static int config_parse_line(char* line, int line_count, void* ptr_data)
 
 	key = strip_white_space(key);
 	data = strip_white_space(data);
+	data = strip_off_quotes(data);
 
 	if (!*key || !*data)
 	{

src/core/config.pl

@@ -1,241 +1,289 @@
 #!/usr/bin/perl -w
 
 use strict;
-use XML::Twig;
+use XML::DOM;
 
 sub write_c_header(@);
-sub write_c_impl_defaults(@);
-sub write_c_impl_apply(@);
-sub write_c_impl_free(@);
-sub write_c_impl_dump(@);
+sub write_sql_dump(@);
 sub get_data($);
 
+my $dump_to_sql = 0;
+
 # initialize parser and read the file
 my $input = "./config.xml";
-my $parser = XML::Twig->new();
+my $parser = new XML::DOM::Parser;
 my $tree = $parser->parsefile($input) || die "Unable to parse XML file.";
 
-# Write header file
-open GENHEAD, ">gen_config.h" || die "Unable to write header file";
-print GENHEAD "/* THIS FILE IS AUTOGENERATED - DO NOT CHANGE IT! */\n\nstruct hub_config\n{\n";
-foreach my $p ($tree->root->children("option"))
+# Get data
+my $nodes = $tree->getElementsByTagName("option");
+my @options = ();
+for (my $i = 0; $i < $nodes->getLength; $i++)
 {
-	write_c_header(get_data($p));
+	my @data = get_data($nodes->item($i));
+	push @options, \@data;
 }
-print GENHEAD "};\n\n";
 
-# Write c source file
-open GENIMPL, ">gen_config.c" || die "Unable to write source file";
-print GENIMPL "/* THIS FILE IS AUTOGENERATED - DO NOT CHANGE IT! */\n\n";
+write_c_header(@options);
+write_sql_dump(@options) if ($dump_to_sql);
 
-# The defaults function
-print GENIMPL "void config_defaults(struct hub_config* config)\n{\n";
-foreach my $p ($tree->root->children("option"))
+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)
 {
-	write_c_impl_defaults(get_data($p));
-}
-print GENIMPL "}\n\n";
+	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;
 
-# apply function
-print GENIMPL "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";
-
-foreach my $p ($tree->root->children("option"))
-{
-	write_c_impl_apply(get_data($p));
-}
-print GENIMPL "\t/* Still here -- unknown directive */\n";
-print GENIMPL "\tLOG_ERROR(\"Unknown configuration directive: '%s'\", key);\n";
-print GENIMPL "\t\treturn -1;\n";
-print GENIMPL "}\n\n";
-
-# free function (for strings)
-print GENIMPL "void free_config(struct hub_config* config)\n{\n";
-foreach my $p ($tree->root->children("option"))
-{
-	write_c_impl_free(get_data($p));
-}
-print GENIMPL "}\n\n";
-
-# dump function
-print GENIMPL "void dump_config(struct hub_config* config, int ignore_defaults)\n{\n";
-foreach my $p ($tree->root->children("option"))
-{
-	write_c_impl_dump(get_data($p));
-}
-print GENIMPL "}\n\n";
-
-
-
-sub write_c_header(@)
-{
-	my @output = @_;
-	my ($type, $name, $default, $advanced, $short, $desc, $since, $example) = @output;
-
-	print GENHEAD "\t";
-	print GENHEAD "int  " if ($type eq "int");
-	print GENHEAD "int  " if ($type eq "boolean");
-	print GENHEAD "char*" if ($type =~ /(string|file|message)/);
-	print GENHEAD " " . $name . ";";
-
-	my $comment = "";
-	if ($type eq "message")
+	if (defined $check)
 	{
-		$comment = "\"" . $default . "\"";
-	}
-	elsif (defined $short && length $short > 0)
-	{
-		$comment = $short;
-		$comment .= " (default: " . $default . ")" if (defined $default);
+		$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 "");
 	}
 
-	if (length $comment > 0)
-	{
-		my $pad = "";
-		for (my $i = length $name; $i < 32; $i++)
-		{
-			$pad .= " ";
-		}
-		$comment = $pad . "/*<<< " . $comment . " */";
-	}
+	$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 "");
 
-	print GENHEAD $comment . "\n";
-}
-
-sub write_c_impl_defaults(@)
-{
-	my @output = @_;
-	my ($type, $name, $default, $advanced, $short, $desc, $since, $example) = @output;
-	my $prefix = "";
-	my $suffix = "";
-
-	print GENIMPL "\tconfig->$name = ";
-	if ($type =~ /(string|file|message)/)
-	{
-		$prefix = "hub_strdup(\"";
-		$suffix = "\")"
-	}
-	print GENIMPL $prefix . $default . $suffix . ";\n";
-}
-
-sub write_c_impl_apply(@)
-{
-	my @output = @_;
-	my ($type, $name, $default, $advanced, $short, $desc, $since, $example, $p) = @output;
-
-	my $min;
-	my $max;
-	my $regexp;
-
-	if (defined $p)
-	{
-		$min = $p->att("min");
-		$max = $p->att("max");
-		$regexp = $p->att("regexp");
-
-		print "'check' is defined for option $name";
-		print ", min=$min" if (defined $min);
-		print ", max=$max" if (defined $max);
-		print ", regexp=\"$regexp\"" if (defined $regexp);
-		print "\n";
-	}
-
-	print GENIMPL "\tif (!strcmp(key, \"" . $name . "\"))\n\t{\n";
+	$config_apply .= "#ifdef $ifdef\n" if ($ifdef ne "");
+	$config_apply .= "\tif (!strcmp(key, \"" . $name . "\"))\n\t{\n";
 
 	if ($type eq "int")
 	{
-		if (defined $min)
-		{
-			print GENIMPL "\t\tmin = $min;\n"
-		}
-		if (defined $max)
-		{
-			print GENIMPL "\t\tmax = $max;\n"
-		}
-
-		print GENIMPL "\t\tif (!apply_integer(key, data, &config->$name, ";
-
-		if (defined $min)
-		{
-			print GENIMPL "&min";
-		}
-		else
-		{
-			print GENIMPL "0";
-		}
-
-		print GENIMPL ", ";
-
-		if (defined $max)
-		{
-			print GENIMPL "&max";
-		}
-		else
-		{
-			print GENIMPL "0";
-		}
-
-		print GENIMPL "))\n";
+		$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")
 	{
-		print GENIMPL "\t\tif (!apply_boolean(key, data, &config->$name))\n";
+		$config_apply .= "\t\tif (!apply_boolean(key, data, &config->$name))\n";
 	}
-	elsif ($type =~ /(string|file|message)/)
+	elsif ($string)
 	{
-		print GENIMPL "\t\tif (!apply_string(key, data, &config->$name, (char*) \"\"))\n";
+		$config_apply .="\t\tif (!apply_string(key, data, &config->$name, (char*) \"\"))\n";
 	}
 
-	print GENIMPL "\t\t{\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\n";
-}
+				  "\t}\n";
+	$config_apply .= "#endif /* $ifdef */\n" if ($ifdef ne "");
+	$config_apply .= "\n";
 
-sub write_c_impl_free(@)
-{
-	my @output = @_;
-	my ($type, $name, $default, $advanced, $short, $desc, $since, $example) = @output;
-
-	if ($type =~ /(string|file|message)/)
+	if ($string)
 	{
-		print GENIMPL "\thub_free(config->" . $name . ");\n\n" 
+		$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";
 	}
-}
 
-sub write_c_impl_dump(@)
-{
-	my @output = @_;
-	my ($type, $name, $default, $advanced, $short, $desc, $since, $example) = @output;
-	my $out;
+	my $out = "%s";
 	my $val = "config->$name";
 	my $test = "config->$name != $default";
 
-	if ($type eq "int")
-	{
-		$out = "%d";
-	}
-	elsif ($type eq "boolean")
-	{
-		$out = "%s";
-		$val = "config->$name ? \"yes\" : \"no\"";
-	}
-	elsif ($type =~ /(string|file|message)/)
+	$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";
 	}
 
-	print GENIMPL "\tif (!ignore_defaults || $test)\n";
-	print GENIMPL "\t\tfprintf(stdout, \"$name = $out\\n\", $val);\n\n";
+	$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 $check = $p->first_child_matches("check");
-	my @data = ($p->att("type"), $p->att("name"), $p->att("default"), $p->att("advanced"), $p->children_text("short"), $p->children_text("description"), $p->children_text("since"), $p->children_text("example"), $check);
+
+	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.xml

@@ -13,7 +13,7 @@
 		<check min="1" max="65535" />
 		<since>0.1.0</since>
 		<short>Server port to bind to</short>
-		<description><![CDATA[This is specifies the port number the hub should listen on.]]></description>
+		<description><![CDATA[This specifies the port number the hub should listen on.]]></description>
 	</option>
 
 	<option name="server_bind_addr" type="string" default="any">
@@ -108,6 +108,15 @@
 		<since>0.1.1</since>
 	</option>
 
+   <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.
+			Otherwise only operators can register users.
+		]]></description>
+		<since>0.4.0</since>
+   </option>
+
 	<option name="obsolete_clients" type="boolean" default="0">
 		<short>Support obsolete clients using a ADC protocol prior to 1.0</short>
 		<description><![CDATA[
@@ -117,14 +126,6 @@
 		<since>0.3.1</since>
 	</option>
 
-	<option name="chat_only" type="boolean" default="0">
-		<short>Allow chat only operation on hub</short>
-		<description><![CDATA[
-			If this is enabled the hub will refuse to relay messages for search and connection setup. This effectively makes the hub viable for chat only.
-		]]></description>
-		<since>0.1.1</since>
-	</option>
-
 	<option name="chat_is_privileged" type="boolean" default="0">
 		<short>Allow chat for operators and above only</short>
 		<description><![CDATA[
@@ -408,7 +409,7 @@
 	</option>
 
 	<option name="tls_require" type="boolean" default="0">
-		<short>If SSL/TLS enabled, should it be required (default: 0)</short>
+		<short>If SSL/TLS enabled, should it be required</short>
 		<description><![CDATA[
 			If TLS/SSL support is enabled it can either be optional or mandatory.
 			If this option is disabled then SSL/TLS is not required to enter the hub, however it is possible to enter either with or without.
@@ -417,6 +418,17 @@
 		<since>0.3.0</since>
 	</option>
 
+	<option name="tls_require_redirect_addr" type="string" default="">
+		<check regexp="(adc|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.
+		For instance a hub at adc://adc.example.com might redirect to adcs://adc.example.com
+		]]></description>
+		<since>0.3.3</since>
+	</option>
+
+
 	<option name="tls_certificate" type="file" default="">
 		<short>Certificate file</short>
 		<description><![CDATA[
@@ -433,24 +445,6 @@
 		<since>0.3.0</since>
 	</option>
 
-	<option name="file_motd" type="file" default="">
-		<short>File containing the 'message of the day</short>
-		<description><![CDATA[
-			This can be specified as a message of the day file. If a valid file is given here it's content will be sent to all users after they have logged in to the hub. If the file is missing or empty this configuration entry will be ignored.
-		]]></description>
-		<since>0.1.3</since>
-		<example><![CDATA[
-			<p>
-			Unix users: <br />
-				file_acl = "/etc/uhub/motd.txt"
-			</p>
-			<p>
-			Windows users: <br />
-				file_acl = "c:\uhub\motd.txt"
-			</p>
-		]]></example>
-	</option>
-
 	<option name="file_acl" type="file" default="">
 		<short>File containing access control lists</short>
 		<description><![CDATA[
@@ -471,21 +465,15 @@
 		]]></example>
 	</option>
 
-	<option name="file_rules" type="file" default="">
-		<short>File containing hub rules</short>
+	<option name="file_plugins" type="file" default="">
+		<short>Plugin configuration file</short>
 		<description><![CDATA[
-			This is a text file that is displayed on login as an extended message of the day.
-			In addition the contents of the file is displayed when a user uses the "!rules" command.
+			Plugin configuration file.
 		]]></description>
-		<since>0.3.0</since>
+		<since>0.3.3</since>
 		<example><![CDATA[
 			<p>
-			Unix users: <br />
-				file_acl = "/etc/uhub/rules.txt"
-			</p>
-			<p>
-			Windows users: <br />
-				file_acl = "c:\uhub\rules.txt"
+				file_plugins = "/etc/uhub/plugins.conf"
 			</p>
 		]]></example>
 	</option>
@@ -602,7 +590,7 @@
 	</option>
 
 	<option name="msg_error_no_memory" type="message" default="No memory">
-		<description><![CDATA[]]></description>
+		<description><![CDATA[Hub has no more memory]]></description>
 		<since>0.2.0</since>
 	</option>
 

src/core/eventqueue.c

@@ -88,7 +88,7 @@ int event_queue_process(struct event_queue* queue)
 	}
 	
 	list_clear(queue->q1, event_queue_cleanup_callback);
-	assert(list_size(queue->q1) == 0);
+	uhub_assert(list_size(queue->q1) == 0);
 		
 	/* unlock queue */
 	queue->locked = 0;

src/core/gen_config.c

@@ -11,8 +11,8 @@ void config_defaults(struct hub_config* config)
 	config->show_banner_sys_info = 1;
 	config->max_users = 500;
 	config->registered_users_only = 0;
+	config->register_self = 0;
 	config->obsolete_clients = 0;
-	config->chat_only = 0;
 	config->chat_is_privileged = 0;
 	config->hub_name = hub_strdup("uhub");
 	config->hub_description = hub_strdup("no description");
@@ -42,11 +42,11 @@ void config_defaults(struct hub_config* config)
 	config->flood_ctl_extras = 0;
 	config->tls_enable = 0;
 	config->tls_require = 0;
+	config->tls_require_redirect_addr = hub_strdup("");
 	config->tls_certificate = hub_strdup("");
 	config->tls_private_key = hub_strdup("");
-	config->file_motd = hub_strdup("");
 	config->file_acl = hub_strdup("");
-	config->file_rules = hub_strdup("");
+	config->file_plugins = hub_strdup("");
 	config->msg_hub_full = hub_strdup("Hub is full");
 	config->msg_hub_disabled = hub_strdup("Hub is disabled");
 	config->msg_hub_registered_users_only = hub_strdup("Hub is for registered users only");
@@ -102,7 +102,9 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "server_port"))
 	{
-		if (!apply_integer(key, data, &config->server_port, 0, 0))
+		min = 1;
+		max = 65535;
+		if (!apply_integer(key, data, &config->server_port, &min, &max))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -122,7 +124,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "server_listen_backlog"))
 	{
-		if (!apply_integer(key, data, &config->server_listen_backlog, 0, 0))
+		min = 5;
+		if (!apply_integer(key, data, &config->server_listen_backlog, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -182,9 +185,9 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 		return 0;
 	}
 
-	if (!strcmp(key, "obsolete_clients"))
+	if (!strcmp(key, "register_self"))
 	{
-		if (!apply_boolean(key, data, &config->obsolete_clients))
+		if (!apply_boolean(key, data, &config->register_self))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -192,9 +195,9 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 		return 0;
 	}
 
-	if (!strcmp(key, "chat_only"))
+	if (!strcmp(key, "obsolete_clients"))
 	{
-		if (!apply_boolean(key, data, &config->chat_only))
+		if (!apply_boolean(key, data, &config->obsolete_clients))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -244,7 +247,9 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "max_recv_buffer"))
 	{
-		if (!apply_integer(key, data, &config->max_recv_buffer, 0, 0))
+		min = 1024;
+		max = 1048576;
+		if (!apply_integer(key, data, &config->max_recv_buffer, &min, &max))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -254,7 +259,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "max_send_buffer"))
 	{
-		if (!apply_integer(key, data, &config->max_send_buffer, 0, 0))
+		min = 2048;
+		if (!apply_integer(key, data, &config->max_send_buffer, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -264,7 +270,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "max_send_buffer_soft"))
 	{
-		if (!apply_integer(key, data, &config->max_send_buffer_soft, 0, 0))
+		min = 1024;
+		if (!apply_integer(key, data, &config->max_send_buffer_soft, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -284,7 +291,9 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "max_chat_history"))
 	{
-		if (!apply_integer(key, data, &config->max_chat_history, 0, 0))
+		min = 0;
+		max = 250;
+		if (!apply_integer(key, data, &config->max_chat_history, &min, &max))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -294,7 +303,9 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "max_logout_log"))
 	{
-		if (!apply_integer(key, data, &config->max_logout_log, 0, 0))
+		min = 0;
+		max = 2000;
+		if (!apply_integer(key, data, &config->max_logout_log, &min, &max))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -304,7 +315,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "limit_max_hubs_user"))
 	{
-		if (!apply_integer(key, data, &config->limit_max_hubs_user, 0, 0))
+		min = 0;
+		if (!apply_integer(key, data, &config->limit_max_hubs_user, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -314,7 +326,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "limit_max_hubs_reg"))
 	{
-		if (!apply_integer(key, data, &config->limit_max_hubs_reg, 0, 0))
+		min = 0;
+		if (!apply_integer(key, data, &config->limit_max_hubs_reg, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -324,7 +337,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "limit_max_hubs_op"))
 	{
-		if (!apply_integer(key, data, &config->limit_max_hubs_op, 0, 0))
+		min = 0;
+		if (!apply_integer(key, data, &config->limit_max_hubs_op, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -334,7 +348,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "limit_max_hubs"))
 	{
-		if (!apply_integer(key, data, &config->limit_max_hubs, 0, 0))
+		min = 0;
+		if (!apply_integer(key, data, &config->limit_max_hubs, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -344,7 +359,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "limit_min_hubs_user"))
 	{
-		if (!apply_integer(key, data, &config->limit_min_hubs_user, 0, 0))
+		min = 0;
+		if (!apply_integer(key, data, &config->limit_min_hubs_user, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -354,7 +370,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "limit_min_hubs_reg"))
 	{
-		if (!apply_integer(key, data, &config->limit_min_hubs_reg, 0, 0))
+		min = 0;
+		if (!apply_integer(key, data, &config->limit_min_hubs_reg, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -364,7 +381,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "limit_min_hubs_op"))
 	{
-		if (!apply_integer(key, data, &config->limit_min_hubs_op, 0, 0))
+		min = 0;
+		if (!apply_integer(key, data, &config->limit_min_hubs_op, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -385,7 +403,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "limit_max_share"))
 	{
-		if (!apply_integer(key, data, &config->limit_max_share, 0, 0))
+		min = 0;
+		if (!apply_integer(key, data, &config->limit_max_share, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -395,7 +414,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "limit_min_slots"))
 	{
-		if (!apply_integer(key, data, &config->limit_min_slots, 0, 0))
+		min = 0;
+		if (!apply_integer(key, data, &config->limit_min_slots, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -405,7 +425,8 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	if (!strcmp(key, "limit_max_slots"))
 	{
-		if (!apply_integer(key, data, &config->limit_max_slots, 0, 0))
+		min = 0;
+		if (!apply_integer(key, data, &config->limit_max_slots, &min, 0))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -495,6 +516,16 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 		return 0;
 	}
 
+	if (!strcmp(key, "tls_require_redirect_addr"))
+	{
+		if (!apply_string(key, data, &config->tls_require_redirect_addr, (char*) ""))
+		{
+			LOG_ERROR("Configuration parse error on line %d", line_count);
+			return -1;
+		}
+		return 0;
+	}
+
 	if (!strcmp(key, "tls_certificate"))
 	{
 		if (!apply_string(key, data, &config->tls_certificate, (char*) ""))
@@ -515,16 +546,6 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 		return 0;
 	}
 
-	if (!strcmp(key, "file_motd"))
-	{
-		if (!apply_string(key, data, &config->file_motd, (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*) ""))
@@ -535,9 +556,9 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 		return 0;
 	}
 
-	if (!strcmp(key, "file_rules"))
+	if (!strcmp(key, "file_plugins"))
 	{
-		if (!apply_string(key, data, &config->file_rules, (char*) ""))
+		if (!apply_string(key, data, &config->file_plugins, (char*) ""))
 		{
 			LOG_ERROR("Configuration parse error on line %d", line_count);
 			return -1;
@@ -907,7 +928,7 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 
 	/* Still here -- unknown directive */
 	LOG_ERROR("Unknown configuration directive: '%s'", key);
-		return -1;
+	return -1;
 }
 
 void free_config(struct hub_config* config)
@@ -922,15 +943,15 @@ void free_config(struct hub_config* config)
 
 	hub_free(config->redirect_addr);
 
+	hub_free(config->tls_require_redirect_addr);
+
 	hub_free(config->tls_certificate);
 
 	hub_free(config->tls_private_key);
 
-	hub_free(config->file_motd);
-
 	hub_free(config->file_acl);
 
-	hub_free(config->file_rules);
+	hub_free(config->file_plugins);
 
 	hub_free(config->msg_hub_full);
 
@@ -1035,12 +1056,12 @@ void dump_config(struct hub_config* config, int ignore_defaults)
 	if (!ignore_defaults || config->registered_users_only != 0)
 		fprintf(stdout, "registered_users_only = %s\n", config->registered_users_only ? "yes" : "no");
 
+	if (!ignore_defaults || config->register_self != 0)
+		fprintf(stdout, "register_self = %s\n", config->register_self ? "yes" : "no");
+
 	if (!ignore_defaults || config->obsolete_clients != 0)
 		fprintf(stdout, "obsolete_clients = %s\n", config->obsolete_clients ? "yes" : "no");
 
-	if (!ignore_defaults || config->chat_only != 0)
-		fprintf(stdout, "chat_only = %s\n", config->chat_only ? "yes" : "no");
-
 	if (!ignore_defaults || config->chat_is_privileged != 0)
 		fprintf(stdout, "chat_is_privileged = %s\n", config->chat_is_privileged ? "yes" : "no");
 
@@ -1128,20 +1149,20 @@ void dump_config(struct hub_config* config, int ignore_defaults)
 	if (!ignore_defaults || config->tls_require != 0)
 		fprintf(stdout, "tls_require = %s\n", config->tls_require ? "yes" : "no");
 
+	if (!ignore_defaults || strcmp(config->tls_require_redirect_addr, "") != 0)
+		fprintf(stdout, "tls_require_redirect_addr = \"%s\"\n", config->tls_require_redirect_addr);
+
 	if (!ignore_defaults || strcmp(config->tls_certificate, "") != 0)
 		fprintf(stdout, "tls_certificate = \"%s\"\n", config->tls_certificate);
 
 	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->file_motd, "") != 0)
-		fprintf(stdout, "file_motd = \"%s\"\n", config->file_motd);
-
 	if (!ignore_defaults || strcmp(config->file_acl, "") != 0)
 		fprintf(stdout, "file_acl = \"%s\"\n", config->file_acl);
 
-	if (!ignore_defaults || strcmp(config->file_rules, "") != 0)
-		fprintf(stdout, "file_rules = \"%s\"\n", config->file_rules);
+	if (!ignore_defaults || strcmp(config->file_plugins, "") != 0)
+		fprintf(stdout, "file_plugins = \"%s\"\n", config->file_plugins);
 
 	if (!ignore_defaults || strcmp(config->msg_hub_full, "Hub is full") != 0)
 		fprintf(stdout, "msg_hub_full = \"%s\"\n", config->msg_hub_full);

src/core/gen_config.h

@@ -4,19 +4,19 @@ struct hub_config
 {
 	int   hub_enabled;                     /*<<< Is server enabled (default: 1) */
 	int   server_port;                     /*<<< Server port to bind to (default: 1511) */
-	char* server_bind_addr;                /*<<< Server bind address (default: any) */
+	char* server_bind_addr;                /*<<< Server bind address (default: "any") */
 	int   server_listen_backlog;           /*<<< Server listen backlog (default: 50) */
-	char* server_alt_ports;                /*<<< Comma separated list of alternative ports to listen to (default: ) */
+	char* server_alt_ports;                /*<<< Comma separated list of alternative ports to listen to (default: "") */
 	int   show_banner;                     /*<<< Show banner on connect (default: 1) */
 	int   show_banner_sys_info;            /*<<< Show banner on connect (default: 1) */
 	int   max_users;                       /*<<< Maximum number of users allowed on the hub (default: 500) */
 	int   registered_users_only;           /*<<< Allow registered users only (default: 0) */
+	int   register_self;                   /*<<< Allow users to register themselves on the hub. (default: 0) */
 	int   obsolete_clients;                /*<<< Support obsolete clients using a ADC protocol prior to 1.0 (default: 0) */
-	int   chat_only;                       /*<<< Allow chat only operation on hub (default: 0) */
 	int   chat_is_privileged;              /*<<< Allow chat for operators and above only (default: 0) */
-	char* hub_name;                        /*<<< Name of hub (default: uhub) */
-	char* hub_description;                 /*<<< Short hub description, topic or subject. (default: no description) */
-	char* redirect_addr;                   /*<<< A common hub redirect address. (default: ) */
+	char* hub_name;                        /*<<< Name of hub (default: "uhub") */
+	char* hub_description;                 /*<<< Short hub description, topic or subject. (default: "no description") */
+	char* redirect_addr;                   /*<<< A common hub redirect address. (default: "") */
 	int   max_recv_buffer;                 /*<<< Max read buffer before parse, per user (default: 4096) */
 	int   max_send_buffer;                 /*<<< Max send buffer before disconnect, per user (default: 131072) */
 	int   max_send_buffer_soft;            /*<<< Max send buffer before message drops, per user (default: 98304) */
@@ -41,12 +41,12 @@ struct hub_config
 	int   flood_ctl_update;                /*<<< Max updates allowed in time interval (default: 0) */
 	int   flood_ctl_extras;                /*<<< Max extra messages allowed in time interval (default: 0) */
 	int   tls_enable;                      /*<<< Enable SSL/TLS support (default: 0) */
-	int   tls_require;                     /*<<< If SSL/TLS enabled, should it be required (default: 0) (default: 0) */
-	char* tls_certificate;                 /*<<< Certificate file (default: ) */
-	char* tls_private_key;                 /*<<< Private key file (default: ) */
-	char* file_motd;                       /*<<< File containing the 'message of the day (default: ) */
-	char* file_acl;                        /*<<< File containing access control lists (default: ) */
-	char* file_rules;                      /*<<< File containing hub rules (default: ) */
+	int   tls_require;                     /*<<< If SSL/TLS enabled, should it be required (default: 0) */
+	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* file_acl;                        /*<<< File containing access control lists (default: "") */
+	char* file_plugins;                    /*<<< Plugin configuration file (default: "") */
 	char* msg_hub_full;                    /*<<< "Hub is full" */
 	char* msg_hub_disabled;                /*<<< "Hub is disabled" */
 	char* msg_hub_registered_users_only;   /*<<< "Hub is for registered users only" */

src/core/hub.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,10 +21,7 @@
 
 struct hub_info* g_hub = 0;
 
-#define CHECK_CHAT_ONLY \
-	if (hub->config->chat_only && u->credentials < cred_operator) \
-		break
-
+/* 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())) \
 	{ \
@@ -50,9 +47,9 @@ int hub_handle_message(struct hub_info* hub, struct hub_user* u, const char* lin
 {
 	int ret = 0;
 	struct adc_message* cmd = 0;
-	
+
 	LOG_PROTO("recv %s: %s", sid_to_string(u->id.sid), line);
-	
+
 	if (user_is_disconnecting(u))
 		return -1;
 
@@ -79,7 +76,12 @@ int hub_handle_message(struct hub_info* hub, struct hub_user* u, const char* lin
 			case ADC_CMD_DINF:
 			case ADC_CMD_EINF:
 			case ADC_CMD_FINF:
+			case ADC_CMD_BQUI:
+			case ADC_CMD_DQUI:
+			case ADC_CMD_EQUI:
+			case ADC_CMD_FQUI:
 				/* these must never be allowed for security reasons, so we ignore them. */
+				CHECK_FLOOD(extras, 1);
 				break;
 
 			case ADC_CMD_EMSG:
@@ -95,23 +97,46 @@ int hub_handle_message(struct hub_info* hub, struct hub_user* u, const char* lin
 			case ADC_CMD_ESCH:
 			case ADC_CMD_FSCH:
 				cmd->priority = -1;
-				CHECK_CHAT_ONLY;
+				if (plugin_handle_search(hub, u, cmd->cache) == st_deny)
+					break;
 				CHECK_FLOOD(search, 1);
 				ROUTE_MSG;
 
+			case ADC_CMD_FRES: // spam
+			case ADC_CMD_BRES: // spam
+			case ADC_CMD_ERES: // pointless.
+				CHECK_FLOOD(extras, 1);
+				break;
+
 			case ADC_CMD_DRES:
 				cmd->priority = -1;
-				CHECK_CHAT_ONLY;
+				if (plugin_handle_search_result(hub, u, uman_get_user_by_sid(hub->users, cmd->target), cmd->cache) == st_deny)
+					break;
 				/* CHECK_FLOOD(search, 0); */
 				ROUTE_MSG;
 
 			case ADC_CMD_DRCM:
-			case ADC_CMD_DCTM:
 				cmd->priority = -1;
-				CHECK_CHAT_ONLY;
+				if (plugin_handle_revconnect(hub, u, uman_get_user_by_sid(hub->users, cmd->target)) == st_deny)
+					break;
 				CHECK_FLOOD(connect, 1);
 				ROUTE_MSG;
-			
+
+			case ADC_CMD_DCTM:
+				cmd->priority = -1;
+				if (plugin_handle_connect(hub, u, uman_get_user_by_sid(hub->users, cmd->target)) == st_deny)
+					break;
+				CHECK_FLOOD(connect, 1);
+				ROUTE_MSG;
+
+			case ADC_CMD_BCMD:
+			case ADC_CMD_DCMD:
+			case ADC_CMD_ECMD:
+			case ADC_CMD_FCMD:
+			case ADC_CMD_HCMD:
+				CHECK_FLOOD(extras, 1);
+				break;
+
 			default:
 				CHECK_FLOOD(extras, 1);
 				ROUTE_MSG;
@@ -125,7 +150,7 @@ int hub_handle_message(struct hub_info* hub, struct hub_user* u, const char* lin
 			ret = -1;
 		}
 	}
-	
+
 	return ret;
 }
 
@@ -166,7 +191,7 @@ int hub_handle_support(struct hub_info* hub, struct hub_user* u, struct adc_mess
 		{
 			ok = 0;
 		}
-		
+
 		index++;
 		hub_free(arg);
 		arg = adc_msg_get_argument(cmd, index);
@@ -234,7 +259,7 @@ int hub_handle_password(struct hub_info* hub, struct hub_user* u, struct adc_mes
 
 	if (u->state == state_verify)
 	{
-		if (acl_password_verify(hub->acl, u, password))
+		if (acl_password_verify(hub, u, password))
 		{
 			on_login_success(hub, u);
 		}
@@ -244,7 +269,7 @@ int hub_handle_password(struct hub_info* hub, struct hub_user* u, struct adc_mes
 			ret = -1;
 		}
 	}
-	
+
 	hub_free(password);
 	return ret;
 }
@@ -253,20 +278,35 @@ int hub_handle_password(struct hub_info* hub, struct hub_user* u, struct adc_mes
 int hub_handle_chat_message(struct hub_info* hub, struct hub_user* u, struct adc_message* cmd)
 {
 	char* message = adc_msg_get_argument(cmd, 0);
+	char* message_decoded = NULL;
 	int ret = 0;
 	int relay = 1;
+	int broadcast;
+	int private_msg;
+	int command;
 	int offset;
 
 	if (!message)
 		return 0;
 
+	message_decoded = adc_msg_unescape(message);
+	if (!message_decoded)
+	{
+		hub_free(message);
+		return 0;
+	}
+
 	if (!user_is_logged_in(u))
 	{
 		hub_free(message);
 		return 0;
 	}
 
-	if ((cmd->cache[0] == 'B') && (message[0] == '!' || message[0] == '+'))
+	broadcast = (cmd->cache[0] == 'B');
+	private_msg = (cmd->cache[0] == 'D' || cmd->cache[0] == 'E');
+	command = (message[0] == '!' || message[0] == '+');
+
+	if (broadcast && command)
 	{
 		/*
 		 * A message such as "++message" is handled as "+message", by removing the first character.
@@ -281,48 +321,50 @@ int hub_handle_chat_message(struct hub_info* hub, struct hub_user* u, struct adc
 		}
 		else
 		{
-			relay = command_dipatcher(hub, u, message);
+			relay = command_invoke(hub->commands, u, message_decoded);
 		}
 	}
 
-	if (((hub->config->chat_is_privileged && !user_is_protected(u)) || (user_flag_get(u, flag_muted))) && (cmd->cache[0] == 'B' || cmd->cache[0] == 'F'))
+	/* FIXME: Plugin should do this! */
+	if (relay && (((hub->config->chat_is_privileged && !user_is_protected(u)) || (user_flag_get(u, flag_muted))) && broadcast))
 	{
 		relay = 0;
 	}
 
+	if (relay)
+	{
+		plugin_st status = st_default;
+		if (broadcast)
+		{
+			status = plugin_handle_chat_message(hub, u, message_decoded, 0);
+		}
+		else if (private_msg)
+		{
+			struct hub_user* target = uman_get_user_by_sid(hub->users, cmd->target);
+			if (target)
+				status = plugin_handle_private_message(hub, u, target, message_decoded, 0);
+			else
+				relay = 0;
+		}
+
+		if (status == st_deny)
+			relay = 0;
+	}
+
 	if (relay)
 	{
 		/* adc_msg_remove_named_argument(cmd, "PM"); */
-		if (cmd->cache[0] == 'B')
-			hub_chat_history_add(hub, u, cmd);
+		if (broadcast)
+		{
+			plugin_log_chat_message(hub, u, message_decoded, 0);
+		}
 		ret = route_message(hub, u, cmd);
 	}
 	hub_free(message);
+	hub_free(message_decoded);
 	return ret;
 }
 
-void hub_chat_history_add(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
-{
-	char* msg_esc   = adc_msg_get_argument(cmd, 0);
-	char* message = adc_msg_unescape(msg_esc);
-	char* log = hub_malloc(strlen(message) + strlen(user->id.nick) + 14);
-	sprintf(log, "%s <%s> %s\n", get_timestamp(time(NULL)), user->id.nick, message);
-	list_append(hub->chat_history, log);
-	while (list_size(hub->chat_history) > (size_t) hub->config->max_chat_history)
-	{
-		char* msg = list_get_first(hub->chat_history);
-		list_remove(hub->chat_history, msg);
-		hub_free(msg);
-	}
-	hub_free(message);
-	hub_free(msg_esc);
-}
-
-void hub_chat_history_clear(struct hub_info* hub)
-{
-	list_clear(hub->chat_history, &hub_free);
-}
-
 void hub_send_support(struct hub_info* hub, struct hub_user* u)
 {
 	if (user_is_connecting(u) || user_is_logged_in(u))
@@ -339,7 +381,7 @@ void hub_send_sid(struct hub_info* hub, struct hub_user* u)
 	if (user_is_connecting(u))
 	{
 		command = adc_msg_construct(ADC_CMD_ISID, 10);
-		sid = uman_get_free_sid(hub, u);
+		sid = uman_get_free_sid(hub->users, u);
 		adc_msg_add_argument(command, (const char*) sid_to_string(sid));
 		route_to_user(hub, u, command);
 		adc_msg_free(command);
@@ -364,7 +406,8 @@ void hub_send_hubinfo(struct hub_info* hub, struct hub_user* u)
 {
 	struct adc_message* info = adc_msg_copy(hub->command_info);
 	int value = 0;
-	
+	uint64_t size = 0;
+
 	if (user_flag_get(u, feature_ping))
 	{
 /*
@@ -377,48 +420,48 @@ void hub_send_hubinfo(struct hub_info* hub, struct hub_user* u)
 		adc_msg_add_named_argument(info, "UC", uhub_itoa(hub_get_user_count(hub)));
 		adc_msg_add_named_argument(info, "MC", uhub_itoa(hub_get_max_user_count(hub)));
 		adc_msg_add_named_argument(info, "SS", uhub_ulltoa(hub_get_shared_size(hub)));
-		adc_msg_add_named_argument(info, "SF", uhub_itoa(hub_get_shared_files(hub)));
-		
+		adc_msg_add_named_argument(info, "SF", uhub_ulltoa(hub_get_shared_files(hub)));
+
 		/* Maximum/minimum share size */
-		value = hub_get_max_share(hub);
-		if (value) adc_msg_add_named_argument(info, "XS", uhub_itoa(value));
-		value = hub_get_min_share(hub);
-		if (value) adc_msg_add_named_argument(info, "MS", uhub_itoa(value));
-		
+		size = hub_get_max_share(hub);
+		if (size) adc_msg_add_named_argument(info, "XS", uhub_ulltoa(size));
+		size = hub_get_min_share(hub);
+		if (size) adc_msg_add_named_argument(info, "MS", uhub_ulltoa(size));
+
 		/* Maximum/minimum upload slots allowed per user */
 		value = hub_get_max_slots(hub);
 		if (value) adc_msg_add_named_argument(info, "XL", uhub_itoa(value));
 		value = hub_get_min_slots(hub);
 		if (value) adc_msg_add_named_argument(info, "ML", uhub_itoa(value));
-		
+
 		/* guest users must be on min/max hubs */
 		value = hub_get_max_hubs_user(hub);
 		if (value) adc_msg_add_named_argument(info, "XU", uhub_itoa(value));
 		value = hub_get_min_hubs_user(hub);
 		if (value) adc_msg_add_named_argument(info, "MU", uhub_itoa(value));
-		
+
 		/* registered users must be on min/max hubs */
 		value = hub_get_max_hubs_reg(hub);
 		if (value) adc_msg_add_named_argument(info, "XR", uhub_itoa(value));
 		value = hub_get_min_hubs_reg(hub);
 		if (value) adc_msg_add_named_argument(info, "MR", uhub_itoa(value));
-		
+
 		/* operators must be on min/max hubs */
 		value = hub_get_max_hubs_op(hub);
 		if (value) adc_msg_add_named_argument(info, "XO", uhub_itoa(value));
 		value = hub_get_min_hubs_op(hub);
 		if (value) adc_msg_add_named_argument(info, "MO", uhub_itoa(value));
-		
+
 		/* uptime in seconds */
 		adc_msg_add_named_argument(info, "UP", uhub_itoa((int) difftime(time(0), hub->tm_started)));
 	}
-	
+
 	if (user_is_connecting(u) || user_is_logged_in(u))
 	{
 		route_to_user(hub, u, info);
 	}
 	adc_msg_free(info);
-	
+
 	/* Only send banner when connecting */
 	if (hub->config->show_banner && user_is_connecting(u))
 	{
@@ -440,32 +483,11 @@ void hub_send_handshake(struct hub_info* hub, struct hub_user* u)
 	}
 }
 
-int hub_send_motd(struct hub_info* hub, struct hub_user* u)
-{
-	if (hub->command_motd)
-	{
-		route_to_user(hub, u, hub->command_motd);
-		return 1;
-	}
-	return 0;
-}
-
-int hub_send_rules(struct hub_info* hub, struct hub_user* u)
-{
-	if (hub->command_rules)
-	{
-		route_to_user(hub, u, hub->command_rules);
-		return 1;
-	}
-	return 0;
-}
-
-
 void hub_send_password_challenge(struct hub_info* hub, struct hub_user* u)
 {
 	struct adc_message* igpa;
 	igpa = adc_msg_construct(ADC_CMD_IGPA, 38);
-	adc_msg_add_argument(igpa, acl_password_generate_challenge(hub->acl, u));
+	adc_msg_add_argument(igpa, acl_password_generate_challenge(hub, u));
 	user_set_state(u, state_verify);
 	route_to_user(hub, u, igpa);
 	adc_msg_free(igpa);
@@ -493,39 +515,66 @@ void hub_send_flood_warning(struct hub_info* hub, struct hub_user* u, const char
 	}
 }
 
+static int check_duplicate_logins_ok(struct hub_info* hub, struct hub_user* user)
+{
+	struct hub_user* lookup1;
+	struct hub_user* lookup2;
+
+	lookup1 = uman_get_user_by_nick(hub->users, user->id.nick);
+	if (lookup1)
+		return status_msg_inf_error_nick_taken;
+
+	lookup2 = uman_get_user_by_cid(hub->users, user->id.cid);
+	if (lookup2)
+		return status_msg_inf_error_cid_taken;
+
+	return 0;
+}
+
 static void hub_event_dispatcher(void* callback_data, struct event_data* message)
 {
+	int status;
 	struct hub_info* hub = (struct hub_info*) callback_data;
 	struct hub_user* user = (struct hub_user*) message->ptr;
-	assert(hub != NULL);
-	
+	uhub_assert(hub != NULL);
+
 	switch (message->id)
 	{
 		case UHUB_EVENT_USER_JOIN:
 		{
 			if (user_is_disconnecting(user))
 				break;
-		
+
 			if (message->flags)
 			{
 				hub_send_password_challenge(hub, user);
 			}
 			else
 			{
-				on_login_success(hub, user);
+				/* Race condition, we could have two messages for two logins queued up.
+				   So make sure we don't let the second client in. */
+				status = check_duplicate_logins_ok(hub, user);
+				if (!status)
+				{
+					on_login_success(hub, user);
+				}
+				else
+				{
+					on_login_failure(hub, user, (enum status_message) status);
+				}
 			}
 			break;
 		}
 
 		case UHUB_EVENT_USER_QUIT:
 		{
-			uman_remove(hub, user);
-			uman_send_quit_message(hub, user);
+			uman_remove(hub->users, user);
+			uman_send_quit_message(hub, hub->users, user);
 			on_logout_user(hub, user);
 			hub_schedule_destroy_user(hub, user);
 			break;
 		}
-		
+
 		case UHUB_EVENT_USER_DESTROY:
 		{
 			user_destroy(user);
@@ -537,7 +586,7 @@ static void hub_event_dispatcher(void* callback_data, struct event_data* message
 			struct hub_user* u = (struct hub_user*) list_get_first(hub->users->list);
 			while (u)
 			{
-				uman_remove(hub, u);
+				uman_remove(hub->users, u);
 				user_destroy(u);
 				u = (struct hub_user*) list_get_first(hub->users->list);
 			}
@@ -551,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;
@@ -657,40 +731,25 @@ static int load_ssl_certificates(struct hub_info* hub, struct hub_config* config
 {
 	if (config->tls_enable)
 	{
-		hub->ssl_method = SSLv23_method(); /* TLSv1_method() */
-		hub->ssl_ctx = SSL_CTX_new(hub->ssl_method);
-
-		/* Disable SSLv2 */
-		SSL_CTX_set_options(hub->ssl_ctx, SSL_OP_NO_SSLv2);
-
-		if (SSL_CTX_use_certificate_file(hub->ssl_ctx, config->tls_certificate, SSL_FILETYPE_PEM) < 0)
+		hub->ctx = net_ssl_context_create();
+		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;
 		}
-
-		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 0;
 	}
 	return 1;
 }
 
 static void unload_ssl_certificates(struct hub_info* hub)
 {
-	if (hub->ssl_ctx)
-	{
-		SSL_CTX_free(hub->ssl_ctx);
-	}
+	if (hub->ctx)
+		net_ssl_context_destroy(hub->ctx);
 }
-#endif
+#endif /* SSL_SUPPORT */
 
 struct hub_info* hub_start_service(struct hub_config* config)
 {
@@ -731,7 +790,8 @@ struct hub_info* hub_start_service(struct hub_config* config)
 	hub->config = config;
 	hub->users = NULL;
 
-	if (uman_init(hub) == -1)
+	hub->users = uman_init();
+	if (!hub->users)
 	{
 		net_con_close(hub->server);
 		hub_free(hub);
@@ -741,7 +801,7 @@ struct hub_info* hub_start_service(struct hub_config* config)
 	if (event_queue_initialize(&hub->queue, hub_event_dispatcher, (void*) hub) == -1)
 	{
 		net_con_close(hub->server);
-		uman_shutdown(hub);
+		uman_shutdown(hub->users);
 		hub_free(hub);
 		return 0;
 	}
@@ -753,30 +813,27 @@ struct hub_info* hub_start_service(struct hub_config* config)
 		net_con_close(hub->server);
 		hub_free(hub->recvbuf);
 		hub_free(hub->sendbuf);
-		uman_shutdown(hub);
+		uman_shutdown(hub->users);
 		hub_free(hub);
 		return 0;
 	}
 
-	hub->chat_history = (struct linked_list*) list_create();
 	hub->logout_info  = (struct linked_list*) list_create();
-	if (!hub->chat_history)
-	{
-		net_con_close(hub->server);
-		list_destroy(hub->chat_history);
-		list_destroy(hub->logout_info);
-		hub_free(hub->recvbuf);
-		hub_free(hub->sendbuf);
-		uman_shutdown(hub);
-		hub_free(hub);
-		return 0;
-	}
-
 	server_alt_port_start(hub, config);
 
 	hub->status = hub_status_running;
 
 	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;
 }
 
@@ -785,83 +842,80 @@ 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
 
 	event_queue_shutdown(hub->queue);
 	net_con_close(hub->server);
-	hub_free(hub->server);
 	server_alt_port_stop(hub);
-	uman_shutdown(hub);
+	uman_shutdown(hub->users);
 	hub->status = hub_status_stopped;
 	hub_free(hub->sendbuf);
 	hub_free(hub->recvbuf);
-	hub_chat_history_clear(hub);
-	list_destroy(hub->chat_history);
 	list_clear(hub->logout_info, &hub_free);
 	list_destroy(hub->logout_info);
+	command_shutdown(hub->commands);
 	hub_free(hub);
 	hub = 0;
 	g_hub = 0;
 }
 
+int hub_plugins_load(struct hub_info* hub)
+{
+	if (!hub->config->file_plugins || !*hub->config->file_plugins)
+		return 0;
+
+	hub->plugins = hub_malloc_zero(sizeof(struct uhub_plugins));
+	if (!hub->plugins)
+		return -1;
+
+	if (plugin_initialize(hub->config, hub) < 0)
+	{
+		hub_free(hub->plugins);
+		hub->plugins = 0;
+		return -1;
+	}
+	return 0;
+}
+
+void hub_plugins_unload(struct hub_info* hub)
+{
+	if (hub->plugins)
+	{
+		plugin_shutdown(hub->plugins);
+		hub_free(hub->plugins);
+		hub->plugins = 0;
+	}
+}
+
 void hub_set_variables(struct hub_info* hub, struct acl_handle* acl)
 {
-	int fd, ret;
-	char buf[MAX_RECV_BUF];
 	char* tmp;
 	char* server = adc_msg_escape(PRODUCT_STRING); /* FIXME: OOM */
-	
+
 	hub->acl = acl;
 	hub->command_info = adc_msg_construct(ADC_CMD_IINF, 15);
 	if (hub->command_info)
 	{
 		adc_msg_add_named_argument(hub->command_info, ADC_INF_FLAG_CLIENT_TYPE, ADC_CLIENT_TYPE_HUB);
 		adc_msg_add_named_argument(hub->command_info, ADC_INF_FLAG_USER_AGENT, server);
-	
+
 		tmp = adc_msg_escape(hub->config->hub_name);
 		adc_msg_add_named_argument(hub->command_info, ADC_INF_FLAG_NICK, tmp);
 		hub_free(tmp);
-	
+
 		tmp = adc_msg_escape(hub->config->hub_description);
 		adc_msg_add_named_argument(hub->command_info, ADC_INF_FLAG_DESCRIPTION, tmp);
 		hub_free(tmp);
 	}
 
-	/* (Re-)read the message of the day */
-	hub->command_motd = 0;
-	fd = (hub->config->file_motd && *hub->config->file_motd) ? open(hub->config->file_motd, 0) : -1;
-	if (fd != -1)
-	{
-		ret = read(fd, buf, MAX_RECV_BUF);
-		if (ret > 0)
-		{
-			buf[ret] = 0;
-			tmp = adc_msg_escape(buf);
-			hub->command_motd = adc_msg_construct(ADC_CMD_IMSG, 6 + strlen(tmp));
-			adc_msg_add_argument(hub->command_motd, tmp);
-			hub_free(tmp);
-		}
-		close(fd);
-	}
-
-	hub->command_rules = 0;
-	fd = (hub->config->file_rules && *hub->config->file_rules) ? open(hub->config->file_rules, 0) : -1;
-	if (fd != -1)
-	{
-		ret = read(fd, buf, MAX_RECV_BUF);
-		if (ret > 0)
-		{
-			buf[ret] = 0;
-			tmp = adc_msg_escape(buf);
-			hub->command_rules = adc_msg_construct(ADC_CMD_IMSG, 6 + strlen(tmp));
-			adc_msg_add_argument(hub->command_rules, tmp);
-			hub_free(tmp);
-		}
-		close(fd);
-	}
-
 	hub->command_support = adc_msg_construct(ADC_CMD_ISUP, 6 + strlen(ADC_PROTO_SUPPORT));
 	if (hub->command_support)
 	{
@@ -880,6 +934,13 @@ void hub_set_variables(struct hub_info* hub, struct acl_handle* acl)
 		hub_free(tmp);
 	}
 
+	if (hub_plugins_load(hub) < 0)
+	{
+		LOG_FATAL("Unable to load plugins.");
+		hub->status = hub_status_shutdown;
+	}
+	else
+
 	hub->status = (hub->config->hub_enabled ? hub_status_running : hub_status_disabled);
 	hub_free(server);
 }
@@ -887,49 +948,13 @@ void hub_set_variables(struct hub_info* hub, struct acl_handle* acl)
 
 void hub_free_variables(struct hub_info* hub)
 {
+	hub_plugins_unload(hub);
+
 	adc_msg_free(hub->command_info);
 	adc_msg_free(hub->command_banner);
-
-	if (hub->command_motd)
-		adc_msg_free(hub->command_motd);
-
-	if (hub->command_rules)
-		adc_msg_free(hub->command_rules);
-
 	adc_msg_free(hub->command_support);
 }
 
-
-/**
- * @return 1 if nickname is in use, or 0 if not used.
- */
-static inline int is_nick_in_use(struct hub_info* hub, const char* nick)
-{
-	struct hub_user* lookup = uman_get_user_by_nick(hub, nick);
-	if (lookup)
-	{
-		return 1;
-	}
-	return 0;
-}
-
-
-/**
- * @return 1 if CID is in use, or 0 if not used.
- */
-static inline int is_cid_in_use(struct hub_info* hub, const char* cid)
-{
-	struct hub_user* lookup = uman_get_user_by_cid(hub, cid);
-	if (lookup)
-	{
-		return 1;
-	}
-	return 0;
-}
-
-
-
-
 static void set_status_code(enum msg_status_level level, int code, char buffer[4])
 {
 	buffer[0] = ('0' + (int) level);
@@ -1000,7 +1025,7 @@ void hub_send_status(struct hub_info* hub, struct hub_user* user, enum status_me
 		STATUS(40, msg_proto_obsolete_adc0, 0, -1, 1);
 	}
 #undef STATUS
-	
+
 	escaped_text = adc_msg_escape(text);
 
 	adc_msg_add_argument(cmd, code);
@@ -1015,6 +1040,8 @@ void hub_send_status(struct hub_info* hub, struct hub_user* user, enum status_me
 
 	if (level >= status_level_fatal)
 	{
+		adc_msg_add_argument(qui, sid_to_string(user->id.sid));
+
 		snprintf(buf, 230, "MS%s", escaped_text);
 		adc_msg_add_argument(qui, buf);
 
@@ -1082,42 +1109,42 @@ const char* hub_get_status_message(struct hub_info* hub, enum status_message msg
 const char* hub_get_status_message_log(struct hub_info* hub, enum status_message msg)
 {
 #define STATUS(MSG) case status_ ## MSG : return #MSG; break
-        switch (msg)
-        {
-                STATUS(msg_hub_full);
-                STATUS(msg_hub_disabled);
-                STATUS(msg_hub_registered_users_only);
-                STATUS(msg_inf_error_nick_missing);
-                STATUS(msg_inf_error_nick_multiple);
-                STATUS(msg_inf_error_nick_invalid);
-                STATUS(msg_inf_error_nick_long);
-                STATUS(msg_inf_error_nick_short);
-                STATUS(msg_inf_error_nick_spaces);
-                STATUS(msg_inf_error_nick_bad_chars);
-                STATUS(msg_inf_error_nick_not_utf8);
-                STATUS(msg_inf_error_nick_taken);
-                STATUS(msg_inf_error_nick_restricted);
-                STATUS(msg_inf_error_cid_invalid);
-                STATUS(msg_inf_error_cid_missing);
-                STATUS(msg_inf_error_cid_taken);
-                STATUS(msg_inf_error_pid_missing);
-                STATUS(msg_inf_error_pid_invalid);
-                STATUS(msg_ban_permanently);
-                STATUS(msg_ban_temporarily);
-                STATUS(msg_auth_invalid_password);
-                STATUS(msg_auth_user_not_found);
-                STATUS(msg_error_no_memory);
-                STATUS(msg_user_share_size_low);
-                STATUS(msg_user_share_size_high);
-                STATUS(msg_user_slots_low);
-                STATUS(msg_user_slots_high);
-                STATUS(msg_user_hub_limit_low);
-                STATUS(msg_user_hub_limit_high);
+	switch (msg)
+	{
+		STATUS(msg_hub_full);
+		STATUS(msg_hub_disabled);
+		STATUS(msg_hub_registered_users_only);
+		STATUS(msg_inf_error_nick_missing);
+		STATUS(msg_inf_error_nick_multiple);
+		STATUS(msg_inf_error_nick_invalid);
+		STATUS(msg_inf_error_nick_long);
+		STATUS(msg_inf_error_nick_short);
+		STATUS(msg_inf_error_nick_spaces);
+		STATUS(msg_inf_error_nick_bad_chars);
+		STATUS(msg_inf_error_nick_not_utf8);
+		STATUS(msg_inf_error_nick_taken);
+		STATUS(msg_inf_error_nick_restricted);
+		STATUS(msg_inf_error_cid_invalid);
+		STATUS(msg_inf_error_cid_missing);
+		STATUS(msg_inf_error_cid_taken);
+		STATUS(msg_inf_error_pid_missing);
+		STATUS(msg_inf_error_pid_invalid);
+		STATUS(msg_ban_permanently);
+		STATUS(msg_ban_temporarily);
+		STATUS(msg_auth_invalid_password);
+		STATUS(msg_auth_user_not_found);
+		STATUS(msg_error_no_memory);
+		STATUS(msg_user_share_size_low);
+		STATUS(msg_user_share_size_high);
+		STATUS(msg_user_slots_low);
+		STATUS(msg_user_slots_high);
+		STATUS(msg_user_hub_limit_low);
+		STATUS(msg_user_hub_limit_high);
 		STATUS(msg_proto_no_common_hash);
 		STATUS(msg_proto_obsolete_adc0);
-        }
+	}
 #undef STATUS
-        return "unknown";
+	return "unknown";
 }
 
 
@@ -1143,12 +1170,16 @@ uint64_t hub_get_shared_files(struct hub_info* hub)
 
 uint64_t hub_get_min_share(struct hub_info* hub)
 {
-	return 1024 * 1024 * hub->config->limit_min_share;
+	uint64_t size = hub->config->limit_min_share;
+	size *= (1024 * 1024);
+	return size;
 }
 
 uint64_t hub_get_max_share(struct hub_info* hub)
 {
-	return 1024 * 1024 * hub->config->limit_max_share;
+        uint64_t size = hub->config->limit_max_share;
+        size *= (1024 * 1024);
+        return size;
 }
 
 size_t hub_get_min_slots(struct hub_info* hub)
@@ -1227,7 +1258,7 @@ void hub_event_loop(struct hub_info* hub)
 		event_queue_process(hub->queue);
 	}
 	while (hub->status == hub_status_running || hub->status == hub_status_disabled);
-	
+
 
 	if (hub->status == hub_status_shutdown)
 	{
@@ -1258,11 +1289,11 @@ void hub_disconnect_user(struct hub_info* hub, struct hub_user* user, int reason
 	user->connection = 0;
 
 	LOG_TRACE("hub_disconnect_user(), user=%p, reason=%d, state=%d", user, reason, user->state);
-	
+
 	need_notify = user_is_logged_in(user) && hub->status == hub_status_running;
 	user->quit_reason = reason;
 	user_set_state(user, state_cleanup);
-	
+
 	if (need_notify)
 	{
 		memset(&post, 0, sizeof(post));
@@ -1281,8 +1312,8 @@ void hub_logout_log(struct hub_info* hub, struct hub_user* user)
 	struct hub_logout_info* loginfo = hub_malloc_zero(sizeof(struct hub_logout_info));
 	if (!loginfo) return;
 	loginfo->time = time(NULL);
-	strcpy(loginfo->cid, user->id.cid);
-	strcpy(loginfo->nick, user->id.nick);
+	memcpy(loginfo->cid, user->id.cid, sizeof(loginfo->cid));
+	memcpy(loginfo->nick, user->id.nick, sizeof(loginfo->nick));
 	memcpy(&loginfo->addr, &user->id.addr, sizeof(struct ip_addr_encap));
 	loginfo->reason = user->quit_reason;
 

src/core/hub.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -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
@@ -103,20 +104,19 @@ struct hub_info
 	struct acl_handle* acl;
 	struct adc_message* command_info;    /* The hub's INF command */
 	struct adc_message* command_support; /* The hub's SUP command */
-	struct adc_message* command_motd;    /* The message of the day */
-	struct adc_message* command_rules;   /* The hub rules */
 	struct adc_message* command_banner;  /* The default welcome message */
 	time_t tm_started;
 	int status;
 	char* recvbuf; /* Global receive buffer */
 	char* sendbuf; /* Global send buffer */
 
-	struct linked_list* chat_history;    /* Chat history */
 	struct linked_list* logout_info;     /* Log of people logging out. */
 
+	struct command_base* commands;       /* Hub command handler */
+	struct uhub_plugins* plugins;        /* Plug-ins loaded for this hub instance. */
+
 #ifdef SSL_SUPPORT
-	SSL_METHOD* ssl_method;
-	SSL_CTX* ssl_ctx;
+	struct ssl_context_handle* ctx;
 #endif /*  SSL_SUPPORT */
 };
 
@@ -150,16 +150,6 @@ extern int hub_handle_password(struct hub_info* hub, struct hub_user* u, struct
  */
 extern int hub_handle_chat_message(struct hub_info* hub, struct hub_user* u, struct adc_message* cmd);
 
-/**
- * Add a chat message to the chat history
- */
-extern void hub_chat_history_add(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd);
-
-/**
- * Clear the chat history.
- */
-extern void hub_chat_history_clear(struct hub_info* hub);
-
 /**
  * Used internally by hub_handle_info
  * @return 1 if nickname is OK, or 0 if nickname is not accepted.
@@ -202,19 +192,6 @@ extern void hub_send_hubinfo(struct hub_info* hub, struct hub_user* u);
  */
 extern void hub_send_handshake(struct hub_info* hub, struct hub_user* u);
 
-/**
- * Send a welcome message containing the message of the day to 
- * one particular user. This can be sent in any point in time.
- * @return 1 if the motd were sent.
- */
-extern int hub_send_motd(struct hub_info* hub, struct hub_user* u);
-
-/**
- * Send the rules if configured.
- * @return 1 if the rules were sent.
- */
-extern int hub_send_rules(struct hub_info* hub, struct hub_user* u);
-
 /**
  * Send a password challenge to a user.
  * This is only used if the user tries to access the hub using a

src/core/hubevent.c

@@ -18,66 +18,24 @@
  */
 
 #include "uhub.h"
+#include "plugin_api/handle.h"
 
-static void log_user_login(struct hub_user* u)
-{
-	const char* cred = get_user_credential_string(u->credentials);
-	const char* addr = user_get_address(u);
-	LOG_USER("LoginOK     %s/%s %s \"%s\" (%s) \"%s\"", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, cred, u->user_agent);
-}
-
-static void log_user_login_error(struct hub_user* u, enum status_message msg)
-{
-	const char* addr = user_get_address(u);
-	const char* message = hub_get_status_message_log(u->hub, msg);
-	LOG_USER("LoginError  %s/%s %s \"%s\" (%s) \"%s\"", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, message, u->user_agent);
-}
-
-static void log_user_update_error(struct hub_user* u, enum status_message msg)
-{
-	const char* addr = user_get_address(u);
-	const char* message = hub_get_status_message_log(u->hub, msg);
-	LOG_USER("UpdateError %s/%s %s \"%s\" (%s) \"%s\"", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, message, u->user_agent);
-}
-
-static void log_user_logout(struct hub_user* u, const char* message)
-{
-	const char* addr = user_get_address(u);
-	LOG_USER("Logout      %s/%s %s \"%s\" (%s)", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, message);
-}
-
-static void log_user_nick_change(struct hub_user* u, const char* nick)
-{
-	const char* addr = user_get_address(u);
-	LOG_USER("NickChange  %s/%s %s \"%s\" -> \"%s\"", sid_to_string(u->id.sid), u->id.cid, addr, u->id.nick, nick);
-}
-
-
-/* Send MOTD, do logging etc */
+/* Notify plugins, etc */
 void on_login_success(struct hub_info* hub, struct hub_user* u)
 {
 	/* Send user list of all existing users */
-	if (!uman_send_user_list(hub, u))
+	if (!uman_send_user_list(hub, hub->users, u))
 		return;
 
 	/* Mark as being in the normal state, and add user to the user list */
 	user_set_state(u, state_normal);
-	uman_add(hub, u);
-
-	/* Print log message */
-	log_user_login(u);
+	uman_add(hub->users, u);
 
 	/* Announce new user to all connected users */
 	if (user_is_logged_in(u))
 		route_info_message(hub, u);
-	
-	/* Send message of the day (if any) */
-	if (user_is_logged_in(u)) /* Previous send() can fail! */
-		hub_send_motd(hub, u);
 
-	/* Send message of the day (if any) */
-	if (user_is_logged_in(u)) /* Previous send() can fail! */
-		hub_send_rules(hub, u);
+	plugin_log_user_login_success(hub, u);
 
 	/* reset timeout */
 	net_con_clear_timeout(u->connection);
@@ -85,14 +43,14 @@ void on_login_success(struct hub_info* hub, struct hub_user* u)
 
 void on_login_failure(struct hub_info* hub, struct hub_user* u, enum status_message msg)
 {
-	log_user_login_error(u, msg);
+	plugin_log_user_login_error(hub, u, hub_get_status_message_log(hub, msg));
 	hub_send_status(hub, u, msg, status_level_fatal);
 	hub_disconnect_user(hub, u, quit_logon_error);
 }
 
 void on_update_failure(struct hub_info* hub, struct hub_user* u, enum status_message msg)
 {
-	log_user_update_error(u, msg);
+	plugin_log_user_update_error(hub, u, hub_get_status_message_log(hub, msg));
 	hub_send_status(hub, u, msg, status_level_fatal);
 	hub_disconnect_user(hub, u, quit_update_error);
 }
@@ -101,14 +59,15 @@ void on_nick_change(struct hub_info* hub, struct hub_user* u, const char* nick)
 {
 	if (user_is_logged_in(u))
 	{
-		log_user_nick_change(u, nick);
+		plugin_log_user_nick_change(hub, u, nick);
 	}
 }
 
 void on_logout_user(struct hub_info* hub, struct hub_user* user)
 {
 	const char* reason = user_get_quit_reason_string(user->quit_reason);
-	log_user_logout(user, reason);
+
+	plugin_log_user_logout(hub, user, reason);
 	hub_logout_log(hub, user);
 }
 

src/core/inf.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2011, 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
@@ -226,9 +226,7 @@ static int check_network(struct hub_info* hub, struct hub_user* user, struct adc
 static void strip_network(struct hub_user* user, struct adc_message* cmd)
 {
 	adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV6_ADDR);
-	adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV6_UDP_PORT);
 	adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV4_ADDR);
-	adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV4_UDP_PORT);
 }
 
 static int nick_length_ok(const char* nick)
@@ -327,8 +325,8 @@ static int check_nick(struct hub_info* hub, struct hub_user* user, struct adc_me
 
 static int check_logged_in(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
 {
-	struct hub_user* lookup1 = uman_get_user_by_nick(hub, user->id.nick);
-	struct hub_user* lookup2 = uman_get_user_by_cid(hub,  user->id.cid);
+	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)
 	{
@@ -378,7 +376,7 @@ static int check_user_agent(struct hub_info* hub, struct hub_user* user, struct
 		ua = adc_msg_unescape(ua_encoded);
 		if (ua)
 		{
-			memcpy(user->user_agent, ua, MIN(strlen(ua), MAX_UA_LEN));
+			memcpy(user->id.user_agent, ua, MIN(strlen(ua), MAX_UA_LEN));
 			hub_free(ua);
 		}
 	}
@@ -429,7 +427,7 @@ static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_
 	arg = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_SHARED_FILES);
 	if (arg)
 	{
-		ssize_t shared_files = atoll(arg);
+		int shared_files = atoi(arg);
 		if (shared_files < 0)
 			shared_files = 0;
 
@@ -446,7 +444,7 @@ static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_
 	arg = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_COUNT_HUB_NORMAL);
 	if (arg)
 	{
-		ssize_t num = atoll(arg);
+		int num = atoi(arg);
 		if (num < 0) num = 0;
 		user->limits.hub_count_user = num;
 		hub_free(arg);
@@ -456,7 +454,7 @@ static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_
 	arg = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_COUNT_HUB_REGISTER);
 	if (arg)
 	{
-		ssize_t num = atoll(arg);
+		int num = atoi(arg);
 		if (num < 0) num = 0;
 		user->limits.hub_count_registered = num;
 		hub_free(arg);
@@ -466,7 +464,7 @@ static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_
 	arg = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_COUNT_HUB_OPERATOR);
 	if (arg)
 	{
-		ssize_t num = atoll(arg);
+		int num = atoi(arg);
 		if (num < 0) num = 0;
 		user->limits.hub_count_operator = num;
 		hub_free(arg);
@@ -476,7 +474,7 @@ static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_
 	arg = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_UPLOAD_SLOTS);
 	if (arg)
 	{
-		ssize_t num = atoll(arg);
+		int num = atoi(arg);
 		if (num < 0) num = 0;
 		user->limits.upload_slots = num;
 		hub_free(arg);
@@ -535,48 +533,49 @@ static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_
 static int set_credentials(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
 {
 	int ret = 0;
-	struct hub_user_access_info* info = acl_get_access_info(hub->acl, user->id.nick);
+	struct auth_info* info = acl_get_access_info(hub, user->id.nick);
 	
 	if (info)
 	{
-		user->credentials = info->status;
+		user->credentials = info->credentials;
 		ret = 1;
 	}
 	else
 	{
-		user->credentials = cred_guest;
+		user->credentials = auth_cred_guest;
 	}
-	
+	hub_free(info);
+
 	switch (user->credentials)
 	{
-		case cred_none:
+		case auth_cred_none:
 			break;
 			
-		case cred_bot:
+		case auth_cred_bot:
 			adc_msg_add_argument(cmd, ADC_INF_FLAG_CLIENT_TYPE ADC_CLIENT_TYPE_BOT);
 			break;
 			
-		case cred_guest:
+		case auth_cred_guest:
 			/* Nothing to be added to the info message */
 			break;
 
-		case cred_user:
+		case auth_cred_user:
 			adc_msg_add_argument(cmd, ADC_INF_FLAG_CLIENT_TYPE ADC_CLIENT_TYPE_REGISTERED_USER);
 			break;
 
-		case cred_operator:
+		case auth_cred_operator:
 			adc_msg_add_argument(cmd, ADC_INF_FLAG_CLIENT_TYPE ADC_CLIENT_TYPE_OPERATOR);
 			break;
 			
-		case cred_super:
+		case auth_cred_super:
 			adc_msg_add_argument(cmd, ADC_INF_FLAG_CLIENT_TYPE ADC_CLIENT_TYPE_SUPER_USER);
 			break;
 
-		case cred_admin:
+		case auth_cred_admin:
 			adc_msg_add_argument(cmd, ADC_INF_FLAG_CLIENT_TYPE ADC_CLIENT_TYPE_ADMIN);
 			break;
 
-		case cred_link:
+		case auth_cred_link:
 			break;
  	}
 	
@@ -591,7 +590,7 @@ static int check_is_hub_full(struct hub_info* hub, struct hub_user* user)
 	 * If hub is full, don't let users in, but we still want to allow
 	 * operators and admins to enter the hub.
 	 */
-	if (hub->config->max_users && hub->users->count >= hub->config->max_users && !user_is_protected(user))
+	if (hub->config->max_users && hub->users->count >= (size_t) hub->config->max_users && !user_is_protected(user))
 	{
 		return 1;
 	}

src/core/ioqueue.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,7 +18,6 @@
  */
 
 #include "uhub.h"
-#include "hubio.h"
 
 #ifdef DEBUG_SENDQ
 static void debug_msg(const char* prefix, struct adc_message* msg)
@@ -35,13 +34,13 @@ static void debug_msg(const char* prefix, struct adc_message* msg)
 }
 #endif
 
-struct hub_recvq* hub_recvq_create()
+struct ioq_recv* ioq_recv_create()
 {
-	struct hub_recvq* q = hub_malloc_zero(sizeof(struct hub_recvq));
+	struct ioq_recv* q = hub_malloc_zero(sizeof(struct ioq_recv));
 	return q;
 }
 
-void hub_recvq_destroy(struct hub_recvq* q)
+void ioq_recv_destroy(struct ioq_recv* q)
 {
 	if (q)
 	{
@@ -50,9 +49,9 @@ void hub_recvq_destroy(struct hub_recvq* q)
 	}
 }
 
-size_t hub_recvq_get(struct hub_recvq* q, void* buf, size_t bufsize)
+size_t ioq_recv_get(struct ioq_recv* q, void* buf, size_t bufsize)
 {
-	assert(bufsize >= q->size);
+	uhub_assert(bufsize >= q->size);
 	if (q->size)
 	{
 		size_t n = q->size;
@@ -65,7 +64,7 @@ size_t hub_recvq_get(struct hub_recvq* q, void* buf, size_t bufsize)
 	return 0;
 }
 
-size_t hub_recvq_set(struct hub_recvq* q, void* buf, size_t bufsize)
+size_t ioq_recv_set(struct ioq_recv* q, void* buf, size_t bufsize)
 {
 	if (q->buf)
 	{
@@ -89,9 +88,9 @@ size_t hub_recvq_set(struct hub_recvq* q, void* buf, size_t bufsize)
 }
 
 
-struct hub_sendq* hub_sendq_create()
+struct ioq_send* ioq_send_create()
 {
-	struct hub_sendq* q = hub_malloc_zero(sizeof(struct hub_sendq));
+	struct ioq_send* q = hub_malloc_zero(sizeof(struct ioq_send));
 	if (!q)
 		return 0;
 
@@ -110,7 +109,7 @@ static void clear_send_queue_callback(void* ptr)
 	adc_msg_free((struct adc_message*) ptr);
 }
 
-void hub_sendq_destroy(struct hub_sendq* q)
+void ioq_send_destroy(struct ioq_send* q)
 {
 	if (q)
 	{
@@ -120,21 +119,21 @@ void hub_sendq_destroy(struct hub_sendq* q)
 	}
 }
 
-void hub_sendq_add(struct hub_sendq* q, struct adc_message* msg_)
+void ioq_send_add(struct ioq_send* q, struct adc_message* msg_)
 {
 	struct adc_message* msg = adc_msg_incref(msg_);
 #ifdef DEBUG_SENDQ
-	debug_msg("hub_sendq_add", msg);
+	debug_msg("ioq_send_add", msg);
 #endif
-	assert(msg->cache && *msg->cache);
+	uhub_assert(msg->cache && *msg->cache);
 	list_append(q->queue, msg);
 	q->size += msg->length;
 }
 
-void hub_sendq_remove(struct hub_sendq* q, struct adc_message* msg)
+void ioq_send_remove(struct ioq_send* q, struct adc_message* msg)
 {
 #ifdef DEBUG_SENDQ
-	debug_msg("hub_sendq_remove", msg);
+	debug_msg("ioq_send_remove", msg);
 #endif
 	list_remove(q->queue, msg);
 	q->size  -= msg->length;
@@ -142,13 +141,13 @@ void hub_sendq_remove(struct hub_sendq* q, struct adc_message* msg)
 	q->offset = 0;
 }
 
-int hub_sendq_send(struct hub_sendq* 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;
-	assert(msg->cache && *msg->cache);
-	ret = net_con_send(user->connection, msg->cache + q->offset, msg->length - q->offset);
+	uhub_assert(msg->cache && *msg->cache);
+	ret = net_con_send(con, msg->cache + q->offset, msg->length - q->offset);
 
 	if (ret > 0)
 	{
@@ -156,18 +155,18 @@ int hub_sendq_send(struct hub_sendq* q, struct hub_user* user)
 		if (msg->length - q->offset > 0)
 			return 0;
 
-		hub_sendq_remove(q, msg);
+		ioq_send_remove(q, msg);
 		return 1;
 	}
 	return ret;
 }
 
-int hub_sendq_is_empty(struct hub_sendq* q)
+int ioq_send_is_empty(struct ioq_send* q)
 {
 	return (q->size - q->offset) == 0;
 }
 
-size_t hub_sendq_get_bytes(struct hub_sendq* q)
+size_t ioq_send_get_bytes(struct ioq_send* q)
 {
 	return q->size - q->offset;
 }

src/core/ioqueue.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,25 +17,25 @@
  *
  */
 
-#ifndef HAVE_UHUB_HUB_IO_H
-#define HAVE_UHUB_HUB_IO_H
+#ifndef HAVE_UHUB_IO_QUEUE_H
+#define HAVE_UHUB_IO_QUEUE_H
 
 struct adc_message;
 struct linked_list;
-typedef int (*hub_recvq_write)(void* desc, const void* buf, size_t len);
-typedef int (*hub_recvq_read)(void* desc, void* buf, size_t len);
+typedef int (*ioq_write)(void* desc, const void* buf, size_t len);
+typedef int (*ioq_read)(void* desc, void* buf, size_t len);
 
-struct hub_sendq
+struct ioq_send
 {
 	size_t               size;      /** Size of send queue (in bytes, not messages) */
 	size_t               offset;    /** Queue byte offset in the first message. Should be 0 unless a partial write. */
 #ifdef SSL_SUPPORT
 	size_t               last_send; /** When using SSL, one have to send the exact same buffer and length if a write cannot complete. */
 #endif
-	struct linked_list*  queue;     /** List of queued messages */
+	struct linked_list*  queue;     /** List of queued messages (struct adc_message) */
 };
 
-struct hub_recvq
+struct ioq_recv
 {
 	char* buf;
 	size_t size;
@@ -44,63 +44,63 @@ struct hub_recvq
 /**
  * Create a send queue
  */
-extern struct hub_sendq* hub_sendq_create();
+extern struct ioq_send* ioq_send_create();
 
 /**
  * Destroy a send queue, and delete any queued messages.
  */
-extern void hub_sendq_destroy(struct hub_sendq*);
+extern void ioq_send_destroy(struct ioq_send*);
 
 /**
  * Add a message to the send queue.
  */
-extern void hub_sendq_add(struct hub_sendq*, struct adc_message* msg);
+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  hub_sendq_send(struct hub_sendq*, struct hub_user*);
+extern int  ioq_send_send(struct ioq_send*, struct net_connection* con);
 
 /**
  * @returns 1 if send queue is empty, 0 otherwise.
  */
-extern int hub_sendq_is_empty(struct hub_sendq*);
+extern int ioq_send_is_empty(struct ioq_send*);
 
 /**
  * @returns the number of bytes remaining to be sent in the queue.
  */
-extern size_t hub_sendq_get_bytes(struct hub_sendq*);
+extern size_t ioq_send_get_bytes(struct ioq_send*);
 
 
 
 /**
  * Create a receive queue.
  */
-extern struct hub_recvq* hub_recvq_create();
+extern struct ioq_recv* ioq_recv_create();
 
 /**
  * Destroy a receive queue.
  */
-extern void hub_recvq_destroy(struct hub_recvq*);
+extern void ioq_recv_destroy(struct ioq_recv*);
 
 /**
  * Gets the buffer, copies it into buf and deallocates it.
  * NOTE: bufsize *MUST* be larger than the buffer, otherwise it asserts.
  * @return the number of bytes copied into buf.
  */
-extern size_t hub_recvq_get(struct hub_recvq*, void* buf, size_t bufsize);
+extern size_t ioq_recv_get(struct ioq_recv*, void* buf, size_t bufsize);
 
 /**
  * Sets the buffer
  */
-extern size_t hub_recvq_set(struct hub_recvq*, void* buf, size_t bufsize);
+extern size_t ioq_recv_set(struct ioq_recv*, void* buf, size_t bufsize);
 
 /**
  * @return 1 if size is zero, 0 otherwise.
  */
-extern int hub_recvq_is_empty(struct hub_recvq* buf);
+extern int ioq_recv_is_empty(struct ioq_recv* buf);
 
 
 
-#endif /* HAVE_UHUB_HUB_IO_H */
+#endif /* HAVE_UHUB_IO_QUEUE_H */

src/core/main.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * Copyright (C) 2007-2011, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,7 +19,6 @@
 
 #include "uhub.h"
 
-
 static int arg_verbose = 5;
 static int arg_fork    = 0;
 static int arg_check_config = 0;
@@ -115,6 +114,11 @@ int main_loop()
 		{
 			LOG_INFO("Reloading configuration files...");
 			LOG_DEBUG("Hub status: %d", (int) hub->status);
+
+			/* Reinitialize logs */
+			hub_log_shutdown();
+			hub_log_initialize(arg_log, arg_log_syslog);
+			hub_set_log_verbosity(arg_verbose);
 		}
 	
 		if (read_config(arg_config, &configuration, !arg_have_config) == -1)
@@ -132,7 +136,13 @@ int main_loop()
 		{
 			hub = hub_start_service(&configuration);
 			if (!hub)
+			{
+				acl_shutdown(&acl);
+				free_config(&configuration);
+				net_destroy();
+				hub_log_shutdown();
 				return -1;
+			}
 #if !defined(WIN32)
 			setup_signal_handlers(hub);
 #endif

src/core/netevent.c

@@ -18,17 +18,14 @@
  */
 
 #include <uhub.h>
-#include "hubio.h"
+#include "ioqueue.h"
 #include "probe.h"
 
-/* FIXME: This should not be needed! */
-extern struct hub_info* g_hub;
-
 int handle_net_read(struct hub_user* user)
 {
 	static char buf[MAX_RECV_BUF];
-	struct hub_recvq* q = user->recv_queue;
-	size_t buf_size = hub_recvq_get(q, buf, MAX_RECV_BUF);
+	struct ioq_recv* q = user->recv_queue;
+	size_t buf_size = ioq_recv_get(q, buf, MAX_RECV_BUF);
 	ssize_t size;
 
 	if (user_flag_get(user, flag_maxbuf))
@@ -58,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
@@ -71,9 +68,9 @@ int handle_net_read(struct hub_user* user)
 			}
 			else
 			{
-				if (((pos - start) > 0) && g_hub->config->max_recv_buffer > (pos - start))
+				if (((pos - start) > 0) && user->hub->config->max_recv_buffer > (pos - start))
 				{
-					if (hub_handle_message(g_hub, user, start, (pos - start)) == -1)
+					if (hub_handle_message(user->hub, user, start, (pos - start)) == -1)
 					{
 							return quit_protocol_error;
 					}
@@ -88,20 +85,20 @@ int handle_net_read(struct hub_user* user)
 
 		if (lastPos || remaining)
 		{
-			if (remaining < g_hub->config->max_recv_buffer)
+			if (remaining < (size_t) user->hub->config->max_recv_buffer)
 			{
-				hub_recvq_set(q, lastPos ? lastPos : buf, remaining);
+				ioq_recv_set(q, lastPos ? lastPos : buf, remaining);
 			}
 			else
 			{
-				hub_recvq_set(q, 0, 0);
+				ioq_recv_set(q, 0, 0);
 				user_flag_set(user, flag_maxbuf);
 				LOG_WARN("Received message past max_recv_buffer, dropping message.");
 			}
 		}
 		else
 		{
-			hub_recvq_set(q, 0, 0);
+			ioq_recv_set(q, 0, 0);
 		}
 	}
 	return 0;
@@ -110,9 +107,9 @@ int handle_net_read(struct hub_user* user)
 int handle_net_write(struct hub_user* user)
 {
 	int ret = 0;
-	while (hub_sendq_get_bytes(user->send_queue))
+	while (ioq_send_get_bytes(user->send_queue))
 	{
-		ret = hub_sendq_send(user->send_queue, user);
+		ret = ioq_send_send(user->send_queue, user->connection);
 		if (ret <= 0)
 			break;
 	}
@@ -120,7 +117,7 @@ int handle_net_write(struct hub_user* user)
 	if (ret < 0)
 		return quit_socket_error;
 
-	if (hub_sendq_get_bytes(user->send_queue))
+	if (ioq_send_get_bytes(user->send_queue))
 	{
 		user_net_io_want_write(user);
 	}
@@ -144,7 +141,7 @@ void net_event(struct net_connection* con, int event, void *arg)
 	{
 		if (user_is_connecting(user))
 		{
-			hub_disconnect_user(g_hub, user, quit_timeout);
+			hub_disconnect_user(user->hub, user, quit_timeout);
 		}
 		return;
 	}
@@ -154,7 +151,7 @@ void net_event(struct net_connection* con, int event, void *arg)
 		flag_close = handle_net_read(user);
 		if (flag_close)
 		{
-			hub_disconnect_user(g_hub, user, flag_close);
+			hub_disconnect_user(user->hub, user, flag_close);
 			return;
 		}
 	}
@@ -164,7 +161,7 @@ void net_event(struct net_connection* con, int event, void *arg)
 		flag_close = handle_net_write(user);
 		if (flag_close)
 		{
-			hub_disconnect_user(g_hub, user, flag_close);
+			hub_disconnect_user(user->hub, user, flag_close);
 			return;
 		}
 	}
@@ -175,15 +172,19 @@ void net_on_accept(struct net_connection* con, int event, void *arg)
 	struct hub_info* hub = (struct hub_info*) arg;
 	struct hub_probe* probe = 0;
 	struct ip_addr_encap ipaddr;
-	const char* addr;
 	int server_fd = net_con_get_sd(con);
+	plugin_st status;
 
 	for (;;)
 	{
 		int fd = net_accept(server_fd, &ipaddr);
 		if (fd == -1)
 		{
+#ifdef WINSOCK
+			if (net_error() == WSAEWOULDBLOCK)
+#else
 			if (net_error() == EWOULDBLOCK)
+#endif
 			{
 				break;
 			}
@@ -194,19 +195,16 @@ void net_on_accept(struct net_connection* con, int event, void *arg)
 			}
 		}
 
-		addr = ip_convert_to_string(&ipaddr);
-
-		/* FIXME: Should have a plugin log this */
-		LOG_TRACE("Got connection from %s", addr);
-
-		/* FIXME: A plugin should perform this check: is IP banned? */
-		if (acl_is_ip_banned(hub->acl, addr))
+		status = plugin_check_ip_early(hub, &ipaddr);
+		if (status == st_deny)
 		{
-			LOG_INFO("Denied      [%s] (IP banned)", addr);
+			plugin_log_connection_denied(hub, &ipaddr);
 			net_close(fd);
 			continue;
 		}
 
+		plugin_log_connection_accepted(hub, &ipaddr);
+
 		probe = probe_create(hub, fd, &ipaddr);
 		if (!probe)
 		{

src/core/plugincallback.c

@@ -0,0 +1,228 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2011, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+#include "plugin_api/command_api.h"
+
+struct plugin_callback_data
+{
+	struct linked_list* commands;
+};
+
+static struct plugin_callback_data* get_callback_data(struct plugin_handle* plugin)
+{
+	return get_internals(plugin)->callback_data;
+}
+
+static int plugin_command_dispatch(struct command_base* cbase, struct hub_user* user, struct hub_command* cmd)
+{
+	struct plugin_handle* plugin = (struct plugin_handle*) cmd->ptr;
+	struct plugin_callback_data* data = get_callback_data(plugin);
+	struct plugin_command_handle* cmdh;
+	struct plugin_user* puser = (struct plugin_user*) user; // FIXME: Use a proper conversion function instead.
+	struct plugin_command* pcommand = (struct plugin_command*) cmd; // FIXME: Use a proper conversion function instead.
+
+	LOG_PLUGIN("plugin_command_dispatch: cmd=%s", cmd->prefix);
+
+	cmdh = (struct plugin_command_handle*) list_get_first(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;
+}
+
+static struct hub_user* convert_user_type(struct plugin_user* user)
+{
+	struct hub_user* huser = (struct hub_user*) user;
+	return huser;
+}
+
+static int cbfunc_send_message(struct plugin_handle* plugin, struct plugin_user* user, 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_user(plugin_get_hub(plugin), convert_user_type(user), 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];
+	char* buffer = adc_msg_escape(message);
+	struct adc_message* command = adc_msg_construct(ADC_CMD_ISTA, strlen(buffer) + 10);
+	snprintf(code_str, sizeof(code_str), "%03d", code);
+	adc_msg_add_argument(command, code_str);
+	adc_msg_add_argument(command, buffer);
+	route_to_user(plugin_get_hub(plugin), convert_user_type(user), command);
+	adc_msg_free(command);
+	hub_free(buffer);
+	return 1;
+}
+
+static int cbfunc_user_disconnect(struct plugin_handle* plugin, struct plugin_user* user)
+{
+	hub_disconnect_user(plugin_get_hub(plugin), convert_user_type(user), quit_kicked);
+	return 0;
+}
+
+static int cbfunc_command_add(struct plugin_handle* plugin, struct plugin_command_handle* cmdh)
+{
+	struct plugin_callback_data* data = get_callback_data(plugin);
+	struct command_handle* command = (struct command_handle*) hub_malloc_zero(sizeof(struct command_handle));
+
+	command->prefix = cmdh->prefix;
+	command->length = cmdh->length;
+	command->args = cmdh->args;
+	command->cred = cmdh->cred;
+	command->description = cmdh->description;
+	command->origin = cmdh->origin;
+	command->handler = plugin_command_dispatch;
+
+	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;
+}
+
+static int cbfunc_command_del(struct plugin_handle* plugin, struct plugin_command_handle* cmdh)
+{
+	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);
+	cmdh->internal_handle = NULL;
+	return 0;
+}
+
+size_t cbfunc_command_arg_reset(struct plugin_handle* plugin, struct plugin_command* cmd)
+{
+	// TODO: Use proper function for rewriting for plugin_command -> hub_command
+	return hub_command_arg_reset((struct hub_command*) cmd);
+}
+
+struct plugin_command_arg_data* cbfunc_command_arg_next(struct plugin_handle* plugin, struct plugin_command* cmd, enum plugin_command_arg_type t)
+{
+	// TODO: Use proper function for rewriting for plugin_command -> hub_command
+	return (struct plugin_command_arg_data*) hub_command_arg_next((struct hub_command*) cmd, (enum hub_command_arg_type) t);
+}
+
+static char* cbfunc_get_hub_name(struct plugin_handle* plugin)
+{
+	struct hub_info* hub = plugin_get_hub(plugin);
+	char* str_encoded = adc_msg_get_named_argument(hub->command_info, ADC_INF_FLAG_NICK);
+	char* str = adc_msg_unescape(str_encoded);
+	hub_free(str_encoded);
+	return str;
+}
+
+static char* cbfunc_get_hub_description(struct plugin_handle* plugin)
+{
+	struct hub_info* hub = plugin_get_hub(plugin);
+	char* str_encoded = adc_msg_get_named_argument(hub->command_info, ADC_INF_FLAG_DESCRIPTION);
+	char* str = adc_msg_unescape(str_encoded);
+	hub_free(str_encoded);
+	return str;
+}
+
+static void cbfunc_set_hub_name(struct plugin_handle* plugin, const char* str)
+{
+	struct hub_info* hub = plugin_get_hub(plugin);
+	struct adc_message* command;
+	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);
+	route_to_all(hub, command);
+
+	adc_msg_free(command);
+	hub_free(new_str);
+}
+
+static void cbfunc_set_hub_description(struct plugin_handle* plugin, const char* str)
+{
+	struct hub_info* hub = plugin_get_hub(plugin);
+	struct adc_message* command;
+	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);
+	route_to_all(hub, command);
+
+	adc_msg_free(command);
+	hub_free(new_str);
+}
+
+void plugin_register_callback_functions(struct plugin_handle* handle)
+{
+	handle->hub.send_message = cbfunc_send_message;
+	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_name = cbfunc_get_hub_name;
+	handle->hub.set_name = cbfunc_set_hub_name;
+	handle->hub.get_description = cbfunc_get_hub_description;
+	handle->hub.set_description = cbfunc_set_hub_description;
+}
+
+void plugin_unregister_callback_functions(struct plugin_handle* handle)
+{
+}
+
+struct plugin_callback_data* plugin_callback_data_create()
+{
+	struct plugin_callback_data* data = (struct plugin_callback_data*) hub_malloc_zero(sizeof(struct plugin_callback_data));
+	LOG_PLUGIN("plugin_callback_data_create()");
+	data->commands = list_create();
+	return data;
+}
+
+void plugin_callback_data_destroy(struct plugin_handle* plugin, struct plugin_callback_data* data)
+{
+	LOG_PLUGIN("plugin_callback_data_destroy()");
+	if (data->commands)
+	{
+		// delete commands not deleted by the plugin itself:
+		struct plugin_command_handle* cmd;
+		while ( (cmd = list_get_first(data->commands)) )
+			cbfunc_command_del(plugin, cmd);
+		list_destroy(data->commands);
+	}
+
+	hub_free(data);
+}

src/core/plugincallback.h

@@ -0,0 +1,32 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2011, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_PLUGIN_CALLBACK_H
+#define HAVE_UHUB_PLUGIN_CALLBACK_H
+
+struct plugin_handle;
+struct uhub_plugin;
+
+extern struct plugin_callback_data* plugin_callback_data_create();
+extern void plugin_callback_data_destroy(struct plugin_handle* plugin, struct plugin_callback_data* data);
+
+extern void plugin_register_callback_functions(struct plugin_handle* plugin);
+extern void plugin_unregister_callback_functions(struct plugin_handle* plugin);
+
+#endif /* HAVE_UHUB_PLUGIN_CALLBACK_H */

src/core/plugininvoke.c

@@ -0,0 +1,198 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2011, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+#include "plugin_api/handle.h"
+
+#define PLUGIN_DEBUG(hub, name) LOG_PLUGIN("Invoke %s on %d plugins", name, (int) (hub->plugins ? list_size(hub->plugins->loaded) : -1));
+
+
+#define INVOKE(HUB, FUNCNAME, CODE) \
+	PLUGIN_DEBUG(HUB, # FUNCNAME) \
+	if (HUB->plugins && HUB->plugins->loaded) \
+	{ \
+		struct plugin_handle* plugin = (struct plugin_handle*) list_get_first(HUB->plugins->loaded); \
+		while (plugin) \
+		{ \
+			if (plugin->funcs.FUNCNAME) \
+				CODE \
+			plugin = (struct plugin_handle*) list_get_next(HUB->plugins->loaded); \
+		} \
+	}
+
+#define PLUGIN_INVOKE_STATUS_1(HUB, FUNCNAME, ARG1) \
+	do { \
+		plugin_st status = st_default; \
+		INVOKE(HUB, FUNCNAME, { \
+			status = plugin->funcs.FUNCNAME(plugin, ARG1); \
+			if (status != st_default) \
+				break; \
+		}); \
+		return status; \
+	} while(0)
+
+#define PLUGIN_INVOKE_STATUS_2(HUB, FUNCNAME, ARG1, ARG2) \
+	do { \
+		plugin_st status = st_default; \
+		INVOKE(HUB, FUNCNAME, { \
+			status = plugin->funcs.FUNCNAME(plugin, ARG1, ARG2); \
+			if (status != st_default) \
+				break; \
+		}); \
+		return status; \
+	} while(0)
+
+#define PLUGIN_INVOKE_STATUS_3(HUB, FUNCNAME, ARG1, ARG2, ARG3) \
+	do { \
+		plugin_st status = st_default; \
+		INVOKE(HUB, FUNCNAME, { \
+			status = plugin->funcs.FUNCNAME(plugin, ARG1, ARG2, ARG3); \
+			if (status != st_default) \
+				break; \
+		}); \
+		return status; \
+	} while(0)
+
+#define PLUGIN_INVOKE_1(HUB, FUNCNAME, ARG1) INVOKE(HUB, FUNCNAME, { plugin->funcs.FUNCNAME(plugin, ARG1); })
+#define PLUGIN_INVOKE_2(HUB, FUNCNAME, ARG1, ARG2) INVOKE(HUB, FUNCNAME, { plugin->funcs.FUNCNAME(plugin, ARG1, ARG2); })
+#define PLUGIN_INVOKE_3(HUB, FUNCNAME, ARG1, ARG2, ARG3) INVOKE(HUB, FUNCNAME, { plugin->funcs.FUNCNAME(plugin, ARG1, ARG2, ARG3); })
+
+
+static struct plugin_user* convert_user_type(struct hub_user* user)
+{
+	struct plugin_user* puser = (struct plugin_user*) user;
+	return puser;
+}
+
+plugin_st plugin_check_ip_early(struct hub_info* hub, struct ip_addr_encap* addr)
+{
+	PLUGIN_INVOKE_STATUS_1(hub, on_check_ip_early, addr);
+}
+
+plugin_st plugin_check_ip_late(struct hub_info* hub, struct hub_user* who, struct ip_addr_encap* addr)
+{
+	struct plugin_user* user = convert_user_type(who);
+	PLUGIN_INVOKE_STATUS_2(hub, on_check_ip_late, user, addr);
+}
+
+void plugin_log_connection_accepted(struct hub_info* hub, struct ip_addr_encap* ipaddr)
+{
+	PLUGIN_INVOKE_1(hub, on_connection_accepted, ipaddr);
+}
+
+void plugin_log_connection_denied(struct hub_info* hub, struct ip_addr_encap* ipaddr)
+{
+	PLUGIN_INVOKE_1(hub, on_connection_refused, ipaddr);
+}
+
+void plugin_log_user_login_success(struct hub_info* hub, struct hub_user* who)
+{
+	struct plugin_user* user = convert_user_type(who);
+	PLUGIN_INVOKE_1(hub, on_user_login, user);
+}
+
+void plugin_log_user_login_error(struct hub_info* hub, struct hub_user* who, const char* reason)
+{
+	struct plugin_user* user = convert_user_type(who);
+	PLUGIN_INVOKE_2(hub, on_user_login_error, user, reason);
+}
+
+void plugin_log_user_logout(struct hub_info* hub, struct hub_user* who, const char* reason)
+{
+	struct plugin_user* user = convert_user_type(who);
+	PLUGIN_INVOKE_2(hub, on_user_logout, user, reason);
+}
+
+void plugin_log_user_nick_change(struct hub_info* hub, struct hub_user* who, const char* new_nick)
+{
+	struct plugin_user* user = convert_user_type(who);
+	PLUGIN_INVOKE_2(hub, on_user_nick_change, user, new_nick);
+}
+
+void plugin_log_user_update_error(struct hub_info* hub, struct hub_user* who, const char* reason)
+{
+	struct plugin_user* user = convert_user_type(who);
+	PLUGIN_INVOKE_2(hub, on_user_update_error, user, reason);
+}
+
+void plugin_log_chat_message(struct hub_info* hub, struct hub_user* who, const char* message, int flags)
+{
+	struct plugin_user* user = convert_user_type(who);
+	PLUGIN_INVOKE_3(hub, on_user_chat_message, user, message, flags);
+}
+
+plugin_st plugin_handle_chat_message(struct hub_info* hub, struct hub_user* from, const char* message, int flags)
+{
+	struct plugin_user* user = convert_user_type(from);
+	PLUGIN_INVOKE_STATUS_2(hub, on_chat_msg, user, message);
+}
+
+plugin_st plugin_handle_private_message(struct hub_info* hub, struct hub_user* from, struct hub_user* to, const char* message, int flags)
+{
+	struct plugin_user* user1 = convert_user_type(from);
+	struct plugin_user* user2 = convert_user_type(to);
+	PLUGIN_INVOKE_STATUS_3(hub, on_private_msg, user1, user2, message);
+}
+
+plugin_st plugin_handle_search(struct hub_info* hub, struct hub_user* from, const char* data)
+{
+	struct plugin_user* user = convert_user_type(from);
+	PLUGIN_INVOKE_STATUS_2(hub, on_search, user, data);
+}
+
+plugin_st plugin_handle_search_result(struct hub_info* hub, struct hub_user* from, struct hub_user* to, const char* data)
+{
+	struct plugin_user* user1 = convert_user_type(from);
+	struct plugin_user* user2 = convert_user_type(to);
+	PLUGIN_INVOKE_STATUS_3(hub, on_search_result, user1, user2, data);
+}
+
+plugin_st plugin_handle_connect(struct hub_info* hub, struct hub_user* from, struct hub_user* to)
+{
+	struct plugin_user* user1 = convert_user_type(from);
+	struct plugin_user* user2 = convert_user_type(to);
+	PLUGIN_INVOKE_STATUS_2(hub, on_p2p_connect, user1, user2);
+}
+
+plugin_st plugin_handle_revconnect(struct hub_info* hub, struct hub_user* from, struct hub_user* to)
+{
+	struct plugin_user* user1 = convert_user_type(from);
+	struct plugin_user* user2 = convert_user_type(to);
+	PLUGIN_INVOKE_STATUS_2(hub, on_p2p_revconnect, user1, user2);
+}
+
+plugin_st plugin_auth_get_user(struct hub_info* hub, const char* nickname, struct auth_info* info)
+{
+	PLUGIN_INVOKE_STATUS_2(hub, auth_get_user, nickname, info);
+}
+
+plugin_st plugin_auth_register_user(struct hub_info* hub, struct auth_info* info)
+{
+	PLUGIN_INVOKE_STATUS_1(hub, auth_register_user, info);
+}
+
+plugin_st plugin_auth_update_user(struct hub_info* hub, struct auth_info* info)
+{
+	PLUGIN_INVOKE_STATUS_1(hub, auth_update_user, info);
+}
+
+plugin_st plugin_auth_delete_user(struct hub_info* hub, struct auth_info* info)
+{
+	PLUGIN_INVOKE_STATUS_1(hub, auth_delete_user, info);
+}

src/core/plugininvoke.h

@@ -0,0 +1,66 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2011, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_PLUGIN_INVOKE_H
+#define HAVE_UHUB_PLUGIN_INVOKE_H
+
+#include "uhub.h"
+#include "plugin_api/handle.h"
+
+struct hub_info;
+struct ip_addr_encap;
+
+/* All log related functions */
+void plugin_log_connection_accepted(struct hub_info* hub, struct ip_addr_encap* addr);
+void plugin_log_connection_denied(struct hub_info* hub, struct ip_addr_encap* addr);
+void plugin_log_user_login_success(struct hub_info* hub, struct hub_user* user);
+void plugin_log_user_login_error(struct hub_info* hub, struct hub_user* user, const char* reason);
+void plugin_log_user_logout(struct hub_info* hub, struct hub_user* user, const char* reason);
+void plugin_log_user_nick_change(struct hub_info* hub, struct hub_user* user, const char* new_nick);
+void plugin_log_user_update_error(struct hub_info* hub, struct hub_user* user, const char* reason);
+void plugin_log_chat_message(struct hub_info* hub, struct hub_user* from, const char* message, int flags);
+
+/* IP ban related */
+plugin_st plugin_check_ip_early(struct hub_info* hub, struct ip_addr_encap* addr);
+plugin_st plugin_check_ip_late(struct hub_info* hub, struct hub_user* user, struct ip_addr_encap* addr);
+
+/* Nickname allow/deny handling */
+plugin_st plugin_check_nickname_valid(struct hub_info* hub, const char* nick);
+plugin_st plugin_check_nickname_reserved(struct hub_info* hub, const char* nick);
+
+/* Handle chat messages */
+plugin_st plugin_handle_chat_message(struct hub_info* hub, struct hub_user* from, const char* message, int flags);
+plugin_st plugin_handle_private_message(struct hub_info* hub, struct hub_user* from, struct hub_user* to, const char* message, int flags);
+
+/* Handle searches */
+plugin_st plugin_handle_search(struct hub_info* hub, struct hub_user* user, const char* data);
+plugin_st plugin_handle_search_result(struct hub_info* hub, struct hub_user* from, struct hub_user* to, const char* data);
+
+/* Handle p2p connections */
+plugin_st plugin_handle_connect(struct hub_info* hub, struct hub_user* from, struct hub_user* to);
+plugin_st plugin_handle_revconnect(struct hub_info* hub, struct hub_user* from, struct hub_user* to);
+
+/* Authentication related */
+plugin_st plugin_auth_get_user(struct hub_info* hub, const char* nickname, struct auth_info* info);
+plugin_st plugin_auth_register_user(struct hub_info* hub, struct auth_info* user);
+plugin_st plugin_auth_update_user(struct hub_info* hub, struct auth_info* user);
+plugin_st plugin_auth_delete_user(struct hub_info* hub, struct auth_info* user);
+
+#endif // HAVE_UHUB_PLUGIN_INVOKE_H
+

src/core/pluginloader.c

@@ -0,0 +1,251 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2011, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+
+#include "plugin_api/handle.h"
+
+struct plugin_callback_data;
+
+struct plugin_hub_internals* get_internals(struct plugin_handle* handle)
+{
+	struct plugin_hub_internals* internals;
+	uhub_assert(handle && handle->handle && handle->handle->internals);
+	internals = (struct plugin_hub_internals*) handle->handle->internals;
+	return internals;
+}
+
+struct uhub_plugin* plugin_open(const char* filename)
+{
+	struct uhub_plugin* plugin;
+	LOG_PLUGIN("plugin_open: \"%s\"", filename);
+
+	plugin = (struct uhub_plugin*) hub_malloc_zero(sizeof(struct uhub_plugin));
+	if (!plugin)
+	{
+		return 0;
+	}
+
+#ifdef HAVE_DLOPEN
+	plugin->handle = dlopen(filename, RTLD_LAZY);
+#else
+	plugin->handle = LoadLibraryExA(filename, NULL, 0);
+#endif
+
+	if (!plugin->handle)
+	{
+#ifdef HAVE_DLOPEN
+		LOG_ERROR("Unable to open plugin %s: %s", filename, dlerror());
+#else
+		LOG_ERROR("Unable to open plugin %s: %d", filename, GetLastError());
+#endif
+		hub_free(plugin);
+		return 0;
+	}
+
+	plugin->filename = strdup(filename);
+	plugin->internals = hub_malloc_zero(sizeof(struct plugin_hub_internals));
+	return plugin;
+}
+
+void plugin_close(struct uhub_plugin* plugin)
+{
+	struct plugin_hub_internals* internals = (struct plugin_hub_internals*) plugin->internals;
+
+	LOG_PLUGIN("plugin_close: \"%s\"", plugin->filename);
+	plugin_callback_data_destroy(plugin->handle, internals->callback_data);
+	hub_free(internals);
+	plugin->internals = NULL;
+
+#ifdef HAVE_DLOPEN
+	dlclose(plugin->handle);
+#else
+	FreeLibrary((HMODULE) plugin->handle);
+#endif
+	hub_free(plugin->filename);
+	hub_free(plugin);
+}
+
+void* plugin_lookup_symbol(struct uhub_plugin* plugin, const char* symbol)
+{
+#ifdef HAVE_DLOPEN
+	void* addr = dlsym(plugin->handle, symbol);
+	return addr;
+#else
+	FARPROC addr = GetProcAddress((HMODULE) plugin->handle, symbol);
+	return (void*) addr;
+#endif
+}
+
+
+
+struct plugin_handle* plugin_load(const char* filename, const char* config, struct hub_info* hub)
+{
+	plugin_register_f register_f;
+	plugin_unregister_f unregister_f;
+	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;
+
+	if (!handle)
+	{
+		plugin_close(plugin);
+		return NULL;
+	}
+
+	handle->handle = plugin;
+	register_f = plugin_lookup_symbol(plugin, "plugin_register");
+	unregister_f = plugin_lookup_symbol(plugin, "plugin_unregister");
+
+	// register hub internals
+	internals->unregister = unregister_f;
+	internals->hub = hub;
+	internals->callback_data = plugin_callback_data_create();
+
+	// setup callback functions, where the plugin can contact the hub.
+	plugin_register_callback_functions(handle);
+
+	if (register_f && unregister_f)
+	{
+		ret = register_f(handle, config);
+		if (ret == 0)
+		{
+			if (handle->plugin_api_version == PLUGIN_API_VERSION && handle->plugin_funcs_size == sizeof(struct plugin_funcs))
+			{
+				LOG_INFO("Loaded plugin: %s: %s, version %s.", filename, handle->name, handle->version);
+				LOG_PLUGIN("Plugin API version: %d (func table size: " PRINTF_SIZE_T ")", handle->plugin_api_version, handle->plugin_funcs_size);
+				return handle;
+			}
+			else
+			{
+				LOG_ERROR("Unable to load plugin: %s - API version mistmatch", filename);
+			}
+		}
+		else
+		{
+			LOG_ERROR("Unable to load plugin: %s - Failed to initialize: %s", filename, handle->error_msg);
+		}
+	}
+
+	plugin_close(plugin);
+	hub_free(handle);
+	return NULL;
+}
+
+void plugin_unload(struct plugin_handle* plugin)
+{
+	struct plugin_hub_internals* internals = get_internals(plugin);
+	internals->unregister(plugin);
+	plugin_unregister_callback_functions(plugin);
+	plugin_close(plugin->handle);
+	hub_free(plugin);
+}
+
+static int plugin_parse_line(char* line, int line_count, void* ptr_data)
+{
+	struct hub_info* hub = (struct hub_info*) ptr_data;
+	struct uhub_plugins* handle = hub->plugins;
+	struct cfg_tokens* tokens = cfg_tokenize(line);
+	struct plugin_handle* plugin;
+	char *directive, *soname, *params;
+
+	if (cfg_token_count(tokens) == 0)
+	{
+		cfg_tokens_free(tokens);
+		return 0;
+	}
+
+	if (cfg_token_count(tokens) < 2)
+	{
+		cfg_tokens_free(tokens);
+		return -1;
+	}
+
+	directive = cfg_token_get_first(tokens);
+	soname    = cfg_token_get_next(tokens);
+	params    = cfg_token_get_next(tokens);
+
+	if (strcmp(directive, "plugin") == 0 && soname && *soname)
+	{
+		if (!params)
+			params = "";
+
+		LOG_PLUGIN("Load plugin: \"%s\", params=\"%s\"", soname, params);
+		plugin = plugin_load(soname, params, hub);
+		if (plugin)
+		{
+			list_append(handle->loaded, plugin);
+			cfg_tokens_free(tokens);
+			return 0;
+		}
+	}
+
+	cfg_tokens_free(tokens);
+	return -1;
+}
+
+int plugin_initialize(struct hub_config* config, struct hub_info* hub)
+{
+	int ret;
+
+	hub->plugins->loaded = list_create();
+	if (!hub->plugins->loaded)
+		return -1;
+
+	if (config)
+	{
+		if (!*config->file_plugins)
+			return 0;
+
+		ret = file_read_lines(config->file_plugins, hub, &plugin_parse_line);
+		if (ret == -1)
+		{
+			list_clear(hub->plugins->loaded, hub_free);
+			list_destroy(hub->plugins->loaded);
+			hub->plugins->loaded = 0;
+			return -1;
+		}
+	}
+	return 0;
+}
+
+void plugin_shutdown(struct uhub_plugins* handle)
+{
+	struct plugin_handle* plugin = (struct plugin_handle*) list_get_first(handle->loaded);
+	while (plugin)
+	{
+		list_remove(handle->loaded, plugin);
+		plugin_unload(plugin);
+		plugin = (struct plugin_handle*) list_get_first(handle->loaded);
+	}
+
+	list_destroy(handle->loaded);
+}
+
+// Used internally only
+struct hub_info* plugin_get_hub(struct plugin_handle* plugin)
+{
+	struct plugin_hub_internals* data = get_internals(plugin);
+	return data->hub;
+}
+

src/core/pluginloader.h

@@ -0,0 +1,67 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2011, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_PLUGIN_LOADER_H
+#define HAVE_UHUB_PLUGIN_LOADER_H
+
+#include "plugin_api/handle.h"
+
+struct hub_config;
+struct hub_info;
+struct linked_list;
+struct plugin_handle;
+
+struct uhub_plugin
+{
+	void* handle;
+	plugin_unregister_f unregister;
+	char* filename;
+	void* internals;      // Hub-internal stuff (struct plugin_hub_internals)
+};
+
+struct uhub_plugins
+{
+	struct linked_list* loaded;
+};
+
+// High level plugin loader code
+extern struct plugin_handle* plugin_load(const char* filename, const char* config, struct hub_info* hub);
+extern void plugin_unload(struct plugin_handle* plugin);
+
+// extern void plugin_unload(struct plugin_handle*);
+extern int plugin_initialize(struct hub_config* config, struct hub_info* hub);
+extern void plugin_shutdown(struct uhub_plugins* handle);
+
+// Low level plugin loader code (used internally)
+extern struct uhub_plugin* plugin_open(const char* filename);
+extern void plugin_close(struct uhub_plugin*);
+extern void* plugin_lookup_symbol(struct uhub_plugin*, const char* symbol);
+
+// Used internally only
+struct plugin_hub_internals
+{
+	struct hub_info* hub;
+	plugin_unregister_f unregister;             /* The unregister function. */
+	struct plugin_callback_data* callback_data; /* callback data that is unique for the plugin */
+};
+
+extern struct plugin_hub_internals* get_internals(struct plugin_handle*);
+extern struct hub_info* plugin_get_hub(struct plugin_handle*);
+
+#endif /* HAVE_UHUB_PLUGIN_LOADER_H */

src/core/probe.c

@@ -50,6 +50,17 @@ static void probe_net_event(struct net_connection* con, int events, void *arg)
 				if (probe->hub->config->tls_enable && probe->hub->config->tls_require)
 				{
 					LOG_TRACE("Not TLS connection - closing connection.");
+					if (*probe->hub->config->tls_require_redirect_addr)
+					{
+						char buf[512];
+						ssize_t len = snprintf(buf, sizeof(buf), "ISUP " ADC_PROTO_SUPPORT "\nISID AAAB\nIINF NIRedirecting...\nIQUI AAAB RD%s\n", probe->hub->config->tls_require_redirect_addr);
+						net_con_send(con, buf, (size_t) len);
+						LOG_TRACE("Not TLS connection - Redirecting to %s.", probe->hub->config->tls_require_redirect_addr);
+					}
+					else
+					{
+						LOG_TRACE("Not TLS connection - closing connection.");
+					}
 				}
 				else
 #endif
@@ -60,42 +71,34 @@ static void probe_net_event(struct net_connection* con, int events, void *arg)
 				probe_destroy(probe);
 				return;
 			}
-
 #ifdef SSL_SUPPORT
-			if (bytes >= 11 &&
+			else if (bytes >= 11 &&
 				probe_recvbuf[0] == 22 && 
 				probe_recvbuf[1] == 3 && /* protocol major version */
 				probe_recvbuf[5] == 1 && /* message type */
-				probe_recvbuf[9] == probe_recvbuf[1] &&
-				probe_recvbuf[10] == probe_recvbuf[2])
+				probe_recvbuf[9] == probe_recvbuf[1])
 			{
 				if (probe->hub->config->tls_enable)
 				{
-					LOG_TRACE("Probed TLS %d.%d connection", (int) probe_recvbuf[1], (int) probe_recvbuf[2]);
+					LOG_TRACE("Probed TLS %d.%d connection", (int) probe_recvbuf[9], (int) probe_recvbuf[10]);
 					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);
+					net_con_ssl_handshake(con, net_con_ssl_mode_server, probe->hub->ctx);
 				}
 				else
 				{
-					LOG_TRACE("Probed TLS %d.%d connection. TLS disabled in hub.", (int) probe_recvbuf[1], (int) probe_recvbuf[2]);
+					LOG_TRACE("Probed TLS %d.%d connection. TLS disabled in hub.", (int) probe_recvbuf[9], (int) probe_recvbuf[10]);
 				}
-				probe_destroy(probe);
-				return;
 			}
 			else
 			{
-				LOG_TRACE("Probed TLS %d.%d connection", (int) probe_recvbuf[1], (int) probe_recvbuf[2]);
-
-				net_con_ssl_handshake(con, net_con_ssl_mode_server, probe->hub->ssl_ctx);
-				return;
+				LOG_TRACE("Probed unsupported protocol: %x%x%x%x.", (int) probe_recvbuf[0], (int) probe_recvbuf[1], (int) probe_recvbuf[2], (int) probe_recvbuf[3]);
 			}
-#else
+#endif
 			probe_destroy(probe);
 			return;
-#endif
 		}
 	}
 }
@@ -107,6 +110,8 @@ struct hub_probe* probe_create(struct hub_info* hub, int sd, struct ip_addr_enca
 	if (probe == NULL)
 		return NULL; /* OOM */
 
+	LOG_TRACE("probe_create(): %p", probe);
+
 	probe->hub = hub;
 	probe->connection = net_con_create();
 	net_con_initialize(probe->connection, sd, probe_net_event, probe, NET_EVENT_READ);
@@ -118,6 +123,7 @@ struct hub_probe* probe_create(struct hub_info* hub, int sd, struct ip_addr_enca
 
 void probe_destroy(struct hub_probe* probe)
 {
+	LOG_TRACE("probe_destroy(): %p (connection=%p)", probe, probe->connection);
 	if (probe->connection)
 	{
 		net_con_close(probe->connection);

src/core/route.c

@@ -30,7 +30,7 @@ int route_message(struct hub_info* hub, struct hub_user* u, struct adc_message*
 			break;
 			
 		case 'D':
-			target = uman_get_user_by_sid(hub, msg->target);
+			target = uman_get_user_by_sid(hub->users, msg->target);
 			if (target)
 			{
 				route_to_user(hub, target, msg);
@@ -38,7 +38,7 @@ int route_message(struct hub_info* hub, struct hub_user* u, struct adc_message*
 			break;
 			
 		case 'E':
-			target = uman_get_user_by_sid(hub, msg->target);
+			target = uman_get_user_by_sid(hub->users, msg->target);
 			if (target)
 			{
 				route_to_user(hub, target, msg);
@@ -57,7 +57,7 @@ int route_message(struct hub_info* hub, struct hub_user* u, struct adc_message*
 	return 0;
 }
 
-static inline size_t get_max_send_queue(struct hub_info* hub)
+static size_t get_max_send_queue(struct hub_info* hub)
 {
 	/* TODO: More dynamic send queue limit, for instance:
 	 * return MAX(hub->config->max_send_buffer, (hub->config->max_recv_buffer * hub_get_user_count(hub)));
@@ -65,7 +65,7 @@ static inline size_t get_max_send_queue(struct hub_info* hub)
 	return hub->config->max_send_buffer;
 }
 
-static inline size_t get_max_send_queue_soft(struct hub_info* hub)
+static size_t get_max_send_queue_soft(struct hub_info* hub)
 {
 	return hub->config->max_send_buffer_soft;
 }
@@ -75,7 +75,7 @@ static inline size_t get_max_send_queue_soft(struct hub_info* hub)
  *         -1 if send queue is overflowed
  *         0 if soft send queue is overflowed (not implemented at the moment)
  */
-static inline int check_send_queue(struct hub_info* hub, struct hub_user* user, struct adc_message* msg)
+static int check_send_queue(struct hub_info* hub, struct hub_user* user, struct adc_message* msg)
 {
 	if (user_flag_get(user, flag_user_list))
 		return 1;
@@ -106,19 +106,19 @@ int route_to_user(struct hub_info* hub, struct hub_user* user, struct adc_messag
 	if (!user->connection)
 		return 0;
 
-	assert(msg->cache && *msg->cache);
+	uhub_assert(msg->cache && *msg->cache);
 
-	if (hub_sendq_is_empty(user->send_queue) && !user_flag_get(user, flag_pipeline))
+	if (ioq_send_is_empty(user->send_queue) && !user_flag_get(user, flag_pipeline))
 	{
 		/* Perform oportunistic write */
-		hub_sendq_add(user->send_queue, msg);
+		ioq_send_add(user->send_queue, msg);
 		handle_net_write(user);
 	}
 	else
 	{
 		if (check_send_queue(hub, user, msg) >= 0)
 		{
-			hub_sendq_add(user->send_queue, msg);
+			ioq_send_add(user->send_queue, msg);
 			if (!user_flag_get(user, flag_pipeline))
 				user_net_io_want_write(user);
 		}
@@ -128,7 +128,7 @@ int route_to_user(struct hub_info* hub, struct hub_user* user, struct adc_messag
 
 int route_flush_pipeline(struct hub_info* hub, struct hub_user* u)
 {
-	if (hub_sendq_is_empty(u->send_queue))
+	if (ioq_send_is_empty(u->send_queue))
 		return 0;
 
 	handle_net_write(u);

src/core/user.c

@@ -46,8 +46,8 @@ struct hub_user* user_create(struct hub_info* hub, struct net_connection* con, s
 	if (user == NULL)
 		return NULL; /* OOM */
 
-	user->send_queue = hub_sendq_create();
-	user->recv_queue = hub_recvq_create();
+	user->send_queue = ioq_send_create();
+	user->recv_queue = ioq_recv_create();
 
 	user->connection = con;
 	net_con_reinitialize(user->connection, net_event, user, NET_EVENT_READ);
@@ -60,6 +60,8 @@ struct hub_user* user_create(struct hub_info* hub, struct net_connection* con, s
 	flood_control_reset(&user->flood_search);
 	flood_control_reset(&user->flood_update);
 	flood_control_reset(&user->flood_extras);
+
+	user->hub = hub;
 	return user;
 }
 
@@ -68,8 +70,14 @@ void user_destroy(struct hub_user* user)
 {
 	LOG_TRACE("user_destroy(), user=%p", user);
 
-	hub_recvq_destroy(user->recv_queue);
-	hub_sendq_destroy(user->send_queue);
+	ioq_recv_destroy(user->recv_queue);
+	ioq_send_destroy(user->send_queue);
+
+	if (user->connection)
+	{
+		LOG_TRACE("user_destory() -> net_con_close(%p)", user->connection);
+		net_con_close(user->connection);
+	}
 
 	adc_msg_free(user->info);
 	user_clear_feature_cast_support(user);
@@ -175,6 +183,10 @@ static int convert_support_fourcc(int fourcc)
 		case FOURCC('A','D','C','S'):
 			return feature_adcs;
 
+		// ignore these extensions, they are not useful for the hub.
+		case FOURCC('D','H','T','0'):
+			return 0;
+
 		default:
 			LOG_DEBUG("Unknown extension: %x", fourcc);
 			return 0;
@@ -288,18 +300,7 @@ int user_is_disconnecting(struct hub_user* user)
 
 int user_is_protected(struct hub_user* user)
 {
-	switch (user->credentials)
-	{
-		case cred_bot:
-		case cred_operator:
-		case cred_super:
-		case cred_admin:
-		case cred_link:
-			return 1;
-		default:
-			break;
-	}
-	return 0;
+	return auth_cred_is_protected(user->credentials);
 }
 
 /**
@@ -309,19 +310,7 @@ int user_is_protected(struct hub_user* user)
  */
 int user_is_registered(struct hub_user* user)
 {
-	switch (user->credentials)
-	{
-		case cred_bot:
-		case cred_user:
-		case cred_operator:
-		case cred_super:
-		case cred_admin:
-		case cred_link:
-			return 1;
-		default:
-			break;
-	}
-	return 0;
+	return auth_cred_is_registered(user->credentials);
 }
 
 void user_net_io_want_write(struct hub_user* user)

src/core/user.h

@@ -82,8 +82,9 @@ extern const char* user_get_quit_reason_string(enum user_quit_reason);
 struct hub_user_info
 {
 	sid_t sid;                    /** session ID */
-	char cid[MAX_CID_LEN+1];      /** global client ID */
 	char nick[MAX_NICK_LEN+1];    /** User's nick name */
+	char cid[MAX_CID_LEN+1];      /** global client ID */
+	char user_agent[MAX_UA_LEN+1];/** User agent string */
 	struct ip_addr_encap addr;    /** User's IP address */
 };
 
@@ -105,16 +106,15 @@ struct hub_user_limits
 
 struct hub_user
 {
-	enum user_state         state;              /** see enum user_state */
-	enum user_credentials   credentials;        /** see enum user_credentials */
 	struct hub_user_info    id;                 /** Contains nick name and CID */
-	uint32_t                flags;              /** see enum user_features */
-	char                    user_agent[MAX_UA_LEN+1];/** User agent string */
+	enum auth_credentials   credentials;        /** see enum user_credentials */
+	enum user_state         state;              /** see enum user_state */
+	uint32_t                flags;              /** see enum user_flags */
 	struct linked_list*     feature_cast;       /** Features supported by feature cast */
 	struct adc_message*     info;               /** ADC 'INF' message (broadcasted to everyone joining the hub) */
 	struct hub_info*        hub;                /** The hub instance this user belong to */
-	struct hub_recvq*       recv_queue;
-	struct hub_sendq*       send_queue;
+	struct ioq_recv*        recv_queue;
+	struct ioq_send*        send_queue;
 	struct net_connection*  connection;         /** Connection data */
 	struct hub_user_limits  limits;             /** Data used for limitation */
 	enum user_quit_reason   quit_reason;        /** Quit reason (see user_quit_reason) */

src/core/usermanager.c

@@ -33,55 +33,17 @@ static void clear_user_list_callback(void* ptr)
 		 * This prevents the hub from trying to send
 		 * quit messages to other users.
 		 */
-		u->credentials = cred_none;
+		u->credentials = auth_cred_none;
 		user_destroy(u);
 	}
 }
 
-void uman_update_stats(struct hub_info* hub)
+
+struct hub_user_manager* uman_init()
 {
-	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();
-}
-
-void uman_print_stats(struct hub_info* hub)
-{
-	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)",
-		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);
-}
-
-static void timer_statistics(struct timeout_evt* t)
-{
-	struct hub_info* hub = (struct hub_info*) t->ptr;
-	uman_update_stats(hub);
-	timeout_queue_reschedule(net_backend_get_timeout_queue(), hub->users->timeout, TIMEOUT_STATS);
-}
-
-int uman_init(struct hub_info* hub)
-{
-	struct hub_user_manager* users = NULL;
-	if (!hub)
-		return -1;
-
-	users = (struct hub_user_manager*) hub_malloc_zero(sizeof(struct hub_user_manager));
+	struct hub_user_manager* users = (struct hub_user_manager*) hub_malloc_zero(sizeof(struct hub_user_manager));
 	if (!users)
-		return -1;
+		return NULL;
 
 	users->list = list_create();
 	users->sids = sid_pool_create(net_get_max_sockets());
@@ -90,143 +52,119 @@ int uman_init(struct hub_info* hub)
 	{
 		list_destroy(users->list);
 		hub_free(users);
+		return NULL;
+	}
+
+	return users;
+}
+
+
+int uman_shutdown(struct hub_user_manager* users)
+{
+	if (!users)
 		return -1;
-	}
 
-	if (net_backend_get_timeout_queue())
+	if (users->list)
 	{
-		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);
+		list_clear(users->list, &clear_user_list_callback);
+		list_destroy(users->list);
 	}
+	sid_pool_destroy(users->sids);
 
-	hub->users = users;
+	hub_free(users);
 	return 0;
 }
 
 
-int uman_shutdown(struct hub_info* hub)
+int uman_add(struct hub_user_manager* users, struct hub_user* user)
 {
-	if (!hub || !hub->users)
+	if (!users || !user)
 		return -1;
 
-	if (net_backend_get_timeout_queue())
-	{
-		timeout_queue_remove(net_backend_get_timeout_queue(), hub->users->timeout);
-		hub_free(hub->users->timeout);
-	}
-
-	if (hub->users->list)
-	{
-		list_clear(hub->users->list, &clear_user_list_callback);
-		list_destroy(hub->users->list);
-	}
-	sid_pool_destroy(hub->users->sids);
-	hub_free(hub->users);
-	hub->users = 0;
-
+	list_append(users->list, user);
+	users->count++;
+	users->count_peak = MAX(users->count, users->count_peak);
 
+	users->shared_size  += user->limits.shared_size;
+	users->shared_files += user->limits.shared_files;
 	return 0;
 }
 
-
-int uman_add(struct hub_info* hub, struct hub_user* user)
+int uman_remove(struct hub_user_manager* users, struct hub_user* user)
 {
-	if (!hub || !user)
+	if (!users || !user)
 		return -1;
 
-	if (user->hub)
-		return -1;
+	list_remove(users->list, user);
 
-	list_append(hub->users->list, user);
-	hub->users->count++;
-	hub->users->count_peak = MAX(hub->users->count, hub->users->count_peak);
-
-	hub->users->shared_size  += user->limits.shared_size;
-	hub->users->shared_files += user->limits.shared_files;
-
-	user->hub = hub;
-	return 0;
-}
-
-int uman_remove(struct hub_info* hub, struct hub_user* user)
-{
-	if (!hub || !user)
-		return -1;
-
-	list_remove(hub->users->list, user);
-
-	if (hub->users->count > 0)
+	if (users->count > 0)
 	{
-		hub->users->count--;
+		users->count--;
 	}
 	else
 	{
-		assert(!"negative count!");
+		uhub_assert(!"negative count!");
 	}
 
-	hub->users->shared_size  -= user->limits.shared_size;
-	hub->users->shared_files -= user->limits.shared_files;
-
-	user->hub = 0;
-
+	users->shared_size  -= user->limits.shared_size;
+	users->shared_files -= user->limits.shared_files;
 	return 0;
 }
 
 
-struct hub_user* uman_get_user_by_sid(struct hub_info* hub, sid_t sid)
+struct hub_user* uman_get_user_by_sid(struct hub_user_manager* users, sid_t sid)
 {
-	return sid_lookup(hub->users->sids, sid);
+	return sid_lookup(users->sids, sid);
 }
 
 
-struct hub_user* uman_get_user_by_cid(struct hub_info* hub, const char* cid)
+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(hub->users->list); /* iterate users - only on incoming INF msg */
+	struct hub_user* user = (struct hub_user*) list_get_first(users->list); /* iterate users - only on incoming INF msg */
 	while (user)
 	{
 		if (strcmp(user->id.cid, cid) == 0)
 			return user;
-		user = (struct hub_user*) list_get_next(hub->users->list);
+		user = (struct hub_user*) list_get_next(users->list);
 	}
 	return NULL;
 }
 
 
-struct hub_user* uman_get_user_by_nick(struct hub_info* hub, const char* nick)
+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(hub->users->list); /* iterate users - only on incoming INF msg */
+	struct hub_user* user = (struct hub_user*) list_get_first(users->list); /* iterate users - only on incoming INF msg */
 	while (user)
 	{
 		if (strcmp(user->id.nick, nick) == 0)
 			return user;
-		user = (struct hub_user*) list_get_next(hub->users->list);
+		user = (struct hub_user*) list_get_next(users->list);
 	}
 	return NULL;
 }
 
-size_t uman_get_user_by_addr(struct hub_info* hub, struct linked_list* users, struct ip_range* range)
+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(hub->users->list); /* iterate users - only on incoming INF msg */
+	struct hub_user* user = (struct hub_user*) list_get_first(users->list); /* iterate users - only on incoming INF msg */
 	while (user)
 	{
 		if (ip_in_range(&user->id.addr, range))
 		{
-			list_append(users, user);
+			list_append(target, user);
 			num++;
 		}
-		user = (struct hub_user*) list_get_next(hub->users->list);
+		user = (struct hub_user*) list_get_next(users->list);
 	}
 	return num;
 }
 
-int uman_send_user_list(struct hub_info* hub, struct hub_user* target)
+int uman_send_user_list(struct hub_info* hub, struct hub_user_manager* users, struct hub_user* target)
 {
 	int ret = 1;
 	struct hub_user* user;
 	user_flag_set(target, flag_user_list);
-	user = (struct hub_user*) list_get_first(hub->users->list); /* iterate users - only on INF or PAS msg */
+	user = (struct hub_user*) list_get_first(users->list); /* iterate users - only on INF or PAS msg */
 	while (user)
 	{
 		if (user_is_logged_in(user))
@@ -235,7 +173,7 @@ int uman_send_user_list(struct hub_info* hub, struct hub_user* target)
 			if (!ret)
 				break;
 		}
-		user = (struct hub_user*) list_get_next(hub->users->list);
+		user = (struct hub_user*) list_get_next(users->list);
 	}
 
 #if 0
@@ -248,7 +186,7 @@ int uman_send_user_list(struct hub_info* hub, struct hub_user* target)
 	return ret;
 }
 
-void uman_send_quit_message(struct hub_info* hub, struct hub_user* leaving)
+void uman_send_quit_message(struct hub_info* hub, struct hub_user_manager* users, struct hub_user* leaving)
 {
 	struct adc_message* command = adc_msg_construct(ADC_CMD_IQUI, 6);
 	adc_msg_add_argument(command, (const char*) sid_to_string(leaving->id.sid));
@@ -261,9 +199,9 @@ void uman_send_quit_message(struct hub_info* hub, struct hub_user* leaving)
 	adc_msg_free(command);
 }
 
-sid_t uman_get_free_sid(struct hub_info* hub, struct hub_user* user)
+sid_t uman_get_free_sid(struct hub_user_manager* users, struct hub_user* user)
 {
-	sid_t sid = sid_alloc(hub->users->sids, user);
+	sid_t sid = sid_alloc(users->sids, user);
 	user->id.sid = sid;
 	return sid;
 }

src/core/usermanager.h

@@ -28,36 +28,35 @@ struct hub_user_manager
 	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 linked_list* list;       /**<< "Contains all logged in users" */
-	struct timeout_evt* timeout;    /**<< "Timeout handler for statistics" */
 };
 
 /**
  * Initializes the user manager.
  * @return 0 on success, or -1 if error (out of memory).
  */
-extern int uman_init(struct hub_info* hub);
+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 (hub is invalid).
+ * @return 0 on success, or -1 in an error occured (invalid pointer).
  */
-extern int uman_shutdown(struct hub_info* hub);
+extern int uman_shutdown(struct hub_user_manager* users);
 
 /**
  * Generate statistics for logfiles.
  */
-extern void uman_update_stats(struct hub_info* hub);
-extern void uman_print_stats(struct hub_info* hub);
+extern void uman_update_stats(struct hub_user_manager* users);
+extern void uman_print_stats(struct hub_user_manager* users);
 
 /**
  * Add a user to the user manager.
  *
- * @param hub The hub to add the user to
+ * @param users The usermanager to add the user to
  * @param user The user to be added to the hub.
  */
-extern int uman_add(struct hub_info* hub, struct hub_user* user);
+extern int uman_add(struct hub_user_manager* users, struct hub_user* user);
 
 /**
  * Remove a user from the user manager.
@@ -66,12 +65,12 @@ extern int uman_add(struct hub_info* hub, struct hub_user* user);
  *
  * @return 0 if successfully removed, -1 if error.
  */
-extern int uman_remove(struct hub_info* hub, struct hub_user* user);
+extern int uman_remove(struct hub_user_manager* users, struct hub_user* user);
 
 /**
  * Returns and allocates an unused session ID (SID).
  */
-extern sid_t uman_get_free_sid(struct hub_info* hub, struct hub_user* user);
+extern sid_t uman_get_free_sid(struct hub_user_manager* users, struct hub_user* user);
 
 /**
  * Lookup a user based on the session ID (SID).
@@ -86,26 +85,28 @@ extern sid_t uman_get_free_sid(struct hub_info* hub, struct hub_user* user);
  *
  * @return a user if found, or NULL if not found
  */
-extern struct hub_user* uman_get_user_by_sid(struct hub_info* hub, sid_t sid);
+extern struct hub_user* uman_get_user_by_sid(struct hub_user_manager* users, sid_t sid);
 
 /**
  * Lookup a user based on the client ID (CID).
  * @return a user if found, or NULL if not found
  */
-extern struct hub_user* uman_get_user_by_cid(struct hub_info* hub, const char* cid);
+extern struct hub_user* uman_get_user_by_cid(struct hub_user_manager* users, const char* cid);
 
 /**
  * Lookup a user based on the nick name.
  * @return a user if found, or NULL if not found
  */
-extern struct hub_user* uman_get_user_by_nick(struct hub_info* hub, const char* nick);
+extern struct hub_user* uman_get_user_by_nick(struct hub_user_manager* users, const char* nick);
 
 /**
  * Lookup users based on an ip address range.
  *
+ * @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).
  */
-extern size_t uman_get_user_by_addr(struct hub_info* hub, struct linked_list* users, struct ip_range* range);
+extern size_t uman_get_user_by_addr(struct hub_user_manager* users, struct linked_list* target, struct ip_range* range);
 
 /**
  * Send the user list of connected clients to 'user'.
@@ -113,13 +114,13 @@ extern size_t uman_get_user_by_addr(struct hub_info* hub, struct linked_list* us
  *
  * @return 1 if sending the user list succeeded, 0 otherwise.
  */
-extern int uman_send_user_list(struct hub_info* hub, struct hub_user* user);
+extern int uman_send_user_list(struct hub_info* hub, struct hub_user_manager* users, struct hub_user* user);
 
 /**
  * Send a quit message to all connected users when 'user' is
  * leaving the hub (for whatever reason).
  */
-extern void uman_send_quit_message(struct hub_info* hub, struct hub_user* user);
+extern void uman_send_quit_message(struct hub_info* hub, struct hub_user_manager* users, struct hub_user* user);
 
 
 #endif /* HAVE_UHUB_USER_MANAGER_H */

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-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -72,7 +72,7 @@ static net_backend_init_t net_backend_init_funcs[] = {
 int net_backend_init()
 {
 	size_t n;
-	g_backend = hub_malloc_zero(sizeof(struct net_backend));
+	g_backend = (struct net_backend*) hub_malloc_zero(sizeof(struct net_backend));
 	g_backend->common.num = 0;
 	g_backend->common.max = net_get_max_sockets();
 	g_backend->now = time(0);
@@ -146,6 +146,9 @@ int net_backend_process()
 		return 0;
 	}
 
+	// Process pending DNS results
+	net_dns_process();
+
 	g_backend->handler.backend_process(g_backend->data, res);
 
 	net_cleanup_process(g_backend->cleaner);
@@ -179,6 +182,11 @@ void net_con_close(struct net_connection* con)
 
 	g_backend->handler.con_del(g_backend->data, con);
 
+#ifdef SSL_SUPPORT
+	if (con->ssl)
+		net_ssl_shutdown(con);
+#endif /* SSL_SUPPORT */
+
 	net_close(con->sd);
 	con->sd = -1;
 
@@ -196,6 +204,7 @@ struct net_cleanup_handler* net_cleanup_initialize(size_t max)
 
 void net_cleanup_shutdown(struct net_cleanup_handler* handler)
 {
+	net_cleanup_process(handler);
 	hub_free(handler->queue);
 	hub_free(handler);
 }
@@ -213,7 +222,7 @@ void net_cleanup_process(struct net_cleanup_handler* handler)
 	{
 		struct net_connection* con = handler->queue[n];
 		LOG_TRACE("net_cleanup_process: free: %p", con);
-		hub_free(con);
+		net_con_destroy(con);
 	}
 	handler->num = 0;
 }

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-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -38,7 +38,7 @@ typedef void (*net_con_backend_init)(struct net_backend*, struct net_connection*
 typedef void (*net_con_backend_add)(struct net_backend*, struct net_connection*, int mask);
 typedef void (*net_con_backend_mod)(struct net_backend*, struct net_connection*, int mask);
 typedef void (*net_con_backend_del)(struct net_backend*,struct net_connection*);
-typedef const char* (*net_con_backend_name)(void);
+typedef const char* (*net_con_backend_name)();
 
 struct net_backend_handler
 {

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-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,11 +20,10 @@
 #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_WANT_SSL_ACCEPT       0x0040
-#define NET_WANT_SSL_CONNECT      0x0080
-#define NET_WANT_SSL_X509_LOOKUP  0x0100
+
+#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
+
+struct ssl_handle; /* abstract type */
 
 #define NET_CLEANUP               0x8000
 
@@ -36,9 +35,7 @@
 	struct timeout_evt*  timeout;   /** timeout event handler */
 
 #define NET_CON_STRUCT_SSL \
-	SSL*                 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. */ \
+	struct ssl_handle* ssl;         /** SSL handle */
 
 #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-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,124 +20,18 @@
 #include "uhub.h"
 #include "network/common.h"
 
-#ifdef SSL_SUPPORT
-
-enum uhub_tls_state
+static int is_blocked_or_interrupted()
 {
-	tls_st_none,
-	tls_st_error,
-	tls_st_accepting,
-	tls_st_connecting,
-	tls_st_connected,
-	tls_st_disconnecting,
-};
-
-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);
+	int err = net_error();
+	return
+#ifdef WINSOCK
+				err == WSAEWOULDBLOCK
+#else
+				err == EWOULDBLOCK
 #endif
-	if (ret > 0)
-	{
-		net_con_update(con, NET_EVENT_READ);
-		con->ssl_state = tls_st_connected;
-	}
-	else
-	{
-		return handle_openssl_error(con, ret);
-	}
-	return ret;
+				|| err == EINTR;
 }
 
-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);
-		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 */
-
-
 ssize_t net_con_send(struct net_connection* con, const void* buf, size_t len)
 {
 	int ret;
@@ -148,7 +42,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 (net_error() == EWOULDBLOCK || net_error() == EINTR)
+			if (is_blocked_or_interrupted())
 				return 0;
 			return -1;
 		}
@@ -156,15 +50,9 @@ ssize_t net_con_send(struct net_connection* con, const void* buf, size_t len)
 	}
 	else
 	{
-		con->write_len = 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);
-		}
+		ret = net_ssl_send(con, buf, len);
 	}
-#endif
+#endif /* SSL_SUPPORT */
 	return ret;
 }
 
@@ -172,13 +60,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 (net_error() == EWOULDBLOCK || net_error() == EINTR)
+			if (is_blocked_or_interrupted())
 				return 0;
 			return -net_error();
 		}
@@ -190,21 +78,9 @@ ssize_t net_con_recv(struct net_connection* con, void* buf, size_t len)
 	}
 	else
 	{
-		if (con->ssl_state == tls_st_error)
-			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);
-		}
-		else
-		{
-			return -handle_openssl_error(con, ret);
-		}
+		ret = net_ssl_recv(con, buf, len);
 	}
-#endif
+#endif /* SSL_SUPPORT */
 	return ret;
 }
 
@@ -213,7 +89,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 (net_error() == EWOULDBLOCK || net_error() == EINTR)
+		if (is_blocked_or_interrupted())
 			return 0;
 		return -net_error();
 	}
@@ -223,19 +99,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;
-}
-
-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;
+	return !!con->ssl;
 }
 #endif /* SSL_SUPPORT */
 
@@ -251,6 +118,10 @@ void* net_con_get_ptr(struct net_connection* con)
 
 void net_con_destroy(struct net_connection* con)
 {
+#ifdef SSL_SUPPORT
+	if (con->ssl)
+		net_ssl_destroy(con);
+#endif
 	hub_free(con);
 }
 
@@ -261,68 +132,16 @@ void net_con_callback(struct net_connection* con, int events)
 
 	if (events == NET_EVENT_TIMEOUT)
 	{
-		LOG_TRACE("net_con_callback(%p, TIMEOUT", con);
+		LOG_TRACE("net_con_callback(%p, TIMEOUT)", con);
 		con->callback(con, events, con->ptr);
 		return;
 	}
 
 #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
-	}
-	else
-	{
-#ifdef NETWORK_DUMP_DEBUG
-		LOG_PROTO("net_con_event: events=%d, con=%p, state=%d", events, con, con->ssl_state);
-#endif
-		switch (con->ssl_state)
-		{
-			case tls_st_none:
-				con->callback(con, events, con->ptr);
-				break;
-
-			case tls_st_error:
-				con->callback(con, NET_EVENT_READ, con->ptr);
-				break;
-
-			case tls_st_accepting:
-				if (net_con_ssl_accept(con) < 0)
-				{
-					con->callback(con, NET_EVENT_READ, con->ptr);
-				}
-				break;
-
-			case tls_st_connecting:
-				if (net_con_ssl_connect(con) < 0)
-				{
-					con->callback(con, NET_EVENT_READ, con->ptr);
-				}
-				break;
-
-			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)
-				{
-					con->callback(con, events & NET_EVENT_READ, con->ptr);
-					return;
-				}
-
-				if (events & NET_EVENT_READ && con->flags & NET_WANT_SSL_WRITE)
-				{
-					con->callback(con, events & NET_EVENT_READ, con->ptr);
-					return;
-				}
-
-				con->callback(con, events, con->ptr);
-				break;
-
-			case tls_st_disconnecting:
-				return;
-		}
-	}
-#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-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,6 +23,7 @@
 #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
@@ -83,29 +84,5 @@ extern ssize_t net_con_peek(struct net_connection* con, void* buf, size_t len);
 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,386 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+
+static struct net_dns_job* find_and_remove_job(struct net_dns_job* job);
+static struct net_dns_result* find_and_remove_result(struct net_dns_job* job);
+
+struct net_dns_job
+{
+	net_dns_job_cb callback;
+	void* ptr;
+
+	char* host;
+	int af;
+
+#ifdef DEBUG_LOOKUP_TIME
+	struct timeval time_start;
+	struct timeval time_finish;
+#endif
+
+	uhub_thread_t* thread_handle;
+};
+
+struct net_dns_result
+{
+	struct linked_list* addr_list;
+	struct net_dns_job* job;
+};
+
+static void free_job(struct net_dns_job* job)
+{
+	if (job)
+	{
+		hub_free(job->host);
+		hub_free(job);
+	}
+}
+
+static void shutdown_free_jobs(void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) ptr;
+	uhub_thread_cancel(job->thread_handle);
+	uhub_thread_join(job->thread_handle);
+	free_job(job);
+}
+
+static void shutdown_free_results(void* ptr)
+{
+	struct net_dns_result* result = (struct net_dns_result*) ptr;
+	uhub_thread_join(result->job->thread_handle);
+	net_dns_result_free(result);
+}
+
+
+// NOTE: Any job manipulating the members of this
+// struct must lock the mutex!
+struct net_dns_subsystem
+{
+	struct linked_list* jobs;    // currently running jobs
+	struct linked_list* results; // queue of results that are awaiting being delivered to callback.
+	uhub_mutex_t mutex;
+};
+
+static struct net_dns_subsystem* g_dns = NULL;
+
+void net_dns_initialize()
+{
+	LOG_TRACE("net_dns_initialize()");
+	g_dns = (struct net_dns_subsystem*) hub_malloc_zero(sizeof(struct net_dns_subsystem));
+	g_dns->jobs = list_create();
+	g_dns->results = list_create();
+	uhub_mutex_init(&g_dns->mutex);
+}
+
+void net_dns_destroy()
+{
+	struct net_dns_job* job;
+	struct net_dns_result* result;
+
+	uhub_mutex_lock(&g_dns->mutex);
+	LOG_TRACE("net_dns_destroy(): jobs=%d", (int) list_size(g_dns->jobs));
+	list_clear(g_dns->jobs, &shutdown_free_jobs);
+
+	LOG_TRACE("net_dns_destroy(): results=%d", (int) list_size(g_dns->results));
+	list_clear(g_dns->results, &shutdown_free_results);
+	uhub_mutex_unlock(&g_dns->mutex);
+
+	list_destroy(g_dns->jobs);
+	list_destroy(g_dns->results);
+	uhub_mutex_destroy(&g_dns->mutex);
+	hub_free(g_dns);
+	g_dns = NULL;
+}
+
+static void dummy_free(void* ptr)
+{
+}
+
+
+void net_dns_process()
+{
+	struct net_dns_result* result;
+	uhub_mutex_lock(&g_dns->mutex);
+	LOG_DUMP("net_dns_process(): jobs=%d, results=%d", (int) list_size(g_dns->jobs), (int) list_size(g_dns->results));
+
+	for (result = (struct net_dns_result*) list_get_first(g_dns->results); result; result = (struct net_dns_result*) list_get_next(g_dns->results))
+	{
+		struct net_dns_job* job = result->job;
+#ifdef DEBUG_LOOKUP_TIME
+		struct timeval time_result;
+		timersub(&result->job->time_finish, &result->job->time_start, &time_result);
+		LOG_TRACE("DNS lookup took %d ms", (time_result.tv_sec * 1000) + (time_result.tv_usec / 1000));
+#endif
+
+		// wait for the work thread to finish
+		uhub_thread_join(job->thread_handle);
+
+		// callback - should we delete the data immediately?
+		if (job->callback(job, result))
+		{
+			net_dns_result_free(result);
+		}
+		else
+		{
+			/* Caller wants to keep the result data, and
+			 * thus needs to call net_dns_result_free() to release it later.
+			 * We only clean up the job data here and keep the results intact.
+			 */
+			result->job = NULL;
+			free_job(job);
+		}
+	}
+
+	list_clear(g_dns->results, &dummy_free);
+	uhub_mutex_unlock(&g_dns->mutex);
+}
+
+static void* job_thread_resolve_name(void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) ptr;
+	struct addrinfo hints, *result, *it;
+	struct net_dns_result* dns_results;
+	int ret;
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = job->af;
+	hints.ai_protocol = IPPROTO_TCP;
+
+	ret = getaddrinfo(job->host, NULL, &hints, &result);
+	if (ret != 0 && ret != EAI_NONAME)
+	{
+		LOG_TRACE("getaddrinfo() failed: %s", gai_strerror(ret));
+		return NULL;
+	}
+
+	dns_results = (struct net_dns_result*) hub_malloc(sizeof(struct net_dns_result));
+	dns_results->addr_list = list_create();
+	dns_results->job = job;
+
+	if (ret != EAI_NONAME)
+	{
+		for (it = result; it; it = it->ai_next)
+		{
+			struct ip_addr_encap* ipaddr = hub_malloc_zero(sizeof(struct ip_addr_encap));
+			ipaddr->af = it->ai_family;
+
+			if (it->ai_family == AF_INET)
+			{
+				struct sockaddr_in* addr4 = (struct sockaddr_in*) it->ai_addr;
+				memcpy(&ipaddr->internal_ip_data.in, &addr4->sin_addr, sizeof(struct in_addr));
+			}
+			else if (it->ai_family == AF_INET6)
+			{
+				struct sockaddr_in6* addr6 = (struct sockaddr_in6*) it->ai_addr;
+				memcpy(&ipaddr->internal_ip_data.in6, &addr6->sin6_addr, sizeof(struct in6_addr));
+			}
+			else
+			{
+				LOG_TRACE("getaddrinfo() returned result with unknown address family: %d", it->ai_family);
+				hub_free(ipaddr);
+				continue;
+			}
+
+			LOG_DUMP("getaddrinfo() - Address (%d) %s for \"%s\"", ret++, ip_convert_to_string(ipaddr), job->host);
+			list_append(dns_results->addr_list, ipaddr);
+		}
+		freeaddrinfo(result);
+	}
+	else
+	{
+		/* hm */
+	}
+
+#ifdef DEBUG_LOOKUP_TIME
+	gettimeofday(&job->time_finish, NULL);
+#endif
+
+	uhub_mutex_lock(&g_dns->mutex);
+	list_remove(g_dns->jobs, job);
+	list_append(g_dns->results, dns_results);
+	uhub_mutex_unlock(&g_dns->mutex);
+
+	return dns_results;
+}
+
+
+extern struct net_dns_job* net_dns_gethostbyname(const char* host, int af, net_dns_job_cb callback, void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) hub_malloc_zero(sizeof(struct net_dns_job));
+	job->host = strdup(host);
+	job->af = af;
+	job->callback = callback;
+	job->ptr = ptr;
+
+#ifdef DEBUG_LOOKUP_TIME
+	gettimeofday(&job->time_start, NULL);
+#endif
+
+	// FIXME - scheduling - what about a max number of threads?
+	uhub_mutex_lock(&g_dns->mutex);
+	job->thread_handle = uhub_thread_create(job_thread_resolve_name, job);
+	if (!job->thread_handle)
+	{
+		LOG_WARN("Unable to create thread");
+		free_job(job);
+		job = NULL;
+	}
+	else
+	{
+		list_append(g_dns->jobs, job);
+	}
+	uhub_mutex_unlock(&g_dns->mutex);
+	return job;
+}
+
+
+
+extern struct net_dns_job* net_dns_gethostbyaddr(struct ip_addr_encap* ipaddr, net_dns_job_cb callback, void* ptr)
+{
+	struct net_dns_job* job = (struct net_dns_job*) hub_malloc_zero(sizeof(struct net_dns_job));
+// 	job->host = strdup(addr);
+	job->af = ipaddr->af;
+	job->callback = callback;
+	job->ptr = ptr;
+
+
+// 	if (pthread_create(&job->thread_handle, NULL, start_job, job))
+// 	{
+// 		free_job(job);
+// 		return NULL;
+// 	}
+	return job;
+}
+
+// NOTE: mutex must be locked first!
+static struct net_dns_job* find_and_remove_job(struct net_dns_job* job)
+{
+	struct net_dns_job* it;
+	for (it = (struct net_dns_job*) list_get_first(g_dns->jobs); it; it = (struct net_dns_job*) list_get_next(g_dns->jobs))
+	{
+		if (it == job)
+		{
+			list_remove(g_dns->jobs, it);
+			return job;
+		}
+	}
+	return NULL;
+}
+
+// NOTE: mutex must be locked first!
+static struct net_dns_result* find_and_remove_result(struct net_dns_job* job)
+{
+	struct net_dns_result* it;
+	for (it = (struct net_dns_result*) list_get_first(g_dns->results); it; it = (struct net_dns_result*) list_get_next(g_dns->results))
+	{
+		if (it->job == job)
+		{
+			list_remove(g_dns->results, it);
+			return it;
+		}
+	}
+	return NULL;
+}
+
+
+extern int net_dns_job_cancel(struct net_dns_job* job)
+{
+	int retval = 0;
+	struct net_dns_result* res;
+
+	LOG_TRACE("net_dns_job_cancel(): job=%p, name=%s", job, job->host);
+
+	/*
+	 * This function looks up the job in the jobs queue (which contains only active jobs)
+	 * If that is found then the thread is cancelled, and the object is deleted.
+	 * If the job was not found, that is either because it was an invalid job, or because
+	 * it was already finished. At which point it was not deleted.
+	 * If the job is already finished, but the result has not been delivered, then this
+	 * deletes the result and the job.
+	 */
+	uhub_mutex_lock(&g_dns->mutex);
+	if (find_and_remove_job(job))
+	{
+		// job still active - cancel it, then close it.
+		uhub_thread_cancel(job->thread_handle);
+		uhub_thread_join(job->thread_handle);
+		free_job(job);
+		retval = 1;
+	}
+	else if ((res = find_and_remove_result(job)))
+	{
+		// job already finished - close it.
+		uhub_thread_join(job->thread_handle);
+		net_dns_result_free(res);
+	}
+	uhub_mutex_unlock(&g_dns->mutex);
+	return retval;
+}
+
+extern struct net_dns_result* net_dns_job_sync_wait(struct net_dns_job* job)
+{
+	struct net_dns_result* res = NULL;
+
+	// Wait for job to finish (if not already)
+	// This should make sure the job is removed from jobs and a result is
+	// present in results.
+	uhub_thread_join(job->thread_handle);
+
+	// Remove the result in order to prevent the callback from being called.
+	uhub_mutex_lock(&g_dns->mutex);
+	res = find_and_remove_result(job);
+	uhub_assert(res != NULL);
+	res->job = NULL;
+	free_job(job);
+	uhub_mutex_unlock(&g_dns->mutex);
+	return res;
+}
+
+void* net_dns_job_get_ptr(const struct net_dns_job* job)
+{
+	return job->ptr;
+}
+
+extern size_t net_dns_result_size(const struct net_dns_result* res)
+{
+	return list_size(res->addr_list);
+}
+
+extern struct ip_addr_encap* net_dns_result_first(const struct net_dns_result* res)
+{
+	struct ip_addr_encap* ipaddr = list_get_first(res->addr_list);
+	LOG_TRACE("net_dns_result_first() - Address: %s", ip_convert_to_string(ipaddr));
+	return ipaddr;
+}
+
+extern struct ip_addr_encap* net_dns_result_next(const struct net_dns_result* res)
+{
+	struct ip_addr_encap* ipaddr = list_get_next(res->addr_list);
+	LOG_TRACE("net_dns_result_next() - Address: %s", ip_convert_to_string(ipaddr));
+	return ipaddr;
+}
+
+extern void net_dns_result_free(struct net_dns_result* res)
+{
+	list_clear(res->addr_list, &hub_free);
+	list_destroy(res->addr_list);
+	free_job(res->job);
+	hub_free(res);
+}

src/network/dnsresolver.h

@@ -0,0 +1,119 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_NETWORK_DNS_RESOLVER_H
+#define HAVE_UHUB_NETWORK_DNS_RESOLVER_H
+
+struct net_dns_job;
+struct net_dns_result;
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+/// Initialize the DNS subsystem
+void net_dns_initialize();
+
+/// Shutdown and destroy the DNS subsystem. This will cancel any pending DNS jobs.
+void net_dns_destroy();
+
+/// Process finished DNS lookups.
+void net_dns_process();
+
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+/**
+ * Callback to be called when the DNS job has finished.
+ * If the name or address could not be resolved to an IP address (host not found, or found but has no address)
+ * then 'result' contains an empty list (@see net_dns_result_size()).
+ * If resolving caused an error then result is NULL.
+ *
+ * After this callback is called the job is considered done, and is freed.
+ *
+ * @param If 1 is returned then result is deleted immediately after the callback,
+ * otherwise the callback becomes owner of the result data which must be freed with net_dns_result_free().
+ */
+typedef int (*net_dns_job_cb)(struct net_dns_job*, const struct net_dns_result* result);
+
+/**
+ * Resolve a hostname.
+ *
+ * @param host the hostname to be resolved.
+ * @param af the indicated address family. Should be AF_INET, AF_INET6 (or AF_UNSPEC - which means both AF_INET and AF_INET6.
+ * @param callback the callback to be called when the hostname has been resolved.
+ * @param ptr A user-defined pointer value.
+ *
+ * @return A resolve job handle if the job has successfully started or NULL if unable to start resolving.
+ */
+extern struct net_dns_job* net_dns_gethostbyname(const char* host, int af, net_dns_job_cb callback, void* ptr);
+
+/**
+ * Perform a reverse DNS lookup for a given IP address.
+ *
+ * @see net_dns_gethostbyname()
+ * @return A resolve job handle if the job has successfully started or NULL if unable to start resolving.
+ */
+extern struct net_dns_job* net_dns_gethostbyaddr(struct ip_addr_encap* ipaddr, net_dns_job_cb callback, void* ptr);
+
+/**
+ * Cancel a DNS lookup job.
+ *
+ * It is only allowed to call this once after a job has been started (@see net_dns_gethostbyname(), @see net_dns_gethostbyaddr())
+ * but before it has finished and delivered a to the callback address (@see net_dns_job_cb).
+ *
+ * @returns 1 if cancelled, or 0 if not cancelled (because the job was not found!)
+ */
+extern int net_dns_job_cancel(struct net_dns_job* job);
+
+/**
+ * Wait in a synchronous manner for a running DNS job to finished and
+ * return the result here.
+ * The job must be started with net_dns_gethostbyaddr/net_dns_gethostbyname
+ * and not finished or cancelled.
+ *
+ * If this function is invoked then the callback function will not be called and
+ * can therefore be NULL.
+ *
+ * <code>
+ *    struct net_dns_job* job = net_dns_gethostbyname("www.example.com", AF_INET, NULL, NULL);
+ *    struct net_dns_result* net_dns_job_sync_wait(job);
+ * </code>
+ */
+extern struct net_dns_result* net_dns_job_sync_wait(struct net_dns_job* job);
+
+/**
+ * Returns the user specified pointer assigned to the resolving job
+*/
+extern void* net_dns_job_get_ptr(const struct net_dns_job* job);
+
+/// Returns the number of results provided. This is 0 if the host could not be found (or has no matching IP address).
+extern size_t net_dns_result_size(const struct net_dns_result*);
+
+/// Returns the first result (if net_dns_result_size > 0), or NULL if not first result exists.
+extern struct ip_addr_encap* net_dns_result_first(const struct net_dns_result*);
+
+/// Returns the next result or NULL if no next result exists.
+extern struct ip_addr_encap* net_dns_result_next(const struct net_dns_result*);
+
+/// When finished with the results
+extern void net_dns_result_free(struct net_dns_result*);
+
+#endif /* HAVE_UHUB_NETWORK_DNS_RESOLVER_H */

src/network/ipcalc.c

@@ -21,7 +21,7 @@
 
 int ip_is_valid_ipv4(const char* address)
 {
-	int i = 0; /* address index */
+	size_t i = 0; /* address index */
 	int o = 0; /* octet number */
 	int n = 0; /* numbers after each dot */
 	int d = 0; /* dots */
@@ -203,8 +203,7 @@ int ip_mask_create_left(int af, int bits, struct ip_addr_encap* result)
 		fill = (128-bits) / 8;
 		remain_bits = (128-bits) % 8;
 		mask = (0xff << (8 - remain_bits));
-		n = 0;
-		
+
 		for (n = 0; n < fill; n++)
 			((uint8_t*) &result->internal_ip_data.in6)[n] = (uint8_t) 0xff;
 		
@@ -252,7 +251,6 @@ int ip_mask_create_right(int af, int bits, struct ip_addr_encap* result)
 		fill = (128-bits) / 8;
 		remain_bits = (128-bits) % 8;
 		mask8 = (0xff >> (8 - remain_bits));
-		n = 0;
 		start = 16-fill;
 		
 		for (n = 0; n < start; n++)

src/network/network.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -34,12 +34,14 @@ static struct net_statistics stats_total;
 
 int net_initialize()
 {
+#ifdef WINSOCK
+	struct WSAData wsa;
+#endif
 	if (!net_initialized)
 	{
 		LOG_TRACE("Initializing network monitor.");
 
 #ifdef WINSOCK
-		struct WSAData wsa;
 		if (WSAStartup(MAKEWORD(2, 2), &wsa) != NO_ERROR)
 		{
 			LOG_ERROR("Unable to initialize winsock.");
@@ -47,22 +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();
-		OpenSSL_add_all_algorithms();
-#endif /*  SSL_SUPPORT */
-
 		net_initialized = 1;
 		return 0;
 	}
@@ -81,8 +82,7 @@ size_t net_get_max_sockets()
 	return 1024;
 #else
 #ifdef WIN32
-	LOG_WARN("Windows system, limited to 4096 connections.");
-	return 4096;
+	return FD_SETSIZE;
 #else
 	LOG_WARN("System does not have getrlimit(): constrained to 1024 sockets");
 	return 1024;
@@ -97,11 +97,13 @@ int net_destroy()
 	{
 		LOG_TRACE("Shutting down network monitor");
 
+		net_dns_destroy();
+
 		net_backend_shutdown();
-		
+
 #ifdef SSL_SUPPORT
-		/* FIXME: Shutdown OpenSSL here. */
-#endif
+		net_ssl_library_shutdown();
+#endif /* SSL_SUPPORT */
 
 #ifdef WINSOCK
 		WSACleanup();
@@ -112,13 +114,6 @@ int net_destroy()
 	return -1;
 }
 
-#ifdef USE_LIBEVENT
-struct event_base* net_get_evbase()
-{
-	return net_evbase;
-}
-#endif
-
 static void net_error_out(int fd, const char* func)
 {
 	int err = net_error();
@@ -370,8 +365,13 @@ int net_accept(int fd, struct ip_addr_encap* ipaddr)
 			case EOPNOTSUPP:
 				errno = EWOULDBLOCK;
 #endif
+#ifdef WINSOCK
+			case WSAEWOULDBLOCK:
+				break;
+#else
 			case EWOULDBLOCK:
 				break;
+#endif
 			default:
 				net_error_out(fd, "net_accept");
 				net_stats_add_error();
@@ -417,7 +417,11 @@ int net_connect(int fd, const struct sockaddr *serv_addr, socklen_t addrlen)
 	int ret = connect(fd, serv_addr, addrlen);
 	if (ret == -1)
 	{
+#ifdef WINSOCK
+		if (net_error() != WSAEINPROGRESS)
+#else
 		if (net_error() != EINPROGRESS)
+#endif
 		{
 			net_error_out(fd, "net_connect");
 			net_stats_add_error();
@@ -491,7 +495,6 @@ int net_socket_create(int af, int type, int protocol)
 		}
 	}
 #endif
-
 	return sd;
 }
 
@@ -520,6 +523,7 @@ const char* net_address_to_string(int af, const void* src, char* dst, socklen_t
 			sin6.sin6_family = AF_INET6;
 			sin6.sin6_port   = 0;
 			sin6.sin6_addr   = *addr6;
+			sin6.sin6_scope_id = 0;
 			size             = sizeof(sin6);
 			addr             = (LPSOCKADDR) &sin6;
 			break;
@@ -528,7 +532,7 @@ const char* net_address_to_string(int af, const void* src, char* dst, socklen_t
 			return NULL;
 	}
 	
-	if (WSAAddressToString(addr, size, NULL, dst, &len) == 0)
+	if (WSAAddressToStringA(addr, size, NULL, dst, &len) == 0)
 	{
 		return dst;
 	}
@@ -648,12 +652,16 @@ const char* net_get_local_address(int fd)
 
 	if (getsockname(fd, (struct sockaddr*) name, &namelen) != -1)
 	{
+#ifndef WINSOCK
 		int af = storage.ss_family;
 		if (af == AF_INET6)
 		{
 			net_address_to_string(af, (void*) &name6->sin6_addr, address, INET6_ADDRSTRLEN);
 		}
 		else
+#else
+		int af = AF_INET;
+#endif
 		{
 			net_address_to_string(af, (void*) &name4->sin_addr, address, INET6_ADDRSTRLEN);
 		}
@@ -679,7 +687,11 @@ ssize_t net_recv(int fd, void* buf, size_t len, int flags)
 	}
 	else
 	{
+#ifdef WINSOCK
+		if (net_error() != WSAEWOULDBLOCK)
+#else
 		if (net_error() != EWOULDBLOCK)
+#endif
 		{
 			/* net_error_out(fd, "net_recv"); */
 			net_stats_add_error();
@@ -698,7 +710,11 @@ ssize_t net_send(int fd, const void* buf, size_t len, int flags)
 	}
 	else
 	{
+#ifdef WINSOCK
+		if (net_error() != WSAEWOULDBLOCK)
+#else
 		if (net_error() != EWOULDBLOCK)
+#endif
 		{
 			/* net_error_out(fd, "net_send"); */
 			net_stats_add_error();

src/network/network.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2012, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -31,6 +31,7 @@ struct net_statistics
 };
 
 struct net_socket_t;
+struct ip_addr_encap;
 
 /**
  * Initialize the socket monitor subsystem.
@@ -51,8 +52,6 @@ extern int net_initialize();
  */
 extern int net_destroy();
 
-extern struct event_base* net_get_evbase();
-
 /**
  * @return the number of sockets currrently being monitored.
  */
@@ -254,46 +253,4 @@ extern void net_stats_add_close();
 extern int net_stats_timeout();
 extern void net_stats_get(struct net_statistics** intermediate, struct net_statistics** total);
 
-
-#if defined(WINSOCK) && !defined(__CYGWIN__)
-
-#define EWOULDBLOCK     WSAEWOULDBLOCK
-#define EINPROGRESS     WSAEINPROGRESS
-#define EALREADY        WSAEALREADY
-#define ENOTSOCK        WSAENOTSOCK
-#define EDESTADDRREQ    WSAEDESTADDRREQ
-#define EMSGSIZE        WSAEMSGSIZE
-#define EPROTOTYPE      WSAEPROTOTYPE
-#define ENOPROTOOPT     WSAENOPROTOOPT
-#define EPROTONOSUPPORT WSAEPROTONOSUPPORT
-#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT
-#define EOPNOTSUPP      WSAEOPNOTSUPP
-#define EPFNOSUPPORT    WSAEPFNOSUPPORT
-#define EAFNOSUPPORT    WSAEAFNOSUPPORT
-#define EADDRINUSE      WSAEADDRINUSE
-#define EADDRNOTAVAIL   WSAEADDRNOTAVAIL
-#define ENETDOWN        WSAENETDOWN
-#define ENETUNREACH     WSAENETUNREACH
-#define ENETRESET       WSAENETRESET
-#define ECONNABORTED    WSAECONNABORTED
-#define ECONNRESET      WSAECONNRESET
-#define ENOBUFS         WSAENOBUFS
-#define EISCONN         WSAEISCONN
-#define ENOTCONN        WSAENOTCONN
-#define ESHUTDOWN       WSAESHUTDOWN
-#define ETOOMANYREFS    WSAETOOMANYREFS
-#define ETIMEDOUT       WSAETIMEDOUT
-#define ECONNREFUSED    WSAECONNREFUSED
-#define ELOOP           WSAELOOP
-#define EHOSTDOWN       WSAEHOSTDOWN
-#define EHOSTUNREACH    WSAEHOSTUNREACH
-#define EPROCLIM        WSAEPROCLIM
-#define EUSERS          WSAEUSERS
-#define EDQUOT          WSAEDQUOT
-#define ESTALE          WSAESTALE
-#define EREMOTE         WSAEREMOTE
-
-#endif /* WINSOCK && !__CYGWIN__ */
-
-
 #endif /* HAVE_UHUB_NETWORK_H */

src/network/openssl.c

@@ -0,0 +1,351 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+#include "network/common.h"
+#include "network/tls.h"
+
+#ifdef SSL_SUPPORT
+#ifdef SSL_USE_OPENSSL
+
+void net_stats_add_tx(size_t bytes);
+void net_stats_add_rx(size_t bytes);
+
+struct net_ssl_openssl
+{
+	SSL* ssl;
+	BIO* bio;
+	enum ssl_state state;
+	uint32_t flags;
+	size_t bytes_rx;
+	size_t bytes_tx;
+};
+
+struct net_context_openssl
+{
+	SSL_METHOD* ssl_method;
+	SSL_CTX* ssl_ctx;
+};
+
+static struct net_ssl_openssl* get_handle(struct net_connection* con)
+{
+	uhub_assert(con);
+	return (struct net_ssl_openssl*) con->ssl;
+}
+
+const char* net_ssl_get_provider()
+{
+	return OPENSSL_VERSION_TEXT;
+}
+
+int net_ssl_library_init()
+{
+	LOG_TRACE("Initializing OpenSSL...");
+	SSL_library_init();
+	SSL_load_error_strings();
+	return 1;
+}
+
+int net_ssl_library_shutdown()
+{
+	ERR_clear_error();
+	ERR_remove_state(0);
+
+	ENGINE_cleanup();
+	CONF_modules_unload(1);
+
+        ERR_free_strings();
+	EVP_cleanup();
+        CRYPTO_cleanup_all_ex_data();
+	
+	// sk_SSL_COMP_free(SSL_COMP_get_compression_methods());
+	return 1;
+}
+
+static void add_io_stats(struct net_ssl_openssl* handle)
+{
+	if (handle->bio->num_read > handle->bytes_rx)
+	{
+		net_stats_add_rx(handle->bio->num_read - handle->bytes_rx);
+		handle->bytes_rx = handle->bio->num_read;
+	}
+
+	if (handle->bio->num_write > handle->bytes_tx)
+	{
+		net_stats_add_tx(handle->bio->num_write - handle->bytes_tx);
+		handle->bytes_tx = handle->bio->num_write;
+	}
+}
+
+/**
+ * Create a new SSL context.
+ */
+struct ssl_context_handle* net_ssl_context_create()
+{
+
+	struct net_context_openssl* ctx = (struct net_context_openssl*) hub_malloc_zero(sizeof(struct net_context_openssl));
+	ctx->ssl_method = (SSL_METHOD*) SSLv23_method(); /* TLSv1_method() */
+	ctx->ssl_ctx = SSL_CTX_new(ctx->ssl_method);
+
+	/* Disable SSLv2 */
+	SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_SSLv2);
+
+#ifdef SSL_OP_NO_COMPRESSION
+	/* Disable compression? */
+	LOG_TRACE("Disabling SSL compression."); /* "CRIME" attack */
+	SSL_CTX_set_options(ctx->ssl_ctx, SSL_OP_NO_COMPRESSION);
+#endif
+
+	SSL_CTX_set_quiet_shutdown(ctx->ssl_ctx, 1);
+
+	return (struct ssl_context_handle*) ctx;
+}
+
+extern void net_ssl_context_destroy(struct ssl_context_handle* ctx_)
+{
+	struct net_context_openssl* ctx = (struct net_context_openssl*) ctx_;
+	SSL_CTX_free(ctx->ssl_ctx);
+	hub_free(ctx);
+}
+
+int ssl_load_certificate(struct ssl_context_handle* ctx_, const char* pem_file)
+{
+	struct net_context_openssl* ctx = (struct net_context_openssl*) ctx_;
+	if (SSL_CTX_use_certificate_file(ctx->ssl_ctx, pem_file, SSL_FILETYPE_PEM) < 0)
+	{
+		LOG_ERROR("SSL_CTX_use_certificate_file: %s", ERR_error_string(ERR_get_error(), NULL));
+		return 0;
+	}
+
+	return 1;
+}
+
+int ssl_load_private_key(struct ssl_context_handle* ctx_, const char* pem_file)
+{
+	struct net_context_openssl* ctx = (struct net_context_openssl*) ctx_;
+	if (SSL_CTX_use_PrivateKey_file(ctx->ssl_ctx, pem_file, SSL_FILETYPE_PEM) < 0)
+	{
+		LOG_ERROR("SSL_CTX_use_PrivateKey_file: %s", ERR_error_string(ERR_get_error(), NULL));
+		return 0;
+	}
+	return 1;
+}
+
+int ssl_check_private_key(struct ssl_context_handle* ctx_)
+{
+	struct net_context_openssl* ctx = (struct net_context_openssl*) ctx_;
+	if (SSL_CTX_check_private_key(ctx->ssl_ctx) != 1)
+	{
+		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;
+	}
+	return 1;
+}
+
+static int handle_openssl_error(struct net_connection* con, int ret, enum ssl_state forced_rwstate)
+{
+	struct net_ssl_openssl* handle = get_handle(con);
+	int err = SSL_get_error(handle->ssl, ret);
+	switch (err)
+	{
+		case SSL_ERROR_ZERO_RETURN:
+			// Not really an error, but SSL was shut down.
+			return -1;
+
+		case SSL_ERROR_WANT_READ:
+			handle->state = forced_rwstate;
+			net_con_update(con, NET_EVENT_READ);
+			return 0;
+
+		case SSL_ERROR_WANT_WRITE:
+			handle->state = forced_rwstate;
+			net_con_update(con, NET_EVENT_WRITE);
+			return 0;
+
+		case SSL_ERROR_SYSCALL:
+			handle->state = tls_st_error;
+			return -2;
+	}
+}
+
+ssize_t net_con_ssl_accept(struct net_connection* con)
+{
+	struct net_ssl_openssl* handle = get_handle(con);
+	handle->state = tls_st_accepting;
+	ssize_t ret;
+
+	ret = SSL_accept(handle->ssl);
+	LOG_PROTO("SSL_accept() ret=%d", ret);
+	if (ret > 0)
+	{
+		net_con_update(con, NET_EVENT_READ);
+		handle->state = tls_st_connected;
+		return ret;
+	}
+	return handle_openssl_error(con, ret, tls_st_accepting);
+}
+
+ssize_t net_con_ssl_connect(struct net_connection* con)
+{
+	struct net_ssl_openssl* handle = get_handle(con);
+	ssize_t ret;
+	handle->state = tls_st_connecting;
+
+	ret = SSL_connect(handle->ssl);
+	LOG_PROTO("SSL_connect() ret=%d", ret);
+
+	if (ret > 0)
+	{
+		handle->state = tls_st_connected;
+		net_con_update(con, NET_EVENT_READ);
+		return ret;
+	}
+	return handle_openssl_error(con, ret, tls_st_connecting);
+}
+
+ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode ssl_mode, struct ssl_context_handle* ssl_ctx)
+{
+	uhub_assert(con);
+
+	struct net_context_openssl* ctx = (struct net_context_openssl*) ssl_ctx;
+	struct net_ssl_openssl* handle = (struct net_ssl_openssl*) hub_malloc_zero(sizeof(struct net_ssl_openssl));
+
+	if (ssl_mode == net_con_ssl_mode_server)
+	{
+		handle->ssl = SSL_new(ctx->ssl_ctx);
+		if (!handle->ssl)
+		{
+			LOG_ERROR("Unable to create new SSL stream\n");
+			return -1;
+		}
+		SSL_set_fd(handle->ssl, con->sd);
+		handle->bio = SSL_get_rbio(handle->ssl);
+		con->ssl = (struct ssl_handle*) handle;
+		return net_con_ssl_accept(con);
+	}
+	else
+	{
+		handle->ssl = SSL_new(SSL_CTX_new(TLSv1_method()));
+		SSL_set_fd(handle->ssl, con->sd);
+		handle->bio = SSL_get_rbio(handle->ssl);
+		con->ssl = (struct ssl_handle*) handle;
+		return net_con_ssl_connect(con);
+	}
+
+}
+
+ssize_t net_ssl_send(struct net_connection* con, const void* buf, size_t len)
+{
+	struct net_ssl_openssl* handle = get_handle(con);
+
+	uhub_assert(handle->state == tls_st_connected || handle->state == tls_st_need_write);
+
+	ERR_clear_error();
+	ssize_t ret = SSL_write(handle->ssl, buf, len);
+	add_io_stats(handle);
+	LOG_PROTO("SSL_write(con=%p, buf=%p, len=" PRINTF_SIZE_T ") => %d", con, buf, len, ret);
+	if (ret > 0)
+	{
+		handle->state = tls_st_connected;
+		return ret;
+	}
+	return handle_openssl_error(con, ret, tls_st_need_write);
+}
+
+ssize_t net_ssl_recv(struct net_connection* con, void* buf, size_t len)
+{
+	struct net_ssl_openssl* handle = get_handle(con);
+	ssize_t ret;
+
+	if (handle->state == tls_st_error)
+		return -2;
+
+	uhub_assert(handle->state == tls_st_connected || handle->state == tls_st_need_read);
+
+	ERR_clear_error();
+
+	ret = SSL_read(handle->ssl, buf, len);
+	add_io_stats(handle);
+	LOG_PROTO("SSL_read(con=%p, buf=%p, len=" PRINTF_SIZE_T ") => %d", con, buf, len, ret);
+	if (ret > 0)
+	{
+		handle->state = tls_st_connected;
+		return ret;
+	}
+	return handle_openssl_error(con, ret, tls_st_need_read);
+}
+
+void net_ssl_shutdown(struct net_connection* con)
+{
+	struct net_ssl_openssl* handle = get_handle(con);
+	SSL_shutdown(handle->ssl);
+	SSL_clear(handle->ssl);
+}
+
+void net_ssl_destroy(struct net_connection* con)
+{
+	struct net_ssl_openssl* handle = get_handle(con);
+	SSL_free(handle->ssl);
+}
+
+void net_ssl_callback(struct net_connection* con, int events)
+{
+	struct net_ssl_openssl* handle = get_handle(con);
+
+	switch (handle->state)
+	{
+		case tls_st_none:
+			con->callback(con, events, con->ptr);
+			break;
+
+		case tls_st_error:
+			con->callback(con, NET_EVENT_READ, con->ptr);
+			break;
+
+		case tls_st_accepting:
+			if (net_con_ssl_accept(con) != 0)
+				con->callback(con, NET_EVENT_READ, con->ptr);
+			break;
+
+		case tls_st_connecting:
+			if (net_con_ssl_connect(con) != 0)
+				con->callback(con, NET_EVENT_READ, con->ptr);
+			break;
+
+		case tls_st_need_read:
+			con->callback(con, NET_EVENT_READ, con->ptr);
+			break;
+
+		case tls_st_need_write:
+			con->callback(con, NET_EVENT_WRITE, con->ptr);
+			break;
+
+		case tls_st_connected:
+			con->callback(con, events, con->ptr);
+			break;
+
+		case tls_st_disconnecting:
+			return;
+	}
+}
+
+
+#endif /* SSL_USE_OPENSSL */
+#endif /* SSL_SUPPORT */
+

src/network/select.c

@@ -35,6 +35,7 @@ struct net_backend_select
 	struct net_connection_select** conns;
 	fd_set rfds;
 	fd_set wfds;
+	fd_set xfds;
 	int maxfd;
 	struct net_backend_common* common;
 };
@@ -48,15 +49,17 @@ const char* net_backend_name_select()
 
 int net_backend_poll_select(struct net_backend* data, int ms)
 {
-	int found, res, n;
+	int res;
+	size_t n, found;
 	struct timeval tval;
 	struct net_backend_select* backend = (struct net_backend_select*) data;
 
 	tval.tv_sec = ms / 1000;
-	tval.tv_usec = ((ms % 1000) * 1000); // FIXME: correct?
+	tval.tv_usec = (ms % 1000) * 1000;
 
 	FD_ZERO(&backend->rfds);
 	FD_ZERO(&backend->wfds);
+	FD_ZERO(&backend->xfds);
 
 	backend->maxfd = -1;
 	for (n = 0, found = 0; found < backend->common->num && n < backend->common->max; n++)
@@ -72,10 +75,15 @@ int net_backend_poll_select(struct net_backend* data, int ms)
 	}
 	backend->maxfd++;
 
-	res = select(backend->maxfd, &backend->rfds, &backend->wfds, 0, &tval);
+	res = select(backend->maxfd, &backend->rfds, &backend->wfds, &backend->xfds, &tval);
+	if (res == -1)
+	{
+		if (net_error() == EINTR)
+			return 0;
+
+		printf("Error: %d\n", net_error());
+	}
 
-	if (res == -1 && errno == EINTR)
-		return 0;
 	return res;
 }
 
@@ -121,11 +129,13 @@ void net_con_backend_add_select(struct net_backend* data, struct net_connection*
 {
 	struct net_backend_select* backend = (struct net_backend_select*) data;
 	backend->conns[con->sd] = (struct net_connection_select*) con;
+	con->flags |= (events & (NET_EVENT_READ | NET_EVENT_WRITE));
 }
 
+
 void net_con_backend_mod_select(struct net_backend* data, struct net_connection* con, int events)
 {
-	con->flags |= (events & (NET_EVENT_READ | NET_EVENT_WRITE));;
+	con->flags |= (events & (NET_EVENT_READ | NET_EVENT_WRITE));
 }
 
 void net_con_backend_del_select(struct net_backend* data, struct net_connection* con)

src/network/timeout.c

@@ -54,7 +54,7 @@ void timeout_queue_shutdown(struct timeout_queue* t)
 
 size_t timeout_queue_process(struct timeout_queue* t, time_t now)
 {
-	size_t pos = t->last;
+	size_t pos = (size_t) t->last;
 	size_t events = 0;
 	struct timeout_evt* evt = 0;
 	t->last = now;

src/network/tls.h

@@ -0,0 +1,104 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_NETWORK_TLS_H
+#define HAVE_UHUB_NETWORK_TLS_H
+
+#include "uhub.h"
+
+#ifdef SSL_SUPPORT
+
+
+enum ssl_state
+{
+	tls_st_none,
+	tls_st_error,
+	tls_st_accepting,
+	tls_st_connecting,
+	tls_st_connected,
+	tls_st_need_read,  /* special case of connected */
+	tls_st_need_write, /* special case of connected */
+	tls_st_disconnecting,
+};
+
+enum net_con_ssl_mode
+{
+	net_con_ssl_mode_server,
+	net_con_ssl_mode_client,
+};
+
+struct ssl_context_handle;
+
+/**
+ * Returns a string describing the TLS/SSL provider information
+ */
+extern const char* net_ssl_get_provider();
+
+/**
+ * return 0 if error, 1 on success.
+ */
+extern int net_ssl_library_init();
+extern int net_ssl_library_shutdown();
+
+/**
+ * Create a new SSL context.
+ */
+extern struct ssl_context_handle* net_ssl_context_create();
+extern void net_ssl_context_destroy(struct ssl_context_handle* ctx);
+
+/**
+ * Return 0 on error, 1 otherwise.
+ */
+extern int ssl_load_certificate(struct ssl_context_handle* ctx, const char* pem_file);
+
+/**
+ * Return 0 on error, 1 otherwise.
+ */
+extern int ssl_load_private_key(struct ssl_context_handle* ctx, const char* pem_file);
+
+/**
+ * Return 0 if private key does not match certificate, 1 if everything is OK.
+ */
+extern int ssl_check_private_key(struct ssl_context_handle* ctx);
+
+/**
+ * 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*);
+
+extern ssize_t net_ssl_send(struct net_connection* con, const void* buf, size_t len);
+extern ssize_t net_ssl_recv(struct net_connection* con, void* buf, size_t len);
+
+extern void net_ssl_shutdown(struct net_connection* con);
+extern void net_ssl_destroy(struct net_connection* con);
+extern void net_ssl_callback(struct net_connection* con, int events);
+
+
+
+extern ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode, struct ssl_context_handle* ssl_ctx);
+extern int   net_con_is_ssl(struct net_connection* con);
+
+#endif /* SSL_SUPPORT */
+#endif /* HAVE_UHUB_NETWORK_TLS_H */
+

src/plugin_api/command_api.h

@@ -0,0 +1,79 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2010, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_PLUGIN_API_H
+#define HAVE_UHUB_PLUGIN_API_H
+
+/**
+ * This file describes the interface a plugin implementation may use from
+ * uhub.
+ */
+
+#include "system.h"
+#include "plugin_api/types.h"
+
+struct plugin_command
+{
+	const char* message;
+	const char* prefix;
+	struct linked_list* args;
+};
+
+struct plugin_command_arg_data
+{
+	enum plugin_command_arg_type type;
+	union {
+		int integer;
+		char* string;
+		struct plugin_user* user;
+		struct ip_addr_encap* address;
+		struct ip_range* range;
+		enum auth_credentials credentials;
+	} data;
+};
+
+typedef int (*plugin_command_handler)(struct plugin_handle*, struct plugin_user* to, struct plugin_command*);
+
+struct plugin_command_handle
+{
+	void* internal_handle;          /**<<< "Internal used by the hub only" */
+	struct plugin_handle* handle;   /**<<< "The plugin handle this is associated with" */
+	const char* prefix;             /**<<< "Command prefix, for instance 'help' would be the prefix for the !help command." */
+	size_t length;                  /**<<< "Length of the prefix" */
+	const char* args;               /**<<< "Argument codes" */
+	enum auth_credentials cred;     /**<<< "Minimum access level for the command" */
+	plugin_command_handler handler; /**<<< "Function pointer for the command" */
+	const char* description;        /**<<< "Description for the command" */
+	const char* origin;             /**<<< "Name of plugin where the command originated." */
+};
+
+#define PLUGIN_COMMAND_INITIALIZE(PTR, HANDLE, PREFIX, ARGS, CRED, CALLBACK, DESC) \
+	do { \
+		PTR->internal_handle = 0; \
+		PTR->handle = HANDLE; \
+		PTR->prefix = PREFIX; \
+		PTR->length = strlen(PREFIX); \
+		PTR->args = ARGS; \
+		PTR->cred = CRED; \
+		PTR->handler = CALLBACK; \
+		PTR->description = DESC; \
+	} while (0)
+
+
+#endif /* HAVE_UHUB_PLUGIN_API_H */

src/plugin_api/handle.h

@@ -0,0 +1,189 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2010, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_PLUGIN_HANDLE_H
+#define HAVE_UHUB_PLUGIN_HANDLE_H
+
+/**
+ * This file describes the interface a uhub uses to interact with plugins.
+ */
+
+#include "system.h"
+#include "util/credentials.h"
+#include "network/ipcalc.h"
+#include "plugin_api/types.h"
+
+typedef void (*on_connection_accepted_t)(struct plugin_handle*, struct ip_addr_encap*);
+typedef void (*on_connection_refused_t)(struct plugin_handle*, struct ip_addr_encap*);
+
+typedef void (*on_user_login_t)(struct plugin_handle*, struct plugin_user*);
+typedef void (*on_user_login_error_t)(struct plugin_handle*, struct plugin_user*, const char* reason);
+typedef void (*on_user_logout_t)(struct plugin_handle*, struct plugin_user*, const char* reason);
+typedef void (*on_user_nick_change_t)(struct plugin_handle*, struct plugin_user*, const char* new_nick);
+typedef void (*on_user_update_error_t)(struct plugin_handle*, struct plugin_user*, const char* reason);
+typedef void (*on_user_chat_msg_t)(struct plugin_handle*, struct plugin_user*, const char* message, int flags);
+
+typedef void (*on_hub_started_t)(struct plugin_handle*, struct plugin_hub_info*);
+typedef void (*on_hub_reloaded_t)(struct plugin_handle*, struct plugin_hub_info*);
+typedef void (*on_hub_shutdown_t)(struct plugin_handle*, struct plugin_hub_info*);
+typedef void (*on_hub_error_t)(struct plugin_handle*, struct plugin_hub_info*, const char* message);
+
+typedef plugin_st (*on_check_ip_early_t)(struct plugin_handle*, struct ip_addr_encap*);
+typedef plugin_st (*on_check_ip_late_t)(struct plugin_handle*, struct plugin_user*, struct ip_addr_encap*);
+typedef plugin_st (*on_validate_nick_t)(struct plugin_handle*, const char* nick);
+typedef plugin_st (*on_validate_cid_t)(struct plugin_handle*, const char* cid);
+typedef plugin_st (*on_change_nick_t)(struct plugin_handle*, struct plugin_user*, const char* new_nick);
+
+typedef plugin_st (*on_chat_msg_t)(struct plugin_handle*, struct plugin_user* from, const char* message);
+typedef plugin_st (*on_private_msg_t)(struct plugin_handle*, struct plugin_user* from, struct plugin_user* to, const char* message);
+typedef plugin_st (*on_search_t)(struct plugin_handle*, struct plugin_user* from, const char* data);
+typedef plugin_st (*on_search_result_t)(struct plugin_handle*, struct plugin_user* from, struct plugin_user* to, const char* data);
+typedef plugin_st (*on_p2p_connect_t)(struct plugin_handle*, struct plugin_user* from, struct plugin_user* to);
+typedef plugin_st (*on_p2p_revconnect_t)(struct plugin_handle*, struct plugin_user* from, struct plugin_user* to);
+
+typedef plugin_st (*auth_get_user_t)(struct plugin_handle*, const char* nickname, struct auth_info* info);
+typedef plugin_st (*auth_register_user_t)(struct plugin_handle*, struct auth_info* user);
+typedef plugin_st (*auth_update_user_t)(struct plugin_handle*, struct auth_info* user);
+typedef plugin_st (*auth_delete_user_t)(struct plugin_handle*, struct auth_info* user);
+
+/**
+ * These are callbacks used for the hub to invoke functions in plugins.
+ * The marked ones are not being called yet.
+ */
+struct plugin_funcs
+{
+	// Log events for connections
+	on_connection_accepted_t on_connection_accepted; /* Someone successfully connected to the hub */
+	on_connection_refused_t  on_connection_refused;  /* Someone was refused connection to the hub */
+
+	// Log events for users
+	on_user_login_t         on_user_login;       /* A user has successfully logged in to the hub */
+	on_user_login_error_t   on_user_login_error; /* A user has failed to log in to the hub */
+	on_user_logout_t        on_user_logout;      /* A user has logged out of the hub (was previously logged in) */
+/* ! */	on_user_nick_change_t   on_user_nick_change; /* A user has changed nickname */
+	on_user_update_error_t  on_user_update_error;/* A user has failed to update - nickname, etc. */
+	on_user_chat_msg_t      on_user_chat_message;/* A user has sent a public chat message */
+
+	// Log hub events
+/* ! */	on_hub_started_t        on_hub_started;      /* Triggered just after plugins are loaded and the hub is started. */
+/* ! */	on_hub_reloaded_t       on_hub_reloaded;     /* Triggered immediately after hub configuration is reloaded. */
+/* ! */	on_hub_shutdown_t       on_hub_shutdown;     /* Triggered just before the hub is being shut down and before plugins are unloaded. */
+/* ! */	on_hub_error_t          on_hub_error;        /* Triggered for log-worthy error messages */
+
+	// Activity events (can be intercepted and refused/accepted by a plugin)
+	on_check_ip_early_t     on_check_ip_early;   /* A user has just connected (can be intercepted) */
+/* ! */	on_check_ip_late_t      on_check_ip_late;    /* A user has logged in (can be intercepted) */
+/* ! */	on_change_nick_t        on_change_nick;      /* A user wants to change his nick (can be intercepted) */
+	on_chat_msg_t           on_chat_msg;         /* A public chat message is about to be sent (can be intercepted) */
+	on_private_msg_t        on_private_msg;      /* A public chat message is about to be sent (can be intercepted) */
+	on_search_t             on_search;           /* A search is about to be sent (can be intercepted) */
+	on_search_result_t      on_search_result;    /* A search result is about to be sent (can be intercepted) */
+	on_p2p_connect_t        on_p2p_connect;      /* A user is about to connect to another user (can be intercepted) */
+	on_p2p_revconnect_t     on_p2p_revconnect;   /* A user is about to connect to another user (can be intercepted) */
+
+	// Authentication actions.
+	auth_get_user_t         auth_get_user;       /* Get authentication info from plugin */
+	auth_register_user_t    auth_register_user;  /* Register user */
+	auth_update_user_t      auth_update_user;    /* Update a registered user */
+	auth_delete_user_t      auth_delete_user;    /* Delete a registered user */
+
+};
+
+struct plugin_command_handle;
+struct plugin_command;
+struct plugin_command_arg_data;
+
+typedef int (*hfunc_send_message)(struct plugin_handle*, struct plugin_user* user, const char* message);
+typedef int (*hfunc_send_status)(struct plugin_handle*, struct plugin_user* to, int code, const char* message);
+typedef int (*hfunc_user_disconnect)(struct plugin_handle*, struct plugin_user* user);
+typedef int (*hfunc_command_add)(struct plugin_handle*, struct plugin_command_handle*);
+typedef int (*hfunc_command_del)(struct plugin_handle*, struct plugin_command_handle*);
+
+typedef size_t (*hfunc_command_arg_reset)(struct plugin_handle*, struct plugin_command*);
+typedef struct plugin_command_arg_data* (*hfunc_command_arg_next)(struct plugin_handle*, struct plugin_command*, enum plugin_command_arg_type);
+
+typedef char* (*hfunc_get_hub_name)(struct plugin_handle*);
+typedef void  (*hfunc_set_hub_name)(struct plugin_handle*, const char*);
+typedef char* (*hfunc_get_hub_description)(struct plugin_handle*);
+typedef void  (*hfunc_set_hub_description)(struct plugin_handle*, const char*);
+
+/**
+ * These are functions created and initialized by the hub and which can be used
+ * by plugins to access functionality internal to the hub.
+ */
+struct plugin_hub_funcs
+{
+	hfunc_send_message send_message;
+	hfunc_send_status send_status_message;
+	hfunc_user_disconnect user_disconnect;
+	hfunc_command_add command_add;
+	hfunc_command_del command_del;
+	hfunc_command_arg_reset command_arg_reset;
+	hfunc_command_arg_next command_arg_next;
+	hfunc_get_hub_name get_name;
+	hfunc_set_hub_name set_name;
+	hfunc_get_hub_description get_description;
+	hfunc_set_hub_description set_description;
+};
+
+struct plugin_handle
+{
+	struct uhub_plugin* handle;     /* Must NOT be modified by the plugin */
+	const char* name;               /* plugin name */
+	const char* version;            /* plugin version */
+	const char* description;        /* plugin description */
+	void* ptr;                      /* Plugin specific data */
+	const char* error_msg;          /* Error message for registration error. */
+	size_t plugin_api_version;      /* Plugin API version */
+	size_t plugin_funcs_size;       /* Size of the plugin funcs */
+	struct plugin_funcs funcs;      /* Table of functions that can be implemented by a plugin */
+	struct plugin_hub_funcs hub;    /* Table of core hub functions that can be used by a plugin */
+};
+
+
+#define PLUGIN_INITIALIZE(PTR, NAME, VERSION, DESCRIPTION) \
+	do { \
+		PTR->name = NAME; \
+		PTR->version = VERSION; \
+		PTR->description = DESCRIPTION; \
+		PTR->ptr = NULL; \
+		PTR->error_msg = NULL; \
+		PTR->plugin_api_version = PLUGIN_API_VERSION; \
+		PTR->plugin_funcs_size = sizeof(struct plugin_funcs); \
+		memset(&PTR->funcs, 0, sizeof(struct plugin_funcs)); \
+	} while (0)
+
+/**
+ * Implemented by the plugin.
+ *
+ * @param handle[out] Sets all information by the plugin
+ * @param config A configuration string
+ * @return 0 on success, -1 on error.
+ */
+PLUGIN_API int plugin_register(struct plugin_handle* handle, const char* config);
+
+/**
+ * @return 0 on success, -1 on error.
+ */
+PLUGIN_API int plugin_unregister(struct plugin_handle*);
+
+typedef int (*plugin_register_f)(struct plugin_handle* handle, const char* config);
+typedef int (*plugin_unregister_f)(struct plugin_handle*);
+
+#endif /* HAVE_UHUB_PLUGIN_HANDLE_H */

src/plugin_api/message_api.h

@@ -0,0 +1,34 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2010, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_PLUGIN_MESSAGE_API_H
+#define HAVE_UHUB_PLUGIN_MESSAGE_API_H
+
+/**
+ * Send an informal message to a user.
+ * The user will see the message as if the hub sent it.
+ */
+extern int plugin_send_message(struct plugin_handle*, struct plugin_user* to, const char* message);
+
+/**
+ * Send a status message to a user.
+ */
+extern int plugin_send_status(struct plugin_handle* struct plugin_user* to, int code, const char* message);
+
+#endif /* HAVE_UHUB_PLUGIN_API_H */

src/plugin_api/types.h

@@ -0,0 +1,107 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2010, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef HAVE_UHUB_PLUGIN_TYPES_H
+#define HAVE_UHUB_PLUGIN_TYPES_H
+
+#define PLUGIN_API_VERSION 1
+
+#ifndef MAX_NICK_LEN
+#define MAX_NICK_LEN 64
+#endif
+
+#ifndef MAX_PASS_LEN
+#define MAX_PASS_LEN 64
+#endif
+
+#ifndef MAX_CID_LEN
+#define MAX_CID_LEN 39
+#endif
+
+#ifndef MAX_UA_LEN
+#define MAX_UA_LEN   32
+#endif
+
+#ifndef SID_T_DEFINED
+typedef uint32_t sid_t;
+#define SID_T_DEFINED
+#endif
+
+struct plugin_handle;
+
+struct plugin_user
+{
+	sid_t sid;
+	char nick[MAX_NICK_LEN+1];
+	char cid[MAX_CID_LEN+1];
+	char user_agent[MAX_UA_LEN+1];
+	struct ip_addr_encap addr;
+	enum auth_credentials credentials;
+};
+
+struct plugin_hub_info
+{
+	const char* description;
+};
+
+enum plugin_status
+{
+	st_default = 0,    /* Use default */
+	st_allow = 1,      /* Allow action */
+	st_deny = -1,      /* Deny action */
+};
+
+typedef enum plugin_status plugin_st;
+
+struct auth_info
+{
+	char nickname[MAX_NICK_LEN+1];
+	char password[MAX_PASS_LEN+1];
+	enum auth_credentials credentials;
+};
+
+enum ban_flags
+{
+	ban_nickname = 0x01, /* Nickname is banned */
+	ban_cid      = 0x02, /* CID is banned */
+	ban_ip       = 0x04, /* IP address (range) is banned */
+};
+
+struct ban_info
+{
+	unsigned int flags;                 /* See enum ban_flags. */
+	char nickname[MAX_NICK_LEN+1];      /* Nickname - only defined if (ban_nickname & flags). */
+	char cid[MAX_CID_LEN+1];            /* CID - only defined if (ban_cid & flags). */
+	struct ip_addr_encap ip_addr_lo;    /* Low IP address of an IP range */
+	struct ip_addr_encap ip_addr_hi;    /* High IP address of an IP range */
+	time_t expiry;                      /* Time when the ban record expires */
+};
+
+enum plugin_command_arg_type
+{
+	plugin_cmd_arg_type_integer,
+	plugin_cmd_arg_type_string,
+	plugin_cmd_arg_type_user,
+	plugin_cmd_arg_type_address,
+	plugin_cmd_arg_type_range,
+	plugin_cmd_arg_type_credentials,
+};
+
+
+#endif /* HAVE_UHUB_PLUGIN_TYPES_H */

src/plugins/mod_auth_simple.c

@@ -0,0 +1,241 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2011, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "plugin_api/handle.h"
+#include "util/memory.h"
+#include "util/list.h"
+#include "util/misc.h"
+#include "util/log.h"
+#include "util/config_token.h"
+
+static void set_error_message(struct plugin_handle* plugin, const char* msg)
+{
+	plugin->error_msg = msg;
+}
+
+struct acl_data
+{
+	struct linked_list* users;
+	char* file;
+	int readonly;
+	int exclusive;
+};
+
+static void insert_user(struct linked_list* users, const char* nick, const char* pass, enum auth_credentials cred)
+{
+	struct auth_info* data = (struct auth_info*) hub_malloc_zero(sizeof(struct auth_info));
+	strncpy(data->nickname, nick, MAX_NICK_LEN);
+	strncpy(data->password, pass, MAX_PASS_LEN);
+	data->credentials = cred;
+	list_append(users, data);
+}
+
+static void free_acl(struct acl_data* data)
+{
+	if (!data)
+		return;
+
+	if (data->users)
+	{
+		list_clear(data->users, hub_free);
+		list_destroy(data->users);
+	}
+	hub_free(data->file);
+	hub_free(data);
+}
+
+static struct acl_data* parse_config(const char* line)
+{
+	struct acl_data* data = (struct acl_data*) hub_malloc_zero(sizeof(struct acl_data));
+	struct cfg_tokens* tokens = cfg_tokenize(line);
+	char* token = cfg_token_get_first(tokens);
+
+	if (!data)
+		return 0;
+
+	// set defaults
+	data->readonly = 1;
+	data->exclusive = 0;
+	data->users = list_create();
+
+	while (token)
+	{
+		char* split = strchr(token, '=');
+		size_t len = strlen(token);
+		size_t key = split ? (split - token) : len;
+		if (key == 4 && strncmp(token, "file", 4) == 0)
+		{
+			if (data->file)
+				hub_free(data->file);
+			data->file = strdup(split + 1);
+		}
+		else if (key == 8 && strncmp(token, "readonly", 8) == 0)
+		{
+			if (!string_to_boolean(split + 1, &data->readonly))
+				data->readonly = 1;
+		}
+		else if (key == 9 && strncmp(token, "exclusive", 9) == 0)
+		{
+			if (!string_to_boolean(split + 1, &data->exclusive))
+				data->exclusive = 1;
+		}
+		else
+		{
+			cfg_tokens_free(tokens);
+			free_acl(data);
+			return 0;
+		}
+
+		token = cfg_token_get_next(tokens);
+	}
+
+	cfg_tokens_free(tokens);
+	return data;
+}
+
+static int parse_line(char* line, int line_count, void* ptr_data)
+{
+	struct linked_list* users = (struct linked_list*) ptr_data;
+	struct cfg_tokens* tokens = cfg_tokenize(line);
+	enum auth_credentials cred;
+	char* credential;
+	char* username;
+	char* password;
+
+	if (cfg_token_count(tokens) == 0)
+	{
+		cfg_tokens_free(tokens);
+		return 0;
+	}
+
+	if (cfg_token_count(tokens) < 2)
+	{
+		cfg_tokens_free(tokens);
+		return -1;
+	}
+
+	credential = cfg_token_get_first(tokens);
+	username   = cfg_token_get_next(tokens);
+	password   = cfg_token_get_next(tokens);
+
+	if (!auth_string_to_cred(credential, &cred))
+	{
+		cfg_tokens_free(tokens);
+		return -1;
+	}
+
+	insert_user(users, username, password, cred);
+	cfg_tokens_free(tokens);
+	return 0;
+}
+
+static struct acl_data* load_acl(const char* config, struct plugin_handle* handle)
+{
+
+	struct acl_data* data = parse_config(config);
+
+	if (!data)
+		return 0;
+
+	if (!data->file || !*data->file)
+	{
+		free_acl(data); data = 0;
+		set_error_message(handle, "No configuration file given, missing \"file=<filename>\" configuration option.");
+		return 0;
+	}
+
+	if (file_read_lines(data->file, data->users, &parse_line) == -1)
+	{
+		fprintf(stderr, "Unable to load %s\n", data->file);
+		set_error_message(handle, "Unable to load file");
+	}
+
+	return data;
+}
+
+static void unload_acl(struct acl_data* data)
+{
+	free_acl(data);
+}
+
+static plugin_st get_user(struct plugin_handle* plugin, const char* nickname, struct auth_info* data)
+{
+	struct acl_data* acl = (struct acl_data*) plugin->ptr;
+	struct auth_info* info = (struct auth_info*) list_get_first(acl->users);
+	while (info)
+	{
+		if (strcasecmp((char*)info->nickname, nickname) == 0)
+		{
+			memcpy(data, info, sizeof(struct auth_info));
+			return st_allow;
+		}
+		info = (struct auth_info*) list_get_next(acl->users);
+	}
+	if (acl->exclusive)
+		return st_deny;
+	return st_default;
+}
+
+static plugin_st register_user(struct plugin_handle* plugin, struct auth_info* user)
+{
+	struct acl_data* acl = (struct acl_data*) plugin->ptr;
+	if (acl->exclusive)
+		return st_deny;
+	return st_default;
+}
+
+static plugin_st update_user(struct plugin_handle* plugin, struct auth_info* user)
+{
+	struct acl_data* acl = (struct acl_data*) plugin->ptr;
+	if (acl->exclusive)
+		return st_deny;
+	return st_default;
+}
+
+static plugin_st delete_user(struct plugin_handle* plugin, struct auth_info* user)
+{
+	struct acl_data* acl = (struct acl_data*) plugin->ptr;
+	if (acl->exclusive)
+		return st_deny;
+	return st_default;
+}
+
+PLUGIN_API int plugin_register(struct plugin_handle* plugin, const char* config)
+{
+	PLUGIN_INITIALIZE(plugin, "File authentication plugin", "0.1", "Authenticate users based on a read-only text file.");
+
+	// Authentication actions.
+	plugin->funcs.auth_get_user = get_user;
+	plugin->funcs.auth_register_user = register_user;
+	plugin->funcs.auth_update_user = update_user;
+	plugin->funcs.auth_delete_user = delete_user;
+
+	plugin->ptr = load_acl(config, plugin);
+	if (plugin->ptr)
+		return 0;
+	return -1;
+}
+
+PLUGIN_API int plugin_unregister(struct plugin_handle* plugin)
+{
+	set_error_message(plugin, 0);
+	unload_acl(plugin->ptr);
+	return 0;
+}
+

src/plugins/mod_auth_sqlite.c

@@ -0,0 +1,282 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "plugin_api/handle.h"
+#include <sqlite3.h>
+#include "util/memory.h"
+#include "util/list.h"
+#include "util/misc.h"
+#include "util/log.h"
+#include "util/config_token.h"
+
+// #define DEBUG_SQL
+
+static void set_error_message(struct plugin_handle* plugin, const char* msg)
+{
+	plugin->error_msg = msg;
+}
+
+struct sql_data
+{
+	int exclusive;
+	sqlite3* db;
+};
+
+static int null_callback(void* ptr, int argc, char **argv, char **colName) { return 0; }
+
+static int sql_execute(struct sql_data* sql, int (*callback)(void* ptr, int argc, char **argv, char **colName), void* ptr, const char* sql_fmt, ...)
+{
+	va_list args;
+	char query[1024];
+	char* errMsg;
+	int rc;
+
+	va_start(args, sql_fmt);
+	vsnprintf(query, sizeof(query), sql_fmt, args);
+
+#ifdef DEBUG_SQL
+	printf("SQL: %s\n", query);
+#endif
+
+	rc = sqlite3_exec(sql->db, query, callback, ptr, &errMsg);
+	if (rc != SQLITE_OK)
+	{
+#ifdef DEBUG_SQL
+		fprintf(stderr, "ERROR: %s\n", errMsg);
+#endif
+		sqlite3_free(errMsg);
+		return -rc;
+	}
+
+	rc = sqlite3_changes(sql->db);
+	return rc;
+}
+
+
+static struct sql_data* parse_config(const char* line, struct plugin_handle* plugin)
+{
+	struct sql_data* data = (struct sql_data*) hub_malloc_zero(sizeof(struct sql_data));
+	struct cfg_tokens* tokens = cfg_tokenize(line);
+	char* token = cfg_token_get_first(tokens);
+
+	if (!data)
+		return 0;
+
+	while (token)
+	{
+		struct cfg_settings* setting = cfg_settings_split(token);
+
+		if (!setting)
+		{
+			set_error_message(plugin, "Unable to parse startup parameters");
+			cfg_tokens_free(tokens);
+			hub_free(data);
+			return 0;
+		}
+
+		if (strcmp(cfg_settings_get_key(setting), "file") == 0)
+		{
+			if (!data->db)
+			{
+				if (sqlite3_open(cfg_settings_get_value(setting), &data->db))
+				{
+					cfg_tokens_free(tokens);
+					cfg_settings_free(setting);
+					hub_free(data);
+					set_error_message(plugin, "Unable to open database file");
+					return 0;
+				}
+			}
+		}
+		else if (strcmp(cfg_settings_get_key(setting), "exclusive") == 0)
+		{
+			if (!string_to_boolean(cfg_settings_get_value(setting), &data->exclusive))
+				data->exclusive = 1;
+		}
+		else
+		{
+			set_error_message(plugin, "Unknown startup parameters given");
+			cfg_tokens_free(tokens);
+			cfg_settings_free(setting);
+			hub_free(data);
+			return 0;
+		}
+
+		cfg_settings_free(setting);
+		token = cfg_token_get_next(tokens);
+	}
+	cfg_tokens_free(tokens);
+
+	if (!data->db)
+	{
+	      set_error_message(plugin, "No database file is given, use file=<database>");
+	      hub_free(data);
+	      return 0;
+	}
+	return data;
+}
+
+static const char* sql_escape_string(const char* str)
+{
+	static char out[1024];
+	size_t i = 0;
+	size_t n = 0;
+	for (; n < strlen(str); n++)
+	{
+		if (str[n] == '\'')
+			out[i++] = '\'';
+		out[i++] = str[n];
+	}
+	out[i++] = '\0';
+	return out;
+}
+
+struct data_record {
+	struct auth_info* data;
+	int found;
+};
+
+static int get_user_callback(void* ptr, int argc, char **argv, char **colName){
+	struct data_record* data = (struct data_record*) ptr;
+	int i = 0;
+	for (; i < argc; i++) {
+		if (strcmp(colName[i], "nickname") == 0)
+			strncpy(data->data->nickname, argv[i], MAX_NICK_LEN);
+		else if (strcmp(colName[i], "password") == 0)
+			strncpy(data->data->password, argv[i], MAX_PASS_LEN);
+		else if (strcmp(colName[i], "credentials") == 0)
+		{
+			auth_string_to_cred(argv[i], &data->data->credentials);
+			data->found = 1;
+		}
+	}
+
+#ifdef DEBUG_SQL
+	printf("SQL: nickname=%s, password=%s, credentials=%s\n", data->data->nickname, data->data->password, auth_cred_to_string(data->data->credentials));
+#endif
+	return 0;
+}
+
+static plugin_st get_user(struct plugin_handle* plugin, const char* nickname, struct auth_info* data)
+{
+	struct sql_data* sql = (struct sql_data*) plugin->ptr;
+	struct data_record result;
+	char query[1024];
+	char* errMsg;
+	int rc;
+
+	snprintf(query, sizeof(query), "SELECT * FROM users WHERE nickname='%s';", sql_escape_string(nickname));
+	memset(data, 0, sizeof(struct auth_info));
+
+	result.data = data;
+	result.found = 0;
+
+#ifdef DEBUG_SQL
+	printf("SQL: %s\n", query);
+#endif
+
+	rc = sqlite3_exec(sql->db, query , get_user_callback, &result, &errMsg);
+	if (rc != SQLITE_OK) {
+#ifdef DEBUG_SQL
+		fprintf(stderr, "SQL: ERROR: %s\n", errMsg);
+#endif
+		sqlite3_free(errMsg);
+		return st_default;
+	}
+	
+	if (result.found)
+		return st_allow;
+	return st_default;
+}
+
+static plugin_st register_user(struct plugin_handle* plugin, struct auth_info* user)
+{
+	struct sql_data* sql = (struct sql_data*) plugin->ptr;
+	char* nick = strdup(sql_escape_string(user->nickname));
+	char* pass = strdup(sql_escape_string(user->password));
+	const char* cred = auth_cred_to_string(user->credentials);
+	int rc = sql_execute(sql, null_callback, NULL, "INSERT INTO users (nickname, password, credentials) VALUES('%s', '%s', '%s');", nick, pass, cred);
+
+	free(nick);
+	free(pass);
+
+	if (rc <= 0)
+	{
+		fprintf(stderr, "Unable to add user \"%s\"\n", user->nickname);
+		return st_deny;
+	}
+	return st_allow;
+	
+}
+
+static plugin_st update_user(struct plugin_handle* plugin, struct auth_info* user)
+{
+	struct sql_data* sql = (struct sql_data*) plugin->ptr;
+
+	char* nick = strdup(sql_escape_string(user->nickname));
+	char* pass = strdup(sql_escape_string(user->password));
+	const char* cred = auth_cred_to_string(user->credentials);
+	int rc = sql_execute(sql, null_callback, NULL, "INSERT INTO users (nickname, password, credentials) VALUES('%s', '%s', '%s');", nick, pass, cred);
+
+	free(nick);
+	free(pass);
+
+	if (rc <= 0)
+	{
+		fprintf(stderr, "Unable to add user \"%s\"\n", user->nickname);
+		return st_deny;
+	}
+	return st_allow;
+	
+}
+
+static plugin_st delete_user(struct plugin_handle* plugin, struct auth_info* user)
+{
+	struct sql_data* sql = (struct sql_data*) plugin->ptr;
+	if (sql->exclusive)
+		return st_deny;
+	return st_default;
+}
+
+int plugin_register(struct plugin_handle* plugin, const char* config)
+{
+	PLUGIN_INITIALIZE(plugin, "SQLite authentication plugin", "1.0", "Authenticate users based on a SQLite database.");
+
+	// Authentication actions.
+	plugin->funcs.auth_get_user = get_user;
+	plugin->funcs.auth_register_user = register_user;
+	plugin->funcs.auth_update_user = update_user;
+	plugin->funcs.auth_delete_user = delete_user;
+
+	plugin->ptr = parse_config(config, plugin);
+	if (plugin->ptr)
+		return 0;
+	return -1;
+}
+
+int plugin_unregister(struct plugin_handle* plugin)
+{
+	struct sql_data* sql;
+	set_error_message(plugin, 0);
+	sql = (struct sql_data*) plugin->ptr;
+	sqlite3_close(sql->db);
+	hub_free(sql);
+	return 0;
+}
+

src/plugins/mod_chat_history.c

@@ -0,0 +1,246 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "plugin_api/handle.h"
+#include "plugin_api/command_api.h"
+#include "util/config_token.h"
+#include "util/memory.h"
+#include "util/misc.h"
+#include "util/list.h"
+#include "util/cbuffer.h"
+
+#define MAX_HISTORY_SIZE 16384
+
+struct chat_history_data
+{
+	size_t history_max;      ///<<< "the maximum number of chat messages kept in history."
+	size_t history_default;  ///<<< "the default number of chat messages returned if no limit was provided"
+	size_t history_connect;  ///<<< "the number of chat messages provided when users connect to the hub."
+	struct linked_list* chat_history; ///<<< "The chat history storage."
+	struct plugin_command_handle* command_history_handle; ///<<< "A handle to the !history command."
+};
+
+/**
+ * Add a chat message to history.
+ */
+static void history_add(struct plugin_handle* plugin, struct plugin_user* from, const char* message, int flags)
+{
+	size_t loglen = strlen(message) + strlen(from->nick) + 13;
+	struct chat_history_data* data = (struct chat_history_data*) plugin->ptr;
+	char* log = hub_malloc(loglen + 1);
+
+	snprintf(log, loglen, "%s <%s> %s\n", get_timestamp(time(NULL)), from->nick, message);
+	log[loglen] = '\0';
+	list_append(data->chat_history, log);
+	while (list_size(data->chat_history) > data->history_max)
+	{
+		char* msg = list_get_first(data->chat_history);
+		list_remove(data->chat_history, msg);
+		hub_free(msg);
+	}
+}
+
+/**
+ * Obtain 'num' messages from the chat history and append them to outbuf.
+ *
+ * @return the number of messages added to the buffer.
+ */
+static size_t get_messages(struct chat_history_data* data, size_t num, struct cbuffer* outbuf)
+{
+	struct linked_list* messages = data->chat_history;
+	char* message;
+	int skiplines = 0;
+	size_t lines = 0;
+	size_t total = list_size(messages);
+
+	if (total == 0)
+		return 0;
+
+	if (num <= 0 || num > total)
+		num = total;
+
+	if (num != total)
+		skiplines = total - num;
+
+	cbuf_append(outbuf, "\n");
+	message = (char*) list_get_first(messages);
+	while (message)
+	{
+		if (--skiplines < 0)
+		{
+			cbuf_append(outbuf, message);
+			lines++;
+		}
+		message = (char*) list_get_next(messages);
+	}
+	cbuf_append(outbuf, "\n");
+	return lines;
+}
+
+void user_login(struct plugin_handle* plugin, struct plugin_user* user)
+{
+	struct chat_history_data* data = (struct chat_history_data*) plugin->ptr;
+	struct cbuffer* buf = NULL;
+	// size_t messages = 0;
+
+	if (data->history_connect > 0 && list_size(data->chat_history) > 0)
+	{
+		buf = cbuf_create(MAX_HISTORY_SIZE);
+		cbuf_append(buf, "Chat history:\n");
+		get_messages(data, data->history_connect, buf);
+		plugin->hub.send_message(plugin, user, cbuf_get(buf));
+		cbuf_destroy(buf);
+	}
+}
+
+/**
+ * Send a status message back to the user who issued the !history command.
+ */
+static int command_status(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd, struct cbuffer* buf)
+{
+	struct cbuffer* msg = cbuf_create(cbuf_size(buf) + strlen(cmd->prefix) + 8);
+	cbuf_append_format(msg, "*** %s: %s", cmd->prefix, cbuf_get(buf));
+	plugin->hub.send_message(plugin, user, cbuf_get(msg));
+	cbuf_destroy(msg);
+	cbuf_destroy(buf);
+	return 0;
+}
+
+/**
+ * The callback function for handling the !history command.
+ */
+static int command_history(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
+{
+	struct cbuffer* buf;
+	struct chat_history_data* data = (struct chat_history_data*) plugin->ptr;
+	struct plugin_command_arg_data* arg = plugin->hub.command_arg_next(plugin, cmd, plugin_cmd_arg_type_integer);
+	int maxlines;
+
+	if (!list_size(data->chat_history))
+		return command_status(plugin, user, cmd, cbuf_create_const("No messages."));
+
+	if (arg)
+		maxlines = arg->data.integer;
+	else
+		maxlines = data->history_default;
+	
+	buf = cbuf_create(MAX_HISTORY_SIZE);
+	cbuf_append_format(buf, "*** %s: Chat History:\n", cmd->prefix);
+	get_messages(data, maxlines, buf);
+
+	plugin->hub.send_message(plugin, user, cbuf_get(buf));
+	cbuf_destroy(buf);
+	return 0;
+}
+
+static void set_error_message(struct plugin_handle* plugin, const char* msg)
+{
+	plugin->error_msg = msg;
+}
+
+static struct chat_history_data* parse_config(const char* line, struct plugin_handle* plugin)
+{
+	struct chat_history_data* data = (struct chat_history_data*) hub_malloc_zero(sizeof(struct chat_history_data));
+	struct cfg_tokens* tokens = cfg_tokenize(line);
+	char* token = cfg_token_get_first(tokens);
+
+	uhub_assert(data != NULL);
+
+	data->history_max = 200;
+	data->history_default = 25;
+	data->history_connect = 5;
+	data->chat_history = list_create();
+
+	while (token)
+	{
+		struct cfg_settings* setting = cfg_settings_split(token);
+
+		if (!setting)
+		{
+			set_error_message(plugin, "Unable to parse startup parameters");
+			cfg_tokens_free(tokens);
+			hub_free(data);
+			return 0;
+		}
+
+		if (strcmp(cfg_settings_get_key(setting), "history_max") == 0)
+		{
+			data->history_max = (size_t) uhub_atoi(cfg_settings_get_value(setting));
+		}
+		else if (strcmp(cfg_settings_get_key(setting), "history_default") == 0)
+		{
+			data->history_default = (size_t) uhub_atoi(cfg_settings_get_value(setting));
+		}
+		else if (strcmp(cfg_settings_get_key(setting), "history_connect") == 0)
+		{
+			data->history_connect = (size_t) uhub_atoi(cfg_settings_get_value(setting));
+		}
+		else
+		{
+			set_error_message(plugin, "Unknown startup parameters given");
+			cfg_tokens_free(tokens);
+			cfg_settings_free(setting);
+			hub_free(data);
+			return 0;
+		}
+
+		cfg_settings_free(setting);
+		token = cfg_token_get_next(tokens);
+	}
+	cfg_tokens_free(tokens);
+	return data;
+}
+
+int plugin_register(struct plugin_handle* plugin, const char* config)
+{
+	struct chat_history_data* data;
+	PLUGIN_INITIALIZE(plugin, "Chat history plugin", "1.0", "Provide a global chat history log.");
+
+	plugin->funcs.on_user_chat_message = history_add;
+	plugin->funcs.on_user_login = user_login;
+	data = parse_config(config, plugin);
+	if (!data)
+		return -1;
+
+	plugin->ptr = data;
+
+	data->command_history_handle = (struct plugin_command_handle*) hub_malloc(sizeof(struct plugin_command_handle));
+	PLUGIN_COMMAND_INITIALIZE(data->command_history_handle, plugin, "history", "?N", auth_cred_guest, &command_history, "Show chat message history.");
+	plugin->hub.command_add(plugin, data->command_history_handle);
+
+	return 0;
+}
+
+int plugin_unregister(struct plugin_handle* plugin)
+{
+	struct chat_history_data* data = (struct chat_history_data*) plugin->ptr;
+
+	if (data)
+	{
+		list_clear(data->chat_history, &hub_free);
+		list_destroy(data->chat_history);
+
+		plugin->hub.command_del(plugin, data->command_history_handle);
+		hub_free(data->command_history_handle);
+		hub_free(data);
+	}
+
+	return 0;
+}
+

src/plugins/mod_chat_only.c

@@ -0,0 +1,163 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "plugin_api/handle.h"
+#include "util/memory.h"
+
+enum Warnings
+{
+	WARN_SEARCH         = 0x01, ///<<< "Warn about searching."
+	WARN_CONNECT        = 0x02, ///<<< "Warn about connecting to a user"
+	WARN_EXTRA          = 0x08, ///<<< "Warn about unknown protocol data."
+};
+
+struct user_info
+{
+	sid_t sid;      // The SID of the user
+	int warnings;   // The number of denies (used to track wether or not a warning should be sent). @see enum Warnings.
+};
+
+struct chat_only_data
+{
+	size_t num_users;        // number of users tracked.
+	size_t max_users;        // max users (hard limit max 1M users due to limitations in the SID (20 bits)).
+	struct user_info* users; // array of max_users
+	int operator_override;   // operators are allowed to override these limitations.
+};
+
+static struct chat_only_data* co_initialize()
+{
+	struct chat_only_data* data = (struct chat_only_data*) hub_malloc(sizeof(struct chat_only_data));
+	data->num_users = 0;
+	data->max_users = 512;
+	data->users = hub_malloc_zero(sizeof(struct user_info) * data->max_users);
+	return data;
+}
+
+static void co_shutdown(struct chat_only_data* data)
+{
+	if (data)
+	{
+		hub_free(data->users);
+		hub_free(data);
+	}
+}
+
+static struct user_info* get_user_info(struct chat_only_data* data, sid_t sid)
+{
+	struct user_info* u;
+
+	// resize buffer if needed.
+	if (sid >= data->max_users)
+	{
+		u = hub_malloc_zero(sizeof(struct user_info) * (sid + 1));
+		memcpy(u, data->users, data->max_users);
+		hub_free(data->users);
+		data->users = u;
+		data->max_users = sid + 1;
+		u = NULL;
+	}
+
+	u = &data->users[sid];
+
+	// reset counters if the user was not previously known.
+	if (!u->sid)
+	{
+		u->sid = sid;
+		u->warnings = 0;
+		data->num_users++;
+	}
+	return u;
+}
+
+static plugin_st on_search_result(struct plugin_handle* plugin, struct plugin_user* from, struct plugin_user* to, const char* search_data)
+{
+	return st_deny;
+}
+
+static plugin_st on_search(struct plugin_handle* plugin, struct plugin_user* user, const char* search_data)
+{
+	struct chat_only_data* data = (struct chat_only_data*) plugin->ptr;
+	struct user_info* info = get_user_info(data, user->sid);
+
+	if (user->credentials >= auth_cred_operator && data->operator_override)
+		return st_allow;
+
+	if (!(info->warnings & WARN_SEARCH))
+	{
+		plugin->hub.send_status_message(plugin, user, 000, "Searching is disabled. This is a chat only hub.");
+		info->warnings |= WARN_SEARCH;
+	}
+	return st_deny;
+}
+
+static plugin_st on_p2p_connect(struct plugin_handle* plugin, struct plugin_user* from, struct plugin_user* to)
+{
+	struct chat_only_data* data = (struct chat_only_data*) plugin->ptr;
+	struct user_info* info = get_user_info(data, from->sid);
+
+	if (from->credentials >= auth_cred_operator && data->operator_override)
+		return st_allow;
+
+	if (!(info->warnings & WARN_CONNECT))
+	{
+		plugin->hub.send_status_message(plugin, from, 000, "Connection setup denied. This is a chat only hub.");
+		info->warnings |= WARN_CONNECT;
+	}
+	return st_deny;
+}
+
+static void on_user_login(struct plugin_handle* plugin, struct plugin_user* user)
+{
+	struct chat_only_data* data = (struct chat_only_data*) plugin->ptr;
+	/*struct user_info* info = */
+	get_user_info(data, user->sid);
+}
+
+static void on_user_logout(struct plugin_handle* plugin, struct plugin_user* user, const char* reason)
+{
+	struct chat_only_data* data = (struct chat_only_data*) plugin->ptr;
+	struct user_info* info = get_user_info(data, user->sid);
+	if (info->sid)
+		data->num_users--;
+	info->warnings = 0;
+	info->sid = 0;
+}
+
+int plugin_register(struct plugin_handle* plugin, const char* config)
+{
+	PLUGIN_INITIALIZE(plugin, "Chat only hub", "1.0", "Disables connection setup, search and results.");
+	plugin->ptr = co_initialize();
+
+	plugin->funcs.on_search = on_search;
+	plugin->funcs.on_search_result = on_search_result;
+	plugin->funcs.on_p2p_connect = on_p2p_connect;
+	plugin->funcs.on_p2p_revconnect = on_p2p_connect;
+	plugin->funcs.on_user_login = on_user_login;
+	plugin->funcs.on_user_logout = on_user_logout;
+
+	return 0;
+}
+
+int plugin_unregister(struct plugin_handle* plugin)
+{
+	co_shutdown((struct chat_only_data*) plugin->ptr);
+	return 0;
+}
+

src/plugins/mod_example.c

@@ -0,0 +1,67 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2011, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "plugin_api/handle.h"
+#include "plugin_api/command_api.h"
+#include "util/memory.h"
+
+struct example_plugin_data
+{
+	struct plugin_command_handle* example;
+};
+
+static int example_command_handler(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
+{
+	plugin->hub.send_message(plugin, user, "Hello from mod_example.");
+	return 0;
+}
+
+static void command_register(struct plugin_handle* plugin)
+{
+	struct example_plugin_data* data = (struct example_plugin_data*) hub_malloc(sizeof(struct example_plugin_data));
+	data->example = hub_malloc_zero(sizeof(struct plugin_command_handle));
+	PLUGIN_COMMAND_INITIALIZE(data->example, (void*) data, "example", "", auth_cred_guest, example_command_handler, "This is an example command that is added dynamically by loading the mod_example plug-in.");
+	plugin->hub.command_add(plugin, data->example);
+	plugin->ptr = data;
+}
+
+static void command_unregister(struct plugin_handle* plugin)
+{
+	struct example_plugin_data* data = (struct example_plugin_data*) plugin->ptr;
+
+	plugin->hub.command_del(plugin, data->example);
+	hub_free(data->example);
+
+	hub_free(data);
+	plugin->ptr = NULL;
+}
+
+int plugin_register(struct plugin_handle* plugin, const char* config)
+{
+	PLUGIN_INITIALIZE(plugin, "Example plugin", "1.0", "A simple example plugin");
+	command_register(plugin);
+	return 0;
+}
+
+int plugin_unregister(struct plugin_handle* plugin)
+{
+	command_unregister(plugin);
+	return 0;
+}
+

src/plugins/mod_logging.c

@@ -0,0 +1,266 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "system.h"
+#include "adc/adcconst.h"
+#include "adc/sid.h"
+#include "util/memory.h"
+#include "network/ipcalc.h"
+#include "plugin_api/handle.h"
+
+#include "util/misc.h"
+#include "util/config_token.h"
+#ifndef WIN32
+#include <syslog.h>
+#endif
+
+struct ip_addr_encap;
+
+struct log_data
+{
+	enum {
+		mode_file,
+		mode_syslog
+	} logmode;
+	char* logfile;
+	int fd;
+};
+
+static void reset(struct log_data* data)
+{
+	/* set defaults */
+	data->logmode = mode_file;
+	data->logfile = NULL;
+	data->fd = -1;
+}
+
+static void set_error_message(struct plugin_handle* plugin, const char* msg)
+{
+	plugin->error_msg = msg;
+}
+
+static int log_open_file(struct plugin_handle* plugin, struct log_data* data)
+{
+	int flags = O_CREAT | O_APPEND | O_WRONLY;
+	data->fd = open(data->logfile, flags, 0664);
+	return (data->fd != -1);
+}
+
+#ifndef WIN32
+static int log_open_syslog(struct plugin_handle* plugin)
+{
+	openlog("uhub", 0, LOG_USER);
+	return 1;
+}
+#endif
+
+static struct log_data* parse_config(const char* line, struct plugin_handle* plugin)
+{
+	struct log_data* data = (struct log_data*) hub_malloc(sizeof(struct log_data));
+	struct cfg_tokens* tokens = cfg_tokenize(line);
+	char* token = cfg_token_get_first(tokens);
+
+	if (!data)
+		return 0;
+
+	reset(data);
+
+	while (token)
+	{
+		struct cfg_settings* setting = cfg_settings_split(token);
+
+		if (!setting)
+		{
+			set_error_message(plugin, "Unable to parse startup parameters");
+			cfg_tokens_free(tokens);
+			hub_free(data);
+			return 0;
+		}
+
+		if (strcmp(cfg_settings_get_key(setting), "file") == 0)
+		{
+			data->logfile = strdup(cfg_settings_get_value(setting));
+			data->logmode = mode_file;
+		}
+#ifndef WIN32
+		else if (strcmp(cfg_settings_get_key(setting), "syslog") == 0)
+		{
+			int use_syslog = 0;
+			if (!string_to_boolean(cfg_settings_get_value(setting), &use_syslog))
+			{
+				data->logmode = (use_syslog) ? mode_syslog : mode_file;
+			}
+		}
+#endif
+		else
+		{
+			set_error_message(plugin, "Unknown startup parameters given");
+			cfg_tokens_free(tokens);
+			cfg_settings_free(setting);
+			hub_free(data);
+			return 0;
+		}
+
+		cfg_settings_free(setting);
+		token = cfg_token_get_next(tokens);
+	}
+
+	cfg_tokens_free(tokens);
+
+	if (data->logmode == mode_file)
+	{
+		if ((data->logmode == mode_file && !data->logfile))
+		{
+			set_error_message(plugin, "No log file is given, use file=<path>");
+			hub_free(data);
+			return 0;
+		}
+
+		if (!log_open_file(plugin, data))
+		{
+			hub_free(data->logfile);
+			hub_free(data);
+			set_error_message(plugin, "Unable to open log file");
+			return 0;
+		}
+	}
+#ifndef WIN32
+	else
+	{
+		if (!log_open_syslog(plugin))
+		{
+			hub_free(data->logfile);
+			hub_free(data);
+			set_error_message(plugin, "Unable to open syslog");
+			return 0;
+		}
+	}
+#endif
+	return data;
+}
+
+static void log_close(struct log_data* data)
+{
+	if (data->logmode == mode_file)
+	{
+		hub_free(data->logfile);
+		close(data->fd);
+	}
+#ifndef WIN32
+	else
+	{
+		closelog();
+	}
+#endif
+	hub_free(data);
+}
+
+static void log_message(struct log_data* data, const char *format, ...)
+{
+	static char logmsg[1024];
+	struct tm *tmp;
+	time_t t;
+	va_list args;
+	ssize_t size = 0;
+
+	if (data->logmode == mode_file)
+	{
+		t = time(NULL);
+		tmp = localtime(&t);
+		strftime(logmsg, 32, "%Y-%m-%d %H:%M:%S ", tmp);
+
+		va_start(args, format);
+		size = vsnprintf(logmsg + 20, 1004, format, args);
+		va_end(args);
+
+		if (write(data->fd, logmsg, size + 20) < (size+20))
+		{
+			fprintf(stderr, "Unable to write full log. Error=%d: %s\n", errno, strerror(errno));
+		}
+		else
+		{
+#ifdef WIN32
+			_commit(data->fd);
+#else
+#if defined _POSIX_SYNCHRONIZED_IO && _POSIX_SYNCHRONIZED_IO > 0
+			fdatasync(data->fd);
+#else
+			fsync(data->fd);
+#endif
+#endif
+		}
+	}
+#ifndef WIN32
+	else
+	{
+		va_start(args, format);
+		vsyslog(LOG_INFO, format, args);
+		va_end(args);
+	}
+#endif
+}
+
+static void log_user_login(struct plugin_handle* plugin, struct plugin_user* user)
+{
+	const char* cred = auth_cred_to_string(user->credentials);
+	const char* addr = ip_convert_to_string(&user->addr);
+
+	log_message(plugin->ptr, "LoginOK     %s/%s %s \"%s\" (%s) \"%s\"\n", sid_to_string(user->sid), user->cid, addr, user->nick, cred, user->user_agent);
+}
+
+static void log_user_login_error(struct plugin_handle* plugin, struct plugin_user* user, const char* reason)
+{
+	const char* addr = ip_convert_to_string(&user->addr);
+	log_message(plugin->ptr, "LoginError  %s/%s %s \"%s\" (%s) \"%s\"\n", sid_to_string(user->sid), user->cid, addr, user->nick, reason, user->user_agent);
+}
+
+static void log_user_logout(struct plugin_handle* plugin, struct plugin_user* user, const char* reason)
+{
+	const char* addr = ip_convert_to_string(&user->addr);
+	log_message(plugin->ptr, "Logout      %s/%s %s \"%s\" (%s) \"%s\"\n", sid_to_string(user->sid), user->cid, addr, user->nick, reason, user->user_agent);
+}
+
+static void log_change_nick(struct plugin_handle* plugin, struct plugin_user* user, const char* new_nick)
+{
+	const char* addr = ip_convert_to_string(&user->addr);
+	log_message(plugin->ptr, "NickChange  %s/%s %s \"%s\" -> \"%s\"\n", sid_to_string(user->sid), user->cid, addr, user->nick, new_nick);
+}
+
+int plugin_register(struct plugin_handle* plugin, const char* config)
+{
+	PLUGIN_INITIALIZE(plugin, "Logging plugin", "1.0", "Logs users entering and leaving the hub.");
+
+	plugin->funcs.on_user_login = log_user_login;
+	plugin->funcs.on_user_login_error = log_user_login_error;
+	plugin->funcs.on_user_logout = log_user_logout;
+	plugin->funcs.on_user_nick_change = log_change_nick;
+
+	plugin->ptr = parse_config(config, plugin);
+	if (!plugin->ptr)
+		return -1;
+	return 0;
+}
+
+int plugin_unregister(struct plugin_handle* plugin)
+{
+	/* No need to do anything! */
+	log_close(plugin->ptr);
+	return 0;
+}
+

src/plugins/mod_no_guest_downloads.c

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

src/plugins/mod_topic.c

@@ -0,0 +1,102 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2012, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "plugin_api/handle.h"
+#include "plugin_api/command_api.h"
+#include "util/memory.h"
+#include "util/cbuffer.h"
+
+struct topic_plugin_data
+{
+	struct plugin_command_handle* topic;
+	struct plugin_command_handle* cleartopic;
+	struct plugin_command_handle* showtopic;
+};
+
+static int command_topic_handler(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
+{
+	struct cbuffer* buf = cbuf_create(128);
+	struct plugin_command_arg_data* arg = plugin->hub.command_arg_next(plugin, cmd, plugin_cmd_arg_type_string);
+
+	plugin->hub.set_description(plugin, arg ? arg->data.string : NULL);
+	cbuf_append_format(buf, "*** %s: Topic set to \"%s\"", cmd->prefix, arg->data.string);
+	plugin->hub.send_message(plugin, user, cbuf_get(buf));
+	cbuf_destroy(buf);
+	return 0;
+}
+
+static int command_cleartopic_handler(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
+{
+	struct cbuffer* buf = cbuf_create(128);
+	plugin->hub.set_description(plugin, NULL);
+	cbuf_append_format(buf, "*** %s: Topic cleared.", cmd->prefix);
+	plugin->hub.send_message(plugin, user, cbuf_get(buf));
+	cbuf_destroy(buf);
+	return 0;
+}
+
+static int command_showtopic_handler(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
+{
+	struct cbuffer* buf = cbuf_create(128);
+	char* topic = plugin->hub.get_description(plugin);
+	cbuf_append_format(buf, "*** %s: Current topic is: \"%s\"", cmd->prefix, topic);
+	plugin->hub.send_message(plugin, user, cbuf_get(buf));
+	cbuf_destroy(buf);
+	hub_free(topic);
+	return 0;
+}
+
+int plugin_register(struct plugin_handle* plugin, const char* config)
+{
+	struct topic_plugin_data* data = (struct topic_plugin_data*) hub_malloc(sizeof(struct topic_plugin_data));
+
+	data->topic = (struct plugin_command_handle*) hub_malloc_zero(sizeof(struct plugin_command_handle));
+	data->cleartopic = (struct plugin_command_handle*) hub_malloc_zero(sizeof(struct plugin_command_handle));
+	data->showtopic = (struct plugin_command_handle*) hub_malloc_zero(sizeof(struct plugin_command_handle));
+
+	PLUGIN_INITIALIZE(plugin, "Topic plugin", "1.0", "Add commands for changing the hub topic (description)");
+
+	PLUGIN_COMMAND_INITIALIZE(data->topic, (void*) data, "topic", "+m", auth_cred_operator, command_topic_handler, "Set new topic");
+	PLUGIN_COMMAND_INITIALIZE(data->cleartopic, (void*) data, "cleartopic", "", auth_cred_operator, command_cleartopic_handler, "Clear the current topic");
+	PLUGIN_COMMAND_INITIALIZE(data->showtopic, (void*) data, "showtopic", "", auth_cred_guest, command_showtopic_handler, "Shows the current topic");
+
+	plugin->hub.command_add(plugin, data->topic);
+	plugin->hub.command_add(plugin, data->cleartopic);
+	plugin->hub.command_add(plugin, data->showtopic);
+	plugin->ptr = data;
+
+
+	return 0;
+}
+
+int plugin_unregister(struct plugin_handle* plugin)
+{
+	struct topic_plugin_data* data = (struct topic_plugin_data*) plugin->ptr;
+
+	plugin->hub.command_del(plugin, data->topic);
+	plugin->hub.command_del(plugin, data->cleartopic);
+	plugin->hub.command_del(plugin, data->showtopic);
+	hub_free(data->topic);
+	hub_free(data->cleartopic);
+	hub_free(data->showtopic);
+	hub_free(data);
+	plugin->ptr = NULL;
+	return 0;
+}
+