Fix bug #185 - Args of !commands lost/damaged.

All string arguments were incorrectly freed after being added to the argument list for a command.
Instead this fix makes sure it is properly copied into a new string, and by doing so this requires
a new API for dealing with hub command arguments in a type safe manner, and also allows for each
argument to be cleaned up properly when the command is no longer needed.

This also fixes issues with parse errors for certain types, and optional arguments (previously it was impossible
to tell the difference for an integer with value 0 or if no integer was given).

.gitignore

@@ -2,7 +2,8 @@
 *.[oa]
 *.exe
 *.gch
+mod_*.so
 uhub-admin
 adcrush
 uhub
-
+revision.h*

.gitmodules

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

AUTHORS

@@ -1,6 +1,9 @@
-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
+MiMic, Implemented user commands
+tehnick, Debian and Ubuntu packaging.
 

ChangeLog

@@ -1,3 +1,25 @@
+0.3.2:
+- Fixed bugs in the kqueue network backend (OSX/BSD)
+- Rewrote the configuration backend code.
+- Added support for escaping characters in the configuration files.
+- Updated the !broadcast command to send private messages instead of main chat messages.
+- Adding support for redirecting clients to other hubs when they fail to log in.
+- Fix some out of memory related crashes.
+- Fixed minor memory leaks.
+
+
+0.3.1:
+- Fixed bug where !getip did not work.
+- Added flood control configuration options.
+- Added configuration options to disallow old/obsolete ADC clients.
+- Fixed crash bugs, an freezes.
+- SSL/TLS fix for tls_require configuration option.
+- Fixed disconnect messages, so that clients can interpret them.
+- Fixed bugs where share limits could be circumvented.
+- Added support for listening to multiple ports.
+- kqueue backend for Mac OS X, and BSD systems.
+
+
 0.3.0:
 - More user commands: ban, broadcast, mute, rules, history, myip, whoip, log
 - Experimental SSL support

GNUmakefile

@@ -3,17 +3,21 @@
 ## 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_SSL       ?= YES
+USE_PLUGINS   ?= YES
 USE_BIGENDIAN ?= AUTO
 BITS          ?= AUTO
 SILENT        ?= YES
 TERSE         ?= NO
 STACK_PROTECT ?= NO
+NEED_LIBDL    ?= NO
 
 ifeq ($(OS), Windows_NT)
 WINDOWS       ?= YES
@@ -30,6 +34,10 @@ ifeq ($(OPSYS),Haiku)
 LDLIBS        += -lnetwork
 endif
 
+ifeq ($(OPSYS),Linux)
+NEED_LIBDL = YES
+endif
+
 CFLAGS        += -I./src/
 
 ifeq ($(OPSYS),Windows)
@@ -44,6 +52,7 @@ else
 DESTDIR       ?= /
 UHUB_CONF_DIR ?= $(DESTDIR)/etc/uhub
 UHUB_PREFIX   ?= $(DESTDIR)/usr/local
+UHUB_MOD_DIR  ?= $(DESTDIR)/var/lib/uhub
 CFLAGS        += -I/usr/local/include
 LDFLAGS       += -L/usr/local/lib
 BIN_EXT       ?=
@@ -113,10 +122,14 @@ endif
 
 ifeq ($(USE_SSL),YES)
 CFLAGS        += -DSSL_SUPPORT
-LDLIBS        += -lssl
+LDLIBS        += -lssl -lcrypto
 endif
 
-GIT_VERSION=$(shell git describe 2>/dev/null || echo "")
+ifeq ($(NEED_LIBDL),YES)
+LDLIBS        += -ldl
+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 "\"")
 
@@ -135,81 +148,160 @@ libuhub_SOURCES := \
 		src/core/route.c \
 		src/core/user.c \
 		src/core/usermanager.c \
+		src/core/plugincallback.c \
+		src/core/plugininvoke.c \
+		src/core/pluginloader.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/network/timer.c
+
+
+libadc_common_SOURCES := \
+		src/adc/message.c \
+		src/adc/sid.c
+
+libutils_SOURCES := \
+		src/util/cbuffer.c \
+		src/util/config_token.c \
+		src/util/credentials.c \
+		src/util/floodctl.c \
 		src/util/ipcalc.c \
 		src/util/list.c \
 		src/util/log.c \
 		src/util/memory.c \
 		src/util/misc.c \
+		src/network/network.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
 
+uhub-passwd_SOURCES := src/tools/uhub-passwd.c
+uhub-passwd_LIBS    := -lsqlite3
+
 adcrush_SOURCES := src/tools/adcrush.c
 
 admin_SOURCES := src/tools/admin.c
 
 autotest_SOURCES := \
-		autotest/test_message.tcc \
+		autotest/test_commands.tcc \
+		autotest/test_credentials.tcc \
+		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_ipfilter.tcc \
-		autotest/test_inf.tcc \
-		autotest/test_hub.tcc \
+		autotest/test_message.tcc \
 		autotest/test_misc.tcc \
+		autotest/test_sid.tcc \
 		autotest/test_tiger.tcc \
-		autotest/test_usermanager.tcc \
-		autotest/test_eventqueue.tcc
+		autotest/test_timer.tcc \
+		autotest/test_tokenizer.tcc \
+		autotest/test_usermanager.tcc
 
 autotest_OBJECTS = autotest.o
 
+# Plugin targets:
+plugin_example_SOURCES := src/plugins/mod_example.c
+plugin_example_TARGET  := mod_example.so
+
+plugin_welcome_SOURCES := src/plugins/mod_welcome.c
+plugin_welcome_TARGET  := mod_welcome.so
+
+plugin_logging_SOURCES := src/plugins/mod_logging.c
+plugin_logging_TARGET  := mod_logging.so
+
+plugin_auth_SOURCES    := src/plugins/mod_auth_simple.c
+plugin_auth_TARGET     := mod_auth_simple.so
+
+plugin_auth_sqlite_SOURCES := src/plugins/mod_auth_sqlite.c
+plugin_auth_sqlite_TARGET  := mod_auth_sqlite.so
+plugin_auth_sqlite_LIBS    := -lsqlite3
+
+plugin_chat_history_SOURCE := src/plugins/mod_chat_history.c
+plugin_chat_history_TARGET := mod_chat_history.so
+
+plugin_chat_only_SOURCE := src/plugins/mod_chat_only.c
+plugin_chat_only_TARGET := mod_chat_only.so
+
 # Source to objects
 libuhub_OBJECTS       := $(libuhub_SOURCES:.c=.o)
+libutils_OBJECTS      := $(libutils_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)
+uhub-passwd_OBJECTS   := $(uhub-passwd_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)
+all_plugins     := $(plugin_example_TARGET) $(plugin_logging_TARGET) $(plugin_auth_TARGET) $(plugin_auth_sqlite_TARGET) $(plugin_welcome_TARGET) $(plugin_chat_history_TARGET) $(plugin_chat_only_TARGET)
+all_OBJECTS     := $(libuhub_OBJECTS) $(uhub_OBJECTS) $(libutils_OBJECTS) $(adcrush_OBJECTS) $(autotest_OBJECTS) $(admin_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
+all_OBJECTS     += $(all_plugins)
 
 uhub_BINARY=uhub$(BIN_EXT)
+uhub-passwd_BINARY=uhub-passwd$(BIN_EXT)
 adcrush_BINARY=adcrush$(BIN_EXT)
 admin_BINARY=uhub-admin$(BIN_EXT)
 autotest_BINARY=autotest/test$(BIN_EXT)
 
-.PHONY: revision.h.tmp
+
+.PHONY: revision.h.tmp all plugins
 
 %.o: %.c version.h revision.h
-	$(MSG_CC) $(CC) -c $(CFLAGS) -o $@ $<
+	$(MSG_CC) $(CC) -fPIC -c $(CFLAGS) -o $@ $<
 
-all: $(uhub_BINARY)
 
-$(adcrush_BINARY): $(adcrush_OBJECTS) $(libuhub_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
+#%.so: %.c
+#	$(MSG_CC) $(CC) -shared -fPIC -o $@ $^ $(CFLAGS)
+
+
+all: $(uhub_BINARY) $(uhub-passwd_BINARY) plugins
+
+plugins: $(uhub_BINARY) $(all_plugins)
+
+$(plugin_auth_TARGET): $(plugin_auth_SOURCES) $(libutils_OBJECTS)
+	$(MSG_CC) $(CC) -shared -fPIC -o $@ $^ $(CFLAGS)
+
+$(plugin_auth_sqlite_TARGET): $(plugin_auth_sqlite_SOURCES) $(libutils_OBJECTS) 
+	$(MSG_CC) $(CC) -shared -fPIC -o $@ $^ $(CFLAGS) $(LDFLAGS) $(plugin_auth_sqlite_LIBS)
+
+$(plugin_example_TARGET): $(plugin_example_SOURCES) $(libutils_OBJECTS)
+	$(MSG_CC) $(CC) -shared -fPIC -o $@ $^ $(CFLAGS)
+
+$(plugin_logging_TARGET): $(plugin_logging_SOURCES) $(libutils_OBJECTS) $(libadc_common_OBJECTS) src/network/network.o
+	$(MSG_CC) $(CC) -shared -fPIC -o $@ $^ $(CFLAGS)
+
+$(plugin_chat_history_TARGET): $(plugin_chat_history_SOURCE) $(libutils_OBJECTS)
+	$(MSG_CC) $(CC) -shared -fPIC -o $@ $^ $(CFLAGS)
+
+$(plugin_chat_only_TARGET): $(plugin_chat_only_SOURCE) $(libutils_OBJECTS)
+	$(MSG_CC) $(CC) -shared -fPIC -o $@ $^ $(CFLAGS)
+
+$(plugin_welcome_TARGET): $(plugin_welcome_SOURCES) $(libutils_OBJECTS)
+	$(MSG_CC) $(CC) -shared -fPIC -o $@ $^ $(CFLAGS)
+
+$(adcrush_BINARY): $(adcrush_OBJECTS) $(libuhub_OBJECTS) $(libutils_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)
+$(admin_BINARY): $(admin_OBJECTS) $(libuhub_OBJECTS) $(libutils_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
 	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
 
-$(uhub_BINARY): $(uhub_OBJECTS) $(libuhub_OBJECTS) $(libadc_common_OBJECTS)
+$(uhub_BINARY): $(uhub_OBJECTS) $(libuhub_OBJECTS) $(libutils_OBJECTS) $(libadc_common_OBJECTS)
 	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
 
+$(uhub-passwd_BINARY): $(uhub-passwd_OBJECTS)
+	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS) $(uhub-passwd_LIBS)
+
+
 autotest.c: $(autotest_SOURCES)
 	$(shell exotic --standalone $(autotest_SOURCES) > $@)
 
@@ -222,12 +314,13 @@ revision.h.tmp:
 version.h: revision.h
 
 revision.h: revision.h.tmp
-	@if [ '$(GIT_REVISION)' != '$(OLD_REVISION)' ]; then cat $@.tmp > $@; fi
+	@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)
+$(autotest_BINARY): $(autotest_OBJECTS) $(libuhub_OBJECTS) $(libutils_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
 	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
 
 autotest: $(autotest_BINARY)
@@ -240,9 +333,13 @@ else
 install: $(uhub_BINARY)
 	@echo Copying $(uhub_BINARY) to $(UHUB_PREFIX)/bin/
 	@cp $(uhub_BINARY) $(UHUB_PREFIX)/bin/
+	@cp $(uhub-passwd_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
+	@if [ ! -f $(UHUB_CONF_DIR)/rules.txt ]; then cp doc/rules.txt  $(UHUB_CONF_DIR); fi
+	@if [ ! -f $(UHUB_CONF_DIR)/plugins.conf ]; then cp doc/plugins.conf  $(UHUB_CONF_DIR); fi
+	@if [ ! -d $(UHUB_MOD_DIR) ]; then echo Creating $(UHUB_MOD_DIR); mkdir -p $(UHUB_MOD_DIR); fi
+	@cp -f mod_*.so $(UHUB_MOD_DIR)
 	@touch $(UHUB_CONF_DIR)/motd.txt
 	@echo done.
 endif
@@ -251,7 +348,7 @@ 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 && \
+	@rm -rf $(libuhub_OBJECTS) *~ core $(uhub_BINARY) $(admin_BINARY) $(autotest_BINARY) $(adcrush_BINARY) $(all_OBJECTS) $(all_plugins) autotest.c revision.h revision.h.tmp && \
 	echo $(MSG_CLEAN)
 
 

autotest/test_commands.tcc

@@ -0,0 +1,146 @@
+#include <uhub.h>
+
+static struct hub_info* hub = 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);
+	return cbase && hub && uman_init(hub) == 0;
+});
+
+static int test_handler(struct command_base* cbase, struct hub_user* user, struct hub_command* hcmd)
+{
+	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->description = "exotic";
+	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", "n", 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, &user, str);
+	enum command_parse_status status = cmd->status;
+	command_free(cmd);
+	return status == expected;
+}
+
+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, &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); });
+
+EXO_TEST(command_destroy, {
+	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;
+});

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

@@ -23,7 +23,7 @@ EXO_TEST(hub_net_startup, {
 
 EXO_TEST(hub_config_initialize, {
 	config_defaults(&g_config);
-	g_config.server_port = 15111;
+	g_config.server_port = 65111;
 	return 1;
 });
 

autotest/test_memory.tcc

@@ -8,27 +8,27 @@ EXO_TEST(test_message_refc_1, {
 });
 
 EXO_TEST(test_message_refc_2, {
-	return g_msg->references == 0; // 0
+	return g_msg->references == 1;
 });
 
 EXO_TEST(test_message_refc_3, {
 	adc_msg_incref(g_msg);
-	return g_msg->references == 1; // 1
+	return g_msg->references == 2;
 });
 
 EXO_TEST(test_message_refc_4, {
 	adc_msg_incref(g_msg);
-	return g_msg->references == 2; // 2
+	return g_msg->references == 3;
 });
 
 EXO_TEST(test_message_refc_5, {
 	adc_msg_free(g_msg);
-	return g_msg->references == 1; // 1
+	return g_msg->references == 2;
 });
 
 EXO_TEST(test_message_refc_6, {
 	adc_msg_free(g_msg);
-	return g_msg->references == 0; // 0
+	return g_msg->references == 1;
 });
 
 EXO_TEST(test_message_refc_7, {

autotest/test_sid.tcc

@@ -0,0 +1,138 @@
+#include <uhub.h>
+
+static struct sid_pool* sid_pool = 0;
+
+struct dummy_user
+{
+	sid_t sid;
+};
+
+static struct dummy_user* last = 0;
+sid_t last_sid = 0;
+
+EXO_TEST(sid_create_pool, {
+	sid_pool = sid_pool_create(4);
+	return sid_pool != 0;
+});
+
+EXO_TEST(sid_check_0a, {
+	struct dummy_user* user = (struct dummy_user*) sid_lookup(sid_pool, 0);
+	return user == 0;
+});
+
+EXO_TEST(sid_check_0b, {
+	struct dummy_user* user = (struct dummy_user*) sid_lookup(sid_pool, 5);
+	return user == 0;
+});
+
+EXO_TEST(sid_alloc_1, {
+	struct dummy_user* user = hub_malloc_zero(sizeof(struct dummy_user));
+	user->sid = sid_alloc(sid_pool, (struct hub_user*) user);
+	last = user;
+	last_sid = user->sid;
+	return (user->sid > 0 && user->sid < 1048576);
+});
+
+EXO_TEST(sid_check_1a, {
+	struct dummy_user* user = (struct dummy_user*) sid_lookup(sid_pool, last_sid);
+	return last == user;
+});
+
+EXO_TEST(sid_check_1b, {
+	struct dummy_user* user = (struct dummy_user*) sid_lookup(sid_pool, last_sid+1);
+	return user == 0;
+});
+
+EXO_TEST(sid_alloc_2, {
+	struct dummy_user* user = hub_malloc_zero(sizeof(struct dummy_user));
+	user->sid = sid_alloc(sid_pool, (struct hub_user*) user);
+	last_sid = user->sid;
+	return (user->sid > 0 && user->sid < 1048576);
+});
+
+EXO_TEST(sid_check_2, {
+	struct dummy_user* user = (struct dummy_user*) sid_lookup(sid_pool, last_sid);
+	return last != user;
+});
+
+EXO_TEST(sid_alloc_3, {
+	struct dummy_user* user = hub_malloc_zero(sizeof(struct dummy_user));
+	user->sid = sid_alloc(sid_pool, (struct hub_user*) user);
+	last_sid = user->sid;
+	return (user->sid > 0 && user->sid < 1048576);
+});
+
+EXO_TEST(sid_check_3, {
+	struct dummy_user* user = (struct dummy_user*) sid_lookup(sid_pool, last_sid);
+	return last != user;
+});
+
+EXO_TEST(sid_alloc_4, {
+	struct dummy_user* user = hub_malloc_zero(sizeof(struct dummy_user));
+	user->sid = sid_alloc(sid_pool, (struct hub_user*) user);
+	last_sid = user->sid;
+	return (user->sid > 0 && user->sid < 1048576);
+});
+
+EXO_TEST(sid_check_4, {
+	struct dummy_user* user = (struct dummy_user*) sid_lookup(sid_pool, last_sid);
+	return last != user;
+});
+
+EXO_TEST(sid_alloc_5, {
+	struct dummy_user user;
+	sid_t sid;
+	sid = sid_alloc(sid_pool, (struct hub_user*) &user);
+	return sid == 0;
+});
+
+EXO_TEST(sid_check_6, {
+	struct dummy_user* user = (struct dummy_user*) sid_lookup(sid_pool, 0);
+	return user == 0;
+});
+
+
+EXO_TEST(sid_list_all_1, {
+	sid_t s;
+	size_t n = 0;
+	int ok = 1;
+	for (s = last->sid; s <= last_sid; s++)
+	{
+		struct dummy_user* user = (struct dummy_user*) sid_lookup(sid_pool, s);
+		if (s != (user ? user->sid : -1))
+		{
+			ok = 0;
+			break;
+		}
+		n++;
+	}
+	return ok && n == 4;
+});
+
+#define FREE_SID(N) \
+	struct dummy_user* user = (struct dummy_user*) sid_lookup(sid_pool, N); \
+	sid_free(sid_pool, N); \
+	hub_free(user); \
+	return sid_lookup(sid_pool, N) == NULL;
+
+EXO_TEST(sid_remove_1, {
+	FREE_SID(2);
+});
+
+EXO_TEST(sid_remove_2, {
+	FREE_SID(1);
+});
+
+EXO_TEST(sid_remove_3, {
+	FREE_SID(4);
+});
+
+EXO_TEST(sid_remove_4, {
+	FREE_SID(3);
+});
+
+EXO_TEST(sid_destroy_pool, {
+	sid_pool_destroy(sid_pool);
+	sid_pool = 0;
+	return sid_pool == 0;
+});

autotest/test_timer.tcc

@@ -0,0 +1,119 @@
+#include <uhub.h>
+
+#define MAX_EVENTS 15
+static struct timeout_queue* g_queue;
+static time_t g_now;
+static size_t g_max;
+static struct timeout_evt g_events[MAX_EVENTS];
+
+static size_t g_triggered;
+
+static void timeout_cb(struct timeout_evt* t)
+{
+	g_triggered++;
+}
+
+/*
+typedef void (*timeout_evt_cb)(struct timeout_evt*);
+
+struct timeout_evt
+{
+	time_t timestamp;
+	timeout_evt_cb callback;
+	void* ptr;
+	struct timeout_evt* prev;
+	struct timeout_evt* next;
+};
+
+void timeout_evt_initialize(struct timeout_evt*, timeout_evt_cb, void* ptr);
+void timeout_evt_reset(struct timeout_evt*);
+int  timeout_evt_is_scheduled(struct timeout_evt*);
+
+
+struct timeout_queue
+{
+	time_t last;
+	size_t max;
+	struct timeout_evt** events;
+};
+
+void timeout_queue_initialize(struct timeout_queue*, time_t now, size_t max);
+void timeout_queue_shutdown(struct timeout_queue*);
+size_t timeout_queue_process(struct timeout_queue*, time_t now);
+void timeout_queue_insert(struct timeout_queue*, struct timeout_evt*, size_t seconds);
+void timeout_queue_remove(struct timeout_queue*, struct timeout_evt*);
+void timeout_queue_reschedule(struct timeout_queue*, struct timeout_evt*, size_t seconds);
+
+size_t timeout_queue_get_next_timeout(struct timeout_queue*, time_t now);
+*/
+
+
+EXO_TEST(timer_setup,{
+	size_t n;
+	g_queue = hub_malloc_zero(sizeof(struct timeout_queue));
+	g_now = 0;
+	g_max = 5;
+	g_triggered = 0;
+	timeout_queue_initialize(g_queue, g_now, g_max);
+
+	memset(g_events, 0,  sizeof(g_events));
+	for (n = 0; n < MAX_EVENTS; n++)
+	{
+		timeout_evt_initialize(&g_events[n], timeout_cb, &g_events[n]);
+	}
+
+	return g_queue != NULL;
+});
+
+
+EXO_TEST(timer_check_timeout_0,{
+	return timeout_queue_get_next_timeout(g_queue, g_now) == g_max;
+});
+
+
+EXO_TEST(timer_add_event_1,{
+	timeout_queue_insert(g_queue, &g_events[0], 2);
+	return g_events[0].prev != NULL;
+});
+
+EXO_TEST(timer_check_timeout_1,{
+	return timeout_queue_get_next_timeout(g_queue, g_now) == 2;
+});
+
+EXO_TEST(timer_remove_event_1,{
+	timeout_queue_remove(g_queue, &g_events[0]);
+	return g_events[0].prev == NULL;
+});
+
+EXO_TEST(timer_check_timeout_2,{
+	return timeout_queue_get_next_timeout(g_queue, g_now) == g_max;
+});
+
+/* test re-removing an event - should not crash! */
+EXO_TEST(timer_remove_event_1_no_crash,{
+	timeout_queue_remove(g_queue, &g_events[0]);
+	return g_events[0].prev == NULL;
+});
+
+EXO_TEST(timer_add_5_events_1,{
+	timeout_queue_insert(g_queue, &g_events[0], 0);
+	timeout_queue_insert(g_queue, &g_events[1], 1);
+	timeout_queue_insert(g_queue, &g_events[2], 2);
+	timeout_queue_insert(g_queue, &g_events[3], 3);
+	timeout_queue_insert(g_queue, &g_events[4], 4);
+
+	return (g_events[0].prev != NULL &&
+			g_events[1].prev != NULL &&
+			g_events[2].prev != NULL &&
+			g_events[3].prev != NULL &&
+			g_events[4].prev != NULL);
+});
+
+EXO_TEST(timer_check_5_events_1,{
+	return timeout_queue_get_next_timeout(g_queue, g_now) == 1;
+});
+
+EXO_TEST(timer_process_5_events_1,{
+	g_now = 4;
+	return timeout_queue_process(g_queue, g_now) == g_triggered;
+});

autotest/test_tokenizer.tcc

@@ -0,0 +1,107 @@
+#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;
+	for (i = 0; i < strlen(str2); i++)
+		if (str2[i] == '_')
+			str2[i] = ' ';
+		else if (str2[i] == '|')
+			str2[i] = '\t';
+
+	int 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;
+	struct linked_list* compare = list_create();
+	SETUP(tokens, str);
+	split_string(ref, " ", compare, 0);
+	int 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, ""); });
+
+

debian/changelog

@@ -1,3 +1,15 @@
+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
+
+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
+
 uhub (0.3.0-2) unstable; urgency=low
 
   * Fixed init.d scripts.

doc/compile.txt

@@ -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/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
@@ -68,6 +68,14 @@ reload() {
 	return $RETVAL
 }	
 
+relog() {
+    echo -n $"Reopen main log file: "
+     killproc uhub -SIGHUP
+     RETVAL=$?
+     echo ""
+     return $RETVAL
+}
+
 rhstatus() {
 	status uhub
         RETVAL=$?
@@ -90,11 +98,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/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 /var/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 /var/lib/uhub/mod_logging.so "file=/var/log/uhub.log"
+
+# A simple example plugin
+# plugin /var/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 /var/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 /var/lib/uhub/mod_chat_history.so "history_max=200 history_default=10 history_connect=5"
+

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

@@ -49,8 +49,10 @@ file_motd=/etc/uhub/motd.txt
 # 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
+# Slots/share/hubs limits
 limit_max_hubs_user = 0
 limit_max_hubs_reg = 0
 limit_max_hubs_op = 0
@@ -66,13 +68,27 @@ limit_max_share = 0
 limit_min_slots = 0
 limit_max_slots = 0
 
+# Flood control support:
+# set the interval to 5 seconds
+flood_ctl_interval = 5
+
+# Then the maximum chat, connect, search, updates etc will be measured over 5 seconds.
+# So, 3 chat messages per 5 seconds allowed.
+flood_ctl_chat=3
+flood_ctl_connect=20
+flood_ctl_search=1
+flood_ctl_update=2
+flood_ctl_extras=5
+
 # chat control
 # 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
+obsolete_clients=1
+
 
 # Configure status message as sent to clients in different circumstances.
 msg_hub_full                   = Hub is full
@@ -104,5 +120,16 @@ msg_user_slots_high	       = User have too many upload slots
 msg_user_hub_limit_low 	       = User is on too few hubs
 msg_user_hub_limit_high	       = User is on too many hubs
 msg_error_no_memory            = No memory
+msg_user_flood_chat            = Chat flood detected, messages are dropped.
+msg_user_flood_connect         = Connect flood detected, connection refused.
+msg_user_flood_search          = Search flood detected, search is stopped.
+msg_user_flood_update          = Update flood detected.
+msg_user_flood_extras          = Flood detected.
 
+# If a client that supports ADC but not a compatible hash algorithm (tiger),
+# then the hub cannot accept the client:
+msg_proto_no_common_hash       = No common hash algorithm.
+
+# Message to be shown to old clients using an older version of ADC than ADC/1.0
+msg_proto_obsolete_adc0        = Client is using an obsolete ADC protocol version.
 

doc/uhub.spec

@@ -1,13 +1,15 @@
 Summary: High performance ADC p2p hub.
 Name: uhub
-Version: 0.3.0 
-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/var/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/var/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

src/adc/adcconst.h

@@ -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 */
@@ -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')

src/adc/message.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * 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
@@ -26,7 +26,9 @@
 	uhub_assert(X->capacity); \
 	uhub_assert(X->length); \
 	uhub_assert(X->length <= X->capacity); \
+	uhub_assert(X->references > 0); \
 	uhub_assert(X->length == strlen(X->cache));
+#define ADC_MSG_NULL_ON_FREE
 #else
 #define ADC_MSG_ASSERT(X) do { } while(0)
 #endif /* DEBUG */
@@ -53,40 +55,18 @@ static void* msg_malloc_zero(size_t size)
 static void msg_free(void* ptr)
 {
 	LOG_MEMORY("msg_free:   %p", ptr);
-	// hub_free(ptr);
+	hub_free(ptr);
 }
-
-#include <sys/mman.h>
-static void adc_msg_protect(struct adc_message* cmd)
-{
-	LOG_MEMORY("msg_prot:   %p %d", cmd, cmd->capacity);
-	mprotect(cmd,        sizeof(cmd),           PROT_READ);
-	mprotect(cmd->cache, sizeof(cmd->capacity), PROT_READ);
-}
-
-static void adc_msg_unprotect(struct adc_message* cmd)
-{
-	LOG_MEMORY("msg_unprot: %p %d", cmd, cmd->capacity);
-	mprotect(cmd,        sizeof(cmd),           PROT_READ | PROT_WRITE);
-	mprotect(cmd->cache, sizeof(cmd->capacity), PROT_READ | PROT_WRITE);
-}
-
 #else
-
 #define msg_malloc(X)       hub_malloc(X)
 #define msg_malloc_zero(X)  hub_malloc_zero(X)
 #define msg_free(X)         hub_free(X)
-
 #endif /* MSG_MEMORY_DEBUG */
 
 
 struct adc_message* adc_msg_incref(struct adc_message* msg)
 {
-	if (!msg) return 0;
 #ifndef ADC_MESSAGE_INCREF
-#ifdef MSG_MEMORY_DEBUG
-	adc_msg_unprotect(msg);
-#endif
 	msg->references++;
 #ifdef MSG_MEMORY_DEBUG
 	adc_msg_protect(msg);
@@ -108,6 +88,9 @@ static int adc_msg_grow(struct adc_message* msg, size_t size)
 	char* buf;
 	size_t newsize = 0;
 
+	if (!msg)
+		return 0;
+
 	if (msg->capacity > size)
 		return 1;
 
@@ -204,20 +187,15 @@ void adc_msg_free(struct adc_message* msg)
 
 	ADC_MSG_ASSERT(msg);
 
-	if (msg->references > 0)
-	{
-#ifdef MSG_MEMORY_DEBUG
-		adc_msg_unprotect(msg);
-#endif
 	msg->references--;
-#ifdef MSG_MEMORY_DEBUG
-		adc_msg_protect(msg);
-#endif
-	}
-	else
+
+	if (msg->references == 0)
 	{
-#ifdef MSG_MEMORY_DEBUG
-		adc_msg_unprotect(msg);
+#ifdef ADC_MSG_NULL_ON_FREE
+		if (msg->cache)
+		{
+			*msg->cache = 0;
+		}
 #endif
 		msg_free(msg->cache);
 
@@ -256,20 +234,24 @@ struct adc_message* adc_msg_copy(const struct adc_message* cmd)
 	copy->length               = cmd->length;
 	copy->capacity             = 0;
 	copy->priority             = cmd->priority;
-	copy->references           = 0;
+	copy->references           = 1;
 	copy->feature_cast_include = 0;
 	copy->feature_cast_exclude = 0;
 
-	if (cmd->cache)
-	{
 	if (!adc_msg_grow(copy, copy->length))
 	{
 		adc_msg_free(copy);
 		return NULL; /* OOM */
 	}
+
+	if (!copy->cache)
+	{
+		adc_msg_free(copy);
+		return NULL;
+	}
+
 	memcpy(copy->cache, cmd->cache, cmd->length);
 	copy->cache[copy->length] = 0;
-	}
 
 	if (cmd->feature_cast_include)
 	{
@@ -295,9 +277,6 @@ struct adc_message* adc_msg_copy(const struct adc_message* cmd)
 
 	ADC_MSG_ASSERT(copy);
 
-#ifdef MSG_MEMORY_DEBUG
-	adc_msg_protect(copy);
-#endif
 	return copy;
 }
 
@@ -360,6 +339,7 @@ struct adc_message* adc_msg_parse(const char* line, size_t length)
 
 	command->cmd = FOURCC(line[0], line[1], line[2], line[3]);
 	command->priority = 0;
+	command->references = 1;
 
 	switch (prefix)
 	{
@@ -443,7 +423,6 @@ struct adc_message* adc_msg_parse(const char* line, size_t length)
 
 			if  (n == 10)
 				ok = 0;
-			
 			break;
 
 		case 'D':
@@ -510,10 +489,6 @@ struct adc_message* adc_msg_parse(const char* line, size_t length)
 	}
 
 	ADC_MSG_ASSERT(command);
-
-#ifdef MSG_MEMORY_DEBUG
-	adc_msg_protect(command);
-#endif
 	return command;
 }
 
@@ -527,7 +502,6 @@ struct adc_message* adc_msg_create(const char* line)
 struct adc_message* adc_msg_construct(fourcc_t fourcc, size_t size)
 {
 	struct adc_message* msg = (struct adc_message*) msg_malloc_zero(sizeof(struct adc_message));
-	
 	if (!msg)
 		return NULL; /* OOM */
 
@@ -554,11 +528,7 @@ struct adc_message* adc_msg_construct(fourcc_t fourcc, size_t size)
 
 	msg->cmd = fourcc;
 	msg->priority = 0;
-
-#ifdef MSG_MEMORY_DEBUG
-	adc_msg_protect(msg);
-#endif
-
+	msg->references = 1;
 	return msg;
 }
 
@@ -630,7 +600,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;
@@ -698,10 +668,6 @@ void adc_msg_terminate(struct adc_message* cmd)
 		adc_msg_cache_append(cmd, "\n", 1);
 	}
 	ADC_MSG_ASSERT(cmd);
-
-#ifdef MSG_MEMORY_DEBUG
-	adc_msg_protect(cmd);
-#endif
 }
 
 /* FIXME: this looks bogus */
@@ -709,10 +675,6 @@ void adc_msg_unterminate(struct adc_message* cmd)
 {
 	ADC_MSG_ASSERT(cmd);
 
-#ifdef MSG_MEMORY_DEBUG
-	adc_msg_unprotect(cmd);
-#endif
-	
 	if (cmd->length > 0 && cmd->cache[cmd->length-1] == '\n')
 	{
 		cmd->length--;
@@ -794,7 +756,7 @@ char* adc_msg_get_argument(struct adc_message* cmd, int offset)
 			else
 			{
 				argument = hub_strdup(&start[1]);
-				if (argument && argument[strlen(argument)-1] == '\n')
+				if (argument && *argument && argument[strlen(argument)-1] == '\n')
 					argument[strlen(argument)-1] = 0;
 			}
 
@@ -884,9 +846,6 @@ int adc_msg_unescape_length(const char* str)
 }
 
 
-
-
-
 char* adc_msg_unescape(const char* string)
 {
 	char* new_string = msg_malloc(adc_msg_unescape_length(string)+1);
@@ -905,14 +864,12 @@ char* adc_msg_unescape(const char* string)
 				*ptr++ = '\n';
 			else
 				*ptr++ = *str;
-			
 			escaped = 0;
 		} else {
 			if (*str == '\\')
 				escaped = 1;
 			else
 				*ptr++ = *str;
-				
 		}
 		str++;
 	}
@@ -924,8 +881,8 @@ char* adc_msg_unescape(const char* string)
 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

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

src/adc/sid.c

@@ -119,7 +119,16 @@ void sid_pool_destroy(struct sid_pool* pool)
 
 sid_t sid_alloc(struct sid_pool* pool, struct hub_user* user)
 {
-	sid_t n = (++pool->count);
+	sid_t n;
+	if (pool->count >= (pool->max - pool->min))
+	{
+#ifdef DEBUG_SID
+		LOG_DUMP("SID_POOL:  alloc, sid pool is full.");
+#endif
+		return 0;
+	}
+
+	n = (++pool->count);
 	for (; (pool->map[n % pool->max]); n++) ;
 
 #ifdef DEBUG_SID
@@ -140,7 +149,7 @@ void sid_free(struct sid_pool* pool, sid_t sid)
 
 struct hub_user* sid_lookup(struct sid_pool* pool, sid_t sid)
 {
-	if (!sid || (sid > pool->max))
+	if (!sid || (sid >= pool->max))
 		return 0;
 	return pool->map[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

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * 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
@@ -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,7 +51,7 @@ 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)))
 	{
@@ -86,7 +67,7 @@ static int check_cmd_user(const char* cmd, int status, struct linked_list* list,
 			return -1;
 		}
 
-		info = hub_malloc_zero(sizeof(struct hub_user_access_info));
+		info = hub_malloc_zero(sizeof(struct auth_info));
 
 		if (!info)
 		{
@@ -104,11 +85,12 @@ static int check_cmd_user(const char* cmd, int status, struct linked_list* list,
 			}
 		}
 
-		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;
@@ -176,14 +158,10 @@ static int check_cmd_addr(const char* cmd, struct linked_list* list, char* line,
 
 static int acl_parse_line(char* line, int line_count, void* ptr_data)
 {
-	char* pos;
 	struct acl_handle* handle = (struct acl_handle*) ptr_data;
 	int ret;
 
-	if ((pos = strchr(line, '#')) != NULL)
-	{
-		pos[0] = 0;
-	}
+	strip_off_ini_line_comments(line, line_count);
 
 	line = strip_white_space(line);
 	if (!*line)
@@ -191,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);
@@ -247,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);
 	}
 }
@@ -305,24 +281,52 @@ int acl_shutdown(struct acl_handle* handle)
 		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 0;
+	}
+	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 info;
+		return 0;
 	}
-		info = (struct hub_user_access_info*) list_get_next(handle->users);
+	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) \
@@ -358,20 +362,10 @@ int acl_is_user_denied(struct acl_handle* handle, const char* data)
 
 int acl_user_ban_nick(struct acl_handle* handle, const char* nick)
 {
-	char* data = 0;
-	struct hub_user_access_info* info = hub_malloc_zero(sizeof(struct hub_user_access_info));
-
-	if (!info)
-	{
-		LOG_ERROR("ACL error: Out of memory!");
-		return -1;
-	}
-
-	data = hub_strdup(nick);
+	char* data = hub_strdup(nick);
 	if (!data)
 	{
 		LOG_ERROR("ACL error: Out of memory!");
-		hub_free(info);
 		return -1;
 	}
 
@@ -381,19 +375,10 @@ int acl_user_ban_nick(struct acl_handle* handle, const char* nick)
 
 int acl_user_ban_cid(struct acl_handle* handle, const char* cid)
 {
-	char* data;
-	struct hub_user_access_info* info = hub_malloc_zero(sizeof(struct hub_user_access_info));
-	if (!info)
-	{
-		LOG_ERROR("ACL error: Out of memory!");
-		return -1;
-	}
-
-	data = hub_strdup(cid);
+	char* data = hub_strdup(cid);
 	if (!data)
 	{
 		LOG_ERROR("ACL error: Out of memory!");
-		hub_free(info);
 		return -1;
 	}
 
@@ -453,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];
@@ -469,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

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

@@ -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
@@ -17,6 +17,160 @@
  *
  */
 
-#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;
+
+typedef int (*command_handler)(struct command_base* cbase, struct hub_user* user, struct hub_command* cmd);
+
+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')" */
+};
+
+struct hub_command_arg_data
+{
+	enum Type {
+		type_integer,
+		type_string,
+		type_user,
+		type_address,
+		type_range,
+		type_credentials,
+		type_command
+	} 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;
+
+	struct hub_command_arg_data* next;
+};
+
+void hub_command_args_free(struct hub_command* command);
+
+/**
+ * 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 all parsed arguments from the message. Type depends on expectations." */
+	enum command_parse_status status;   /**<<< "Status of the 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" */
+};
+
+/**
+ * Argument codes are used to automatically parse arguments
+ * for a a hub command.
+ *
+ * n = nick name (must exist in hub session)
+ * 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.
+ * NOTE; if an argument is optional then all following arguments must also be optional.
+ *
+ * Example:
+ * "nia" means "nick cid ip"
+ * "n?p" means "nick [password]" where password is optional.
+ *
+ */
+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);
+
+/**
+ * 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, 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);
+
+
+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

@@ -29,459 +29,44 @@
 #define INT_MIN (-0x7fffffff - 1)
 #endif
 
-#define CFG_APPLY_BOOLEAN(KEY, TARGET) \
-	if (strcmp(KEY, key) == 0) \
-	{ \
-		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\
-		{ \
-			LOG_FATAL("Configuration error on line %d: '%s' must be either '1' or '0'", line_count, key); \
-			return -1; \
-		} \
-		TARGET |= 0x80000000; \
-		return 0; \
-	}
-
-#define CFG_APPLY_STRING(KEY, TARGET) \
-	if (strcmp(KEY, key) == 0) \
-	{ \
-		TARGET = hub_strdup(data); \
-		return 0; \
-	}
-
-
-#define CFG_APPLY_INTEGER(KEY, TARGET) \
-	if (strcmp(KEY, key) == 0) \
-	{ \
-		char* endptr; \
-		int val; \
-		errno = 0; \
-		val = strtol(data, &endptr, 10); \
-		if (((errno == ERANGE && (val == INT_MAX || val == INT_MIN)) || (errno != 0 && val == 0)) || endptr == data) { \
-			LOG_FATAL("Configuration error on line %d: '%s' must be a number", line_count, key); \
-			return -1; \
-		} \
-		TARGET = val; \
-		return 0; \
-	}
-
-
-#define DEFAULT_STRING(KEY, VALUE) \
-{ \
-	if (config->KEY == 0) \
-		config->KEY = hub_strdup(VALUE); \
-}
-
-#define DEFAULT_INTEGER(KEY, VALUE) \
-{ \
-	if (config->KEY == 0) \
-		config->KEY = VALUE; \
-}
-
-#define DEFAULT_BOOLEAN(KEY, VALUE) \
-{ \
-	if (config->KEY & 0x80000000) \
-	{ \
-		config->KEY = config->KEY & 0x000000ff; \
-	} \
-	else \
-	{ \
-		config->KEY = VALUE; \
-	} \
-}
-
-#define GET_STR(NAME)  CFG_APPLY_STRING ( #NAME , config->NAME )
-#define GET_INT(NAME)  CFG_APPLY_INTEGER( #NAME , config->NAME )
-#define GET_BOOL(NAME) CFG_APPLY_BOOLEAN( #NAME , config->NAME )
-#define IGNORED(NAME) \
-    if (strcmp(#NAME, key) == 0) \
-    { \
-        LOG_WARN("Configuration option %s deprecated and ingnored.", key); \
-        return 0; \
-    } \
-
-/* default configuration values */
-#define DEF_SERVER_BIND_ADDR                "any"
-#define DEF_SERVER_PORT                     1511
-#define DEF_SERVER_BACKLOG                  50
-#define DEF_SERVER_ALT_PORTS                ""
-#define DEF_HUB_NAME                        "uhub"
-#define DEF_HUB_DESCRIPTION                 ""
-#define DEF_HUB_ENABLED                     1
-#define DEF_FILE_ACL                        ""
-#define DEF_FILE_MOTD                       ""
-#define DEF_FILE_RULES                      ""
-#define DEF_MAX_USERS                       500
-#define DEF_MAX_CHAT_HISTORY                20
-#define DEF_MAX_LOGOUT_LOG                  100
-#define DEF_MAX_RECV_BUFFER                 4096
-#define DEF_MAX_SEND_BUFFER                 131072
-#define DEF_MAX_SEND_BUFFER_SOFT            98304
-#define DEF_SHOW_BANNER                     1
-#define DEF_SHOW_BANNER_SYS_INFO            1
-#define DEF_REGISTERED_USERS_ONLY           0
-#define DEF_CHAT_ONLY                       0
-#define DEF_CHAT_IS_PRIVILEGED              0
-#define DEF_LOW_BANDWIDTH_MODE              0
-#define DEF_LIMIT_MAX_HUBS_USER             0
-#define DEF_LIMIT_MAX_HUBS_REG              0
-#define DEF_LIMIT_MAX_HUBS_OP               0
-#define DEF_LIMIT_MAX_HUBS                  0
-#define DEF_LIMIT_MIN_HUBS_USER             0
-#define DEF_LIMIT_MIN_HUBS_REG              0
-#define DEF_LIMIT_MIN_HUBS_OP               0
-#define DEF_LIMIT_MIN_SHARE                 0
-#define DEF_LIMIT_MAX_SHARE                 0
-#define DEF_LIMIT_MIN_SLOTS                 0
-#define DEF_LIMIT_MAX_SLOTS                 0
-#define DEF_TLS_ENABLE                      0
-#define DEF_TLS_REQUIRE                     1
-#define DEF_TLS_PRIVATE_KEY                 ""
-#define DEF_TLS_CERTIFICATE                 ""
-#define DEF_MSG_HUB_FULL                    "Hub is full"
-#define DEF_MSG_HUB_DISABLED                "Hub is disabled"
-#define DEF_MSG_HUB_REGISTERED_USERS_ONLY   "Hub is for registered users only"
-#define DEF_MSG_INF_ERROR_NICK_MISSING      "No nickname given"
-#define DEF_MSG_INF_ERROR_NICK_MULTIPLE     "Multiple nicknames given"
-#define DEF_MSG_INF_ERROR_NICK_INVALID      "Nickname is invalid"
-#define DEF_MSG_INF_ERROR_NICK_LONG         "Nickname too long"
-#define DEF_MSG_INF_ERROR_NICK_SHORT        "Nickname too short"
-#define DEF_MSG_INF_ERROR_NICK_SPACES       "Nickname cannot start with spaces"
-#define DEF_MSG_INF_ERROR_NICK_BAD_CHARS    "Nickname contains invalid characters"
-#define DEF_MSG_INF_ERROR_NICK_NOT_UTF8     "Nickname is not valid utf8"
-#define DEF_MSG_INF_ERROR_NICK_TAKEN        "Nickname is already in use"
-#define DEF_MSG_INF_ERROR_NICK_RESTRICTED   "Nickname cannot be used on this hub"
-#define DEF_MSG_INF_ERROR_CID_INVALID       "CID is not valid"
-#define DEF_MSG_INF_ERROR_CID_MISSING       "CID is not specified"
-#define DEF_MSG_INF_ERROR_CID_TAKEN         "CID is taken"
-#define DEF_MSG_INF_ERROR_PID_MISSING       "PID is not specified"
-#define DEF_MSG_INF_ERROR_PID_INVALID       "PID is invalid"
-#define DEF_MSG_BAN_PERMANENTLY             "Banned permanently"
-#define DEF_MSG_BAN_TEMPORARILY             "Banned temporarily"
-#define DEF_MSG_AUTH_INVALID_PASSWORD       "Password is wrong"
-#define DEF_MSG_AUTH_USER_NOT_FOUND         "User not found in password database"
-#define DEF_MSG_ERROR_NO_MEMORY             "No memory"
-#define DEF_MSG_USER_SHARE_SIZE_LOW         "User is not sharing enough"
-#define DEF_MSG_USER_SHARE_SIZE_HIGH        "User is sharing too much"
-#define DEF_MSG_USER_SLOTS_LOW              "User have too few upload slots."
-#define DEF_MSG_USER_SLOTS_HIGH             "User have too many upload slots."
-#define DEF_MSG_USER_HUB_LIMIT_LOW          "User is on too few hubs."
-#define DEF_MSG_USER_HUB_LIMIT_HIGH         "User is on too many hubs."
-
-void config_defaults(struct hub_config* config)
+static int apply_boolean(const char* key, const char* data, int* target)
 {
-	DEFAULT_STRING (server_bind_addr,      DEF_SERVER_BIND_ADDR);
-	DEFAULT_STRING (hub_name,              DEF_HUB_NAME);
-	DEFAULT_STRING (hub_description,       DEF_HUB_DESCRIPTION);
-	DEFAULT_BOOLEAN(hub_enabled,           DEF_HUB_ENABLED);
-	DEFAULT_STRING (file_acl,              DEF_FILE_ACL);
-	DEFAULT_STRING (file_motd,             DEF_FILE_MOTD);
-	DEFAULT_STRING (file_rules,            DEF_FILE_RULES);
-	DEFAULT_INTEGER(server_port,           DEF_SERVER_PORT);
-	DEFAULT_INTEGER(server_listen_backlog, DEF_SERVER_BACKLOG);
-	DEFAULT_STRING (server_alt_ports,      DEF_SERVER_ALT_PORTS);
-	DEFAULT_INTEGER(max_users,             DEF_MAX_USERS);
-	DEFAULT_INTEGER(max_chat_history,      DEF_MAX_CHAT_HISTORY);
-	DEFAULT_INTEGER(max_logout_log,        DEF_MAX_LOGOUT_LOG);
-	DEFAULT_INTEGER(max_recv_buffer,       DEF_MAX_RECV_BUFFER);
-	DEFAULT_INTEGER(max_send_buffer,       DEF_MAX_SEND_BUFFER);
-	DEFAULT_INTEGER(max_send_buffer_soft,  DEF_MAX_SEND_BUFFER_SOFT);
-	DEFAULT_BOOLEAN(show_banner,           DEF_SHOW_BANNER);
-	DEFAULT_BOOLEAN(show_banner_sys_info,  DEF_SHOW_BANNER_SYS_INFO);
-	DEFAULT_BOOLEAN(chat_only,             DEF_CHAT_ONLY);
-	DEFAULT_BOOLEAN(chat_is_privileged,    DEF_CHAT_IS_PRIVILEGED);
-	DEFAULT_BOOLEAN(low_bandwidth_mode,    DEF_LOW_BANDWIDTH_MODE);
-	DEFAULT_BOOLEAN(registered_users_only, DEF_REGISTERED_USERS_ONLY);
-	
-	/* Limits enforced on users */
-	DEFAULT_INTEGER(limit_max_hubs_user,   DEF_LIMIT_MAX_HUBS_USER);
-	DEFAULT_INTEGER(limit_max_hubs_reg,    DEF_LIMIT_MAX_HUBS_REG);
-	DEFAULT_INTEGER(limit_max_hubs_op,     DEF_LIMIT_MAX_HUBS_OP);
-	DEFAULT_INTEGER(limit_min_hubs_user,   DEF_LIMIT_MIN_HUBS_USER);
-	DEFAULT_INTEGER(limit_min_hubs_reg,    DEF_LIMIT_MIN_HUBS_REG);
-	DEFAULT_INTEGER(limit_min_hubs_op,     DEF_LIMIT_MIN_HUBS_OP);
-	DEFAULT_INTEGER(limit_max_hubs,        DEF_LIMIT_MAX_HUBS);
-	DEFAULT_INTEGER(limit_min_share,       DEF_LIMIT_MIN_SHARE);
-	DEFAULT_INTEGER(limit_max_share,       DEF_LIMIT_MAX_SHARE);
-	DEFAULT_INTEGER(limit_min_slots,       DEF_LIMIT_MIN_SLOTS);
-	DEFAULT_INTEGER(limit_max_slots,       DEF_LIMIT_MAX_SLOTS);
-
-	/* Status/error strings */
-	DEFAULT_STRING (msg_hub_full,                  DEF_MSG_HUB_FULL);
-	DEFAULT_STRING (msg_hub_disabled,              DEF_MSG_HUB_DISABLED)
-	DEFAULT_STRING (msg_hub_registered_users_only, DEF_MSG_HUB_REGISTERED_USERS_ONLY);
-	DEFAULT_STRING (msg_inf_error_nick_missing,    DEF_MSG_INF_ERROR_NICK_MISSING);
-	DEFAULT_STRING (msg_inf_error_nick_multiple,   DEF_MSG_INF_ERROR_NICK_MULTIPLE);
-	DEFAULT_STRING (msg_inf_error_nick_invalid,    DEF_MSG_INF_ERROR_NICK_INVALID);
-	DEFAULT_STRING (msg_inf_error_nick_long,       DEF_MSG_INF_ERROR_NICK_LONG);
-	DEFAULT_STRING (msg_inf_error_nick_short,      DEF_MSG_INF_ERROR_NICK_SHORT);
-	DEFAULT_STRING (msg_inf_error_nick_spaces,     DEF_MSG_INF_ERROR_NICK_SPACES);
-	DEFAULT_STRING (msg_inf_error_nick_bad_chars,  DEF_MSG_INF_ERROR_NICK_BAD_CHARS);
-	DEFAULT_STRING (msg_inf_error_nick_not_utf8,   DEF_MSG_INF_ERROR_NICK_NOT_UTF8);
-	DEFAULT_STRING (msg_inf_error_nick_taken,      DEF_MSG_INF_ERROR_NICK_TAKEN);
-	DEFAULT_STRING (msg_inf_error_nick_restricted, DEF_MSG_INF_ERROR_NICK_RESTRICTED);
-	DEFAULT_STRING (msg_inf_error_cid_invalid,     DEF_MSG_INF_ERROR_CID_INVALID);
-	DEFAULT_STRING (msg_inf_error_cid_missing,     DEF_MSG_INF_ERROR_CID_MISSING);
-	DEFAULT_STRING (msg_inf_error_cid_taken,       DEF_MSG_INF_ERROR_CID_TAKEN);
-	DEFAULT_STRING (msg_inf_error_pid_missing,     DEF_MSG_INF_ERROR_PID_MISSING);
-	DEFAULT_STRING (msg_inf_error_pid_invalid,     DEF_MSG_INF_ERROR_PID_INVALID);
-	DEFAULT_STRING (msg_ban_permanently,           DEF_MSG_BAN_PERMANENTLY);
-	DEFAULT_STRING (msg_ban_temporarily,           DEF_MSG_BAN_TEMPORARILY);
-	DEFAULT_STRING (msg_auth_invalid_password,     DEF_MSG_AUTH_INVALID_PASSWORD);
-	DEFAULT_STRING (msg_auth_user_not_found,       DEF_MSG_AUTH_USER_NOT_FOUND);
-	DEFAULT_STRING (msg_error_no_memory,           DEF_MSG_ERROR_NO_MEMORY);
-	DEFAULT_STRING (msg_user_share_size_low,       DEF_MSG_USER_SHARE_SIZE_LOW);
-	DEFAULT_STRING (msg_user_share_size_high,      DEF_MSG_USER_SHARE_SIZE_HIGH);
-	DEFAULT_STRING (msg_user_slots_low,            DEF_MSG_USER_SLOTS_LOW);
-	DEFAULT_STRING (msg_user_slots_high,           DEF_MSG_USER_SLOTS_HIGH);
-	DEFAULT_STRING (msg_user_hub_limit_low,        DEF_MSG_USER_HUB_LIMIT_LOW);
-	DEFAULT_STRING (msg_user_hub_limit_high,       DEF_MSG_USER_HUB_LIMIT_HIGH);
-
-	DEFAULT_INTEGER(tls_enable,                    DEF_TLS_ENABLE);
-	DEFAULT_INTEGER(tls_require,                   DEF_TLS_REQUIRE);
-	DEFAULT_STRING (tls_certificate,               DEF_TLS_CERTIFICATE);
-	DEFAULT_STRING (tls_private_key,               DEF_TLS_PRIVATE_KEY);
+	return string_to_boolean(data, target);
 }
 
-
-static int apply_config(struct hub_config* config, char* key, char* data, int line_count)
+static int apply_string(const char* key, const char* data, char** target, char* regexp)
 {
-	GET_STR (file_acl);
-	GET_STR (file_motd);
-	GET_STR (file_rules);
-	GET_STR (server_bind_addr);
-	GET_INT (server_port);
-	GET_INT (server_listen_backlog);
-	GET_STR (server_alt_ports);
-	GET_STR (hub_name);
-	GET_STR (hub_description);
-	GET_BOOL(hub_enabled);
-	GET_INT (max_users);
-	GET_INT (max_chat_history);
-	GET_INT (max_logout_log);
-	GET_INT (max_recv_buffer);
-	GET_INT (max_send_buffer);
-	GET_INT (max_send_buffer_soft);
-	GET_BOOL(show_banner);
-	GET_BOOL(show_banner_sys_info);
-	GET_BOOL(chat_only);
-	GET_BOOL(chat_is_privileged);
-	GET_BOOL(low_bandwidth_mode);
-	GET_BOOL(registered_users_only);
+	(void) regexp;
+	// FIXME: Add regexp checks for correct data
 
-	/* Limits enforced on users */
-	GET_INT(limit_max_hubs_user);
-	GET_INT(limit_max_hubs_reg);
-	GET_INT(limit_max_hubs_op);
-	GET_INT(limit_min_hubs_user);
-	GET_INT(limit_min_hubs_reg);
-	GET_INT(limit_min_hubs_op);
-	GET_INT(limit_max_hubs);
-	GET_INT(limit_min_share);
-	GET_INT(limit_max_share);
-	GET_INT(limit_min_slots);
-	GET_INT(limit_max_slots);
+	if (*target)
+		hub_free(*target);
 
-	/* Status/error strings */
-	GET_STR (msg_hub_full);
-	GET_STR (msg_hub_disabled);
-	GET_STR (msg_hub_registered_users_only);
-	GET_STR (msg_inf_error_nick_missing);
-	GET_STR (msg_inf_error_nick_multiple);
-	GET_STR (msg_inf_error_nick_invalid);
-	GET_STR (msg_inf_error_nick_long);
-	GET_STR (msg_inf_error_nick_short);
-	GET_STR (msg_inf_error_nick_spaces);
-	GET_STR (msg_inf_error_nick_bad_chars);
-	GET_STR (msg_inf_error_nick_not_utf8);
-	GET_STR (msg_inf_error_nick_taken);
-	GET_STR (msg_inf_error_nick_restricted);
-	GET_STR (msg_inf_error_cid_invalid);
-	GET_STR (msg_inf_error_cid_missing);
-	GET_STR (msg_inf_error_cid_taken);
-	GET_STR (msg_inf_error_pid_missing);
-	GET_STR (msg_inf_error_pid_invalid);
-	GET_STR (msg_ban_permanently);
-	GET_STR (msg_ban_temporarily);
-	GET_STR (msg_auth_invalid_password);
-	GET_STR (msg_auth_user_not_found);
-	GET_STR (msg_error_no_memory);
-	GET_STR (msg_user_share_size_low);
-	GET_STR (msg_user_share_size_high);
-	GET_STR (msg_user_slots_low);
-	GET_STR (msg_user_slots_high);
-	GET_STR (msg_user_hub_limit_low);
-	GET_STR (msg_user_hub_limit_high);
-
-	GET_BOOL(tls_enable);
-	GET_BOOL(tls_require);
-	GET_STR (tls_certificate);
-	GET_STR (tls_private_key);
-
-    /* Still here -- unknown directive */
-	LOG_ERROR("Unknown configuration directive: '%s'", key);
-	return -1;
+	*target = hub_strdup(data);
+	return 1;
 }
 
-
-void free_config(struct hub_config* config)
+static int apply_integer(const char* key, const char* data, int* target, int* min, int* max)
 {
-	hub_free(config->server_bind_addr);
-	hub_free(config->server_alt_ports);
-	hub_free(config->file_motd);
-	hub_free(config->file_acl);
-	hub_free(config->file_rules);
-	hub_free(config->hub_name);
-	hub_free(config->hub_description);
+	char* endptr;
+	int val;
+	errno = 0;
+	val = strtol(data, &endptr, 10);
 
-	hub_free(config->msg_hub_full);
-	hub_free(config->msg_hub_disabled);
-	hub_free(config->msg_hub_registered_users_only);
-	hub_free(config->msg_inf_error_nick_missing);
-	hub_free(config->msg_inf_error_nick_multiple);
-	hub_free(config->msg_inf_error_nick_invalid);
-	hub_free(config->msg_inf_error_nick_long);
-	hub_free(config->msg_inf_error_nick_short);
-	hub_free(config->msg_inf_error_nick_spaces);
-	hub_free(config->msg_inf_error_nick_bad_chars);
-	hub_free(config->msg_inf_error_nick_not_utf8);
-	hub_free(config->msg_inf_error_nick_taken);
-	hub_free(config->msg_inf_error_nick_restricted);
-	hub_free(config->msg_inf_error_cid_invalid);
-	hub_free(config->msg_inf_error_cid_missing);
-	hub_free(config->msg_inf_error_cid_taken);
-	hub_free(config->msg_inf_error_pid_missing);
-	hub_free(config->msg_inf_error_pid_invalid);
-	hub_free(config->msg_ban_permanently);
-	hub_free(config->msg_ban_temporarily);
-	hub_free(config->msg_auth_invalid_password);
-	hub_free(config->msg_auth_user_not_found);
-	hub_free(config->msg_error_no_memory);
-	hub_free(config->msg_user_share_size_low);
-	hub_free(config->msg_user_share_size_high);
-	hub_free(config->msg_user_slots_low);
-	hub_free(config->msg_user_slots_high);
-	hub_free(config->msg_user_hub_limit_low);
-	hub_free(config->msg_user_hub_limit_high);
+	if (((errno == ERANGE && (val == INT_MAX || val == INT_MIN)) || (errno != 0 && val == 0)) || endptr == data)
+			return 0;
 
-	hub_free(config->tls_certificate);
-	hub_free(config->tls_private_key);
+	if (min && val < *min)
+		return 0;
 
-	memset(config, 0, sizeof(struct hub_config));
-}
-
-#define DUMP_STR(NAME, DEFAULT) \
-	if (ignore_defaults) \
-	{ \
-		if (strcmp(config->NAME, DEFAULT) != 0) \
-			fprintf(stdout, "%s = \"%s\"\n", #NAME , config->NAME); \
-	} \
-	else \
-		fprintf(stdout, "%s = \"%s\"\n", #NAME , config->NAME); \
-		
-#define DUMP_INT(NAME, DEFAULT) \
-	if (ignore_defaults) \
-	{ \
-		if (config->NAME != DEFAULT) \
-			fprintf(stdout, "%s = %d\n", #NAME , config->NAME); \
-	} \
-	else \
-		fprintf(stdout, "%s = %d\n", #NAME , config->NAME); \
-
-
-#define DUMP_BOOL(NAME, DEFAULT) \
-	if (ignore_defaults) \
-	{ \
-		if (config->NAME != DEFAULT) \
-			fprintf(stdout, "%s = %s\n", #NAME , (config->NAME ? "yes" : "no")); \
-	} \
-	else \
-		fprintf(stdout, "%s = %s\n", #NAME , (config->NAME ? "yes" : "no"));
-
-void dump_config(struct hub_config* config, int ignore_defaults)
-{
-	DUMP_STR (file_acl, DEF_FILE_ACL);
-	DUMP_STR (file_motd, DEF_FILE_MOTD);
-	DUMP_STR (file_rules, DEF_FILE_RULES);
-	DUMP_STR (server_bind_addr, DEF_SERVER_BIND_ADDR);
-	DUMP_INT (server_port, DEF_SERVER_PORT);
-	DUMP_INT (server_listen_backlog, DEF_SERVER_BACKLOG);
-	DUMP_STR (server_alt_ports, DEF_SERVER_ALT_PORTS);
-	DUMP_STR (hub_name, DEF_HUB_NAME);
-	DUMP_STR (hub_description, DEF_HUB_DESCRIPTION);
-	DUMP_BOOL(hub_enabled, DEF_HUB_ENABLED);
-	DUMP_INT (max_users, DEF_MAX_USERS);
-	DUMP_INT (max_chat_history, DEF_MAX_CHAT_HISTORY);
-	DUMP_INT (max_logout_log, DEF_MAX_LOGOUT_LOG);
-	DUMP_INT (max_recv_buffer, DEF_MAX_RECV_BUFFER);
-	DUMP_INT (max_send_buffer, DEF_MAX_SEND_BUFFER);
-	DUMP_INT (max_send_buffer_soft, DEF_MAX_SEND_BUFFER_SOFT);
-	DUMP_BOOL(show_banner, DEF_SHOW_BANNER);
-	DUMP_BOOL(show_banner_sys_info, DEF_SHOW_BANNER_SYS_INFO);
-	DUMP_BOOL(chat_only, DEF_CHAT_ONLY);
-	DUMP_BOOL(chat_is_privileged, DEF_CHAT_IS_PRIVILEGED);
-	DUMP_BOOL(low_bandwidth_mode, DEF_LOW_BANDWIDTH_MODE);
-	DUMP_BOOL(registered_users_only, DEF_REGISTERED_USERS_ONLY);
-
-#ifdef SSL_SUPPORT
-	DUMP_BOOL(tls_enable, DEF_TLS_ENABLE);
-	DUMP_BOOL(tls_require, DEF_TLS_REQUIRE);
-	DUMP_STR (tls_certificate, DEF_TLS_CERTIFICATE);
-	DUMP_STR (tls_private_key, DEF_TLS_PRIVATE_KEY);
-#endif
-
-	/* Limits enforced on users */
-	DUMP_INT(limit_max_hubs_user, DEF_LIMIT_MAX_HUBS_USER);
-	DUMP_INT(limit_max_hubs_reg, DEF_LIMIT_MAX_HUBS_REG);
-	DUMP_INT(limit_max_hubs_op, DEF_LIMIT_MAX_HUBS_OP);
-	DUMP_INT(limit_min_hubs_user, DEF_LIMIT_MIN_HUBS_USER);
-	DUMP_INT(limit_min_hubs_reg, DEF_LIMIT_MIN_HUBS_REG);
-	DUMP_INT(limit_min_hubs_op, DEF_LIMIT_MIN_HUBS_OP);
-	DUMP_INT(limit_max_hubs, DEF_LIMIT_MAX_HUBS);
-	DUMP_INT(limit_min_share, DEF_LIMIT_MIN_SHARE);
-	DUMP_INT(limit_max_share, DEF_LIMIT_MAX_SHARE);
-	DUMP_INT(limit_min_slots, DEF_LIMIT_MIN_SLOTS);
-	DUMP_INT(limit_max_slots, DEF_LIMIT_MAX_SLOTS);
-	
-	/* Status/error strings */
-	DUMP_STR (msg_hub_full, DEF_MSG_HUB_FULL);
-	DUMP_STR (msg_hub_disabled, DEF_MSG_HUB_DISABLED);
-	DUMP_STR (msg_hub_registered_users_only, DEF_MSG_HUB_REGISTERED_USERS_ONLY);
-	DUMP_STR (msg_inf_error_nick_missing, DEF_MSG_INF_ERROR_NICK_MISSING);
-	DUMP_STR (msg_inf_error_nick_multiple, DEF_MSG_INF_ERROR_NICK_MULTIPLE);
-	DUMP_STR (msg_inf_error_nick_invalid, DEF_MSG_INF_ERROR_NICK_INVALID);
-	DUMP_STR (msg_inf_error_nick_long, DEF_MSG_INF_ERROR_NICK_LONG);
-	DUMP_STR (msg_inf_error_nick_short, DEF_MSG_INF_ERROR_NICK_SHORT);
-	DUMP_STR (msg_inf_error_nick_spaces, DEF_MSG_INF_ERROR_NICK_SPACES);
-	DUMP_STR (msg_inf_error_nick_bad_chars, DEF_MSG_INF_ERROR_NICK_BAD_CHARS);
-	DUMP_STR (msg_inf_error_nick_not_utf8, DEF_MSG_INF_ERROR_NICK_NOT_UTF8);
-	DUMP_STR (msg_inf_error_nick_taken, DEF_MSG_INF_ERROR_NICK_TAKEN);
-	DUMP_STR (msg_inf_error_nick_restricted, DEF_MSG_INF_ERROR_NICK_RESTRICTED);
-	DUMP_STR (msg_inf_error_cid_invalid, DEF_MSG_INF_ERROR_CID_INVALID);
-	DUMP_STR (msg_inf_error_cid_missing, DEF_MSG_INF_ERROR_CID_MISSING);
-	DUMP_STR (msg_inf_error_cid_taken, DEF_MSG_INF_ERROR_CID_TAKEN);
-	DUMP_STR (msg_inf_error_pid_missing, DEF_MSG_INF_ERROR_PID_MISSING);
-	DUMP_STR (msg_inf_error_pid_invalid, DEF_MSG_INF_ERROR_PID_INVALID);
-	DUMP_STR (msg_ban_permanently, DEF_MSG_BAN_PERMANENTLY);
-	DUMP_STR (msg_ban_temporarily, DEF_MSG_BAN_TEMPORARILY);
-	DUMP_STR (msg_auth_invalid_password, DEF_MSG_AUTH_INVALID_PASSWORD);
-	DUMP_STR (msg_auth_user_not_found, DEF_MSG_AUTH_USER_NOT_FOUND);
-	DUMP_STR (msg_error_no_memory, DEF_MSG_ERROR_NO_MEMORY);
-	DUMP_STR (msg_user_share_size_low, DEF_MSG_USER_SHARE_SIZE_LOW);
-	DUMP_STR (msg_user_share_size_high, DEF_MSG_USER_SHARE_SIZE_HIGH);
-	DUMP_STR (msg_user_slots_low, DEF_MSG_USER_SLOTS_LOW);
-	DUMP_STR (msg_user_slots_high, DEF_MSG_USER_SLOTS_HIGH);
-	DUMP_STR (msg_user_hub_limit_low, DEF_MSG_USER_HUB_LIMIT_LOW);
-	DUMP_STR (msg_user_hub_limit_high, DEF_MSG_USER_HUB_LIMIT_HIGH);
+	if (max && val > *max)
+		return 0;
+
+	*target = val;
+	return 1;
 }
 
+#include "gen_config.c"
 
 static int config_parse_line(char* line, int line_count, void* ptr_data)
 {
@@ -490,10 +75,7 @@ static int config_parse_line(char* line, int line_count, void* ptr_data)
 	char* data;
 	struct hub_config* config = (struct hub_config*) ptr_data;
 
-	if ((pos = strchr(line, '#')) != NULL)
-	{
-		pos[0] = 0;
-	}
+	strip_off_ini_line_comments(line, line_count);
 	
 	if (!*line) return 0;
 
@@ -518,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)
 	{
@@ -536,6 +119,7 @@ int read_config(const char* file, struct hub_config* config, int allow_missing)
 	int ret;
 
 	memset(config, 0, sizeof(struct hub_config));
+	config_defaults(config);
 
 	ret = file_read_lines(file, config, &config_parse_line);
 	if (ret < 0)
@@ -550,7 +134,6 @@ int read_config(const char* file, struct hub_config* config, int allow_missing)
 		}
 	}
 
-	config_defaults(config);
 	return 0;
 }
 

src/core/config.h

@@ -20,81 +20,7 @@
 #ifndef HAVE_UHUB_CONFIG_H
 #define HAVE_UHUB_CONFIG_H
 
-struct hub_config
-{
-	int server_port;             /**<<< "Server port to bind to (default: 1511)" */
-	char* server_bind_addr;      /**<<< "Server bind address (default: '0.0.0.0' or '::')" */
-	int server_listen_backlog;   /**<<< "Server listen backlog (default: 50)" */
-	char* server_alt_ports;      /**<<< "Comma separated list of alternative ports to listen to (default: '')" */
-	int hub_enabled;             /**<<< "Is server enabled (default: 1)" */
-	int show_banner;             /**<<< "Show banner on connect (default: 1)" */
-	int show_banner_sys_info;    /**<<< "Show banner system information (default: 1). Has no effect unless show_banner is enabled." */
-	int max_users;               /**<<< "Maximum number of users allowed on the hub (default: 500)" */
-	int registered_users_only;   /**<<< "Allow registered users only (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* file_motd;             /**<<< "File containing the 'message of the day' (default: '' - no motd)" */
-	char* file_acl;              /**<<< "File containing user database (default: '' - no known users)" */
-	char* file_rules;            /**<<< "File containing the rules (default: '' - no rules)" */
-	char* hub_name;              /**<<< "Name of hub (default: 'My uhub hub')" */
-	char* hub_description;       /**<<< "Name of hub (default: 'no description')" */
-	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: 128K)" */
-	int max_send_buffer_soft;    /**<<< "Max send buffer before message drops, per user (default: 96K)" */
-	int low_bandwidth_mode;      /**<<< "If this is enabled, the hub will strip off elements from each user's info message to reduce bandwidth usage" */
-
-	int max_chat_history;        /**<<< "Number of chat messages kept in history (default: 20)" */
-	int max_logout_log;          /**<<< "Number of log entries for people leaving the hub. (default: 100) */
-
-	/* Limits enforced on users */
-	int limit_max_hubs_user;     /**<<< "Max concurrent hubs as a user. (0=off, default: 10)" */
-	int limit_max_hubs_reg;      /**<<< "Max concurrent hubs as registered user. (0=off, default: 10)" */
-	int limit_max_hubs_op;       /**<<< "Max concurrent hubs as operator. (0=off, default: 10)" */
-	int limit_min_hubs_user;     /**<<< "Min concurrent hubs as a user. (0=off, default: 0)" */
-	int limit_min_hubs_reg;      /**<<< "Min concurrent hubs as registered user. (0=off, default: 0)" */
-	int limit_min_hubs_op;       /**<<< "Min concurrent hubs as operator. (0=off, default: 0)" */
-	int limit_max_hubs;          /**<<< "Max total hub connections allowed, user/reg/op combined. (0=off, default: 25)" */
-	int limit_min_share;         /**<<< "Limit minimum share size in megabytes (MiB) (0=off, default: 0)" */
-	int limit_max_share;         /**<<< "Limit maximum share size in megabytes (MiB) (0=off, default: 0)" */
-	int limit_min_slots;         /**<<< "Limit minimum number of slots open per user (0=off, default: 0)" */
-	int limit_max_slots;         /**<<< "Limit maximum number of slots open per user (0=off, default: 0)" */
-
-	/* Messages that can be sent to a user */
-	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" */
-	char* msg_inf_error_nick_missing;     /**<<< "no nickname given" */
-	char* msg_inf_error_nick_multiple;    /**<<< "multiple nicknames given" */
-	char* msg_inf_error_nick_invalid;     /**<<< "generic/unkown" */
-	char* msg_inf_error_nick_long;        /**<<< "nickname too long" */
-	char* msg_inf_error_nick_short;       /**<<< "nickname too short" */
-	char* msg_inf_error_nick_spaces;      /**<<< "nickname cannot start with spaces" */
-	char* msg_inf_error_nick_bad_chars;   /**<<< "nickname contains chars below ascii 32" */
-	char* msg_inf_error_nick_not_utf8;    /**<<< "nickname is not valid utf8" */
-	char* msg_inf_error_nick_taken;       /**<<< "nickname is in use" */
-	char* msg_inf_error_nick_restricted;  /**<<< "nickname cannot be used on this hub" */
-	char* msg_inf_error_cid_invalid;      /**<<< "CID is not valid" */
-	char* msg_inf_error_cid_missing;      /**<<< "CID is not specified" */
-	char* msg_inf_error_cid_taken;        /**<<< "CID is taken" */
-	char* msg_inf_error_pid_missing;      /**<<< "PID is not specified" */
-	char* msg_inf_error_pid_invalid;      /**<<< "PID is invalid" */
-	char* msg_ban_permanently;            /**<<< "Banned permanently" */
-	char* msg_ban_temporarily;            /**<<< "Banned temporarily" */
-	char* msg_auth_invalid_password;      /**<<< "Password is wrong" */
-	char* msg_auth_user_not_found;        /**<<< "User not found in password database" */
-	char* msg_error_no_memory;            /**<<< "No memory" */
-	char* msg_user_share_size_low;        /**<<< "User is not sharing enough" */
-	char* msg_user_share_size_high;       /**<<< "User is sharing too much" */
-	char* msg_user_slots_low;             /**<<< "User have too few upload slots." */
-	char* msg_user_slots_high;            /**<<< "User have too many upload slots." */
-	char* msg_user_hub_limit_low;         /**<<< "User is on too few hubs." */
-	char* msg_user_hub_limit_high;        /**<<< "User is on too many hubs." */
-
-	int tls_enable;                      /**<<< "Enable SSL/TLS support (default: 0)" */
-	int tls_require;                     /**<<< "If SSL/TLS enabled, should it be required (default: 0) */
-	char* tls_certificate;               /**<<< "Certificate file (PEM)" */
-	char* tls_private_key;               /**<<< "Private key" */
-};
+#include "gen_config.h"
 
 /**
  * This initializes the configuration variables, and sets the default

src/core/config.pl

@@ -0,0 +1,241 @@
+#!/usr/bin/perl -w
+
+use strict;
+use XML::Twig;
+
+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 get_data($);
+
+# initialize parser and read the file
+my $input = "./config.xml";
+my $parser = XML::Twig->new();
+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"))
+{
+	write_c_header(get_data($p));
+}
+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";
+
+# The defaults function
+print GENIMPL "void config_defaults(struct hub_config* config)\n{\n";
+foreach my $p ($tree->root->children("option"))
+{
+	write_c_impl_defaults(get_data($p));
+}
+print GENIMPL "}\n\n";
+
+# 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")
+	{
+		$comment = "\"" . $default . "\"";
+	}
+	elsif (defined $short && length $short > 0)
+	{
+		$comment = $short;
+		$comment .= " (default: " . $default . ")" if (defined $default);
+	}
+
+	if (length $comment > 0)
+	{
+		my $pad = "";
+		for (my $i = length $name; $i < 32; $i++)
+		{
+			$pad .= " ";
+		}
+		$comment = $pad . "/*<<< " . $comment . " */";
+	}
+
+	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";
+
+	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";
+	}
+	elsif ($type eq "boolean")
+	{
+		print GENIMPL "\t\tif (!apply_boolean(key, data, &config->$name))\n";
+	}
+	elsif ($type =~ /(string|file|message)/)
+	{
+		print GENIMPL "\t\tif (!apply_string(key, data, &config->$name, (char*) \"\"))\n";
+	}
+
+	print GENIMPL "\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";
+}
+
+sub write_c_impl_free(@)
+{
+	my @output = @_;
+	my ($type, $name, $default, $advanced, $short, $desc, $since, $example) = @output;
+
+	if ($type =~ /(string|file|message)/)
+	{
+		print GENIMPL "\thub_free(config->" . $name . ");\n\n" 
+	}
+}
+
+sub write_c_impl_dump(@)
+{
+	my @output = @_;
+	my ($type, $name, $default, $advanced, $short, $desc, $since, $example) = @output;
+	my $out;
+	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 = "\\\"%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";
+}
+
+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);
+	return @data;
+}
+

src/core/config.xml

@@ -0,0 +1,662 @@
+<?xml version='1.0' standalone="yes" ?>
+<config>
+
+	<option name="hub_enabled" type="boolean" default="1">
+		<short>Is server enabled</short>
+		<description><![CDATA[
+			Use this to disable the hub for a while.
+		]]></description>
+		<since>0.1.3</since>
+	</option>
+
+	<option name="server_port" type="int" default="1511">
+		<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>
+	</option>
+
+	<option name="server_bind_addr" type="string" default="any">
+		<check regexp="(\d\.\d\.\d\.\d\)|(any)|(loopback)|(.*)" /><!-- FIXME: add better IPv6 regexp in the future! -->
+		<short>Server bind address</short>
+		<description><![CDATA[
+			Specify the IP address the local hub should bind to. This can be an IPv4 or IPv6 address, or one of the special addresses "any" or "loopback". <br />
+			When "any" or "loopback" is used, the hub will automatically detect if IPv6 is supported and prefer that.
+		]]></description>
+		<syntax>
+			IPv4 address, IPv6 address, "any" or "loopback"
+		</syntax>
+		<since>0.1.2</since>
+		<example><![CDATA[
+				<p>
+				To listen to a specific IP:<br />
+				server_bind_addr = "192.168.12.69"
+				</p>
+				<p>
+				To listen to any IPv4 address:<br />
+				server_bind_addr = "0.0.0.0"
+				</p>
+				<p>
+				Or to listen to any address including IPv6 (if supported):<br />
+				server_bind_addr = "any"
+				</p>
+		]]></example>
+	</option>
+
+	<option name="server_listen_backlog" type="int" default="50">
+		<check min="5" />
+		<short>Server listen backlog</short>
+		<description><![CDATA[
+			<p>
+			This specifies the number of connections the hub will be able to accept in the backlog before they must be processed by the hub.
+			</p>
+			<p>
+			A too low number here will mean the hub will not accept connections fast enough when users are reconnecting really fast. The hub should under normal circumstances be able to empty the listen backlog several times per second.
+			</p>
+		]]></description>
+		<since>0.3.0</since>
+	</option>
+
+	<option name="server_alt_ports" type="string" default="">
+		<check regexp="((\d+)(,(\d+))*)?" />
+		<short>Comma separated list of alternative ports to listen to</short>
+		<description><![CDATA[
+		In addition to the server_port the hub can listen to a list of alternative ports.
+		]]></description>
+		<example><![CDATA[
+			server_alt_ports = 1295,1512,53990
+		]]></example>
+		<since>0.3.0</since>
+	</option>
+
+	<option name="show_banner" type="boolean" default="1">
+		<short>Show banner on connect</short>
+		<description><![CDATA[
+			If enabled, the hub will announce the software version running to clients when they connect with a message like: "Powered by uhub/0.x.y"
+		]]></description>
+		<since>0.1.0</since>
+	</option>
+
+	<option name="show_banner_sys_info" type="boolean" default="1">
+		<short>Show banner on connect</short>
+		<description><![CDATA[
+			If enabled, the hub will announce the operating system and CPU architecture to clients when they join.<br />
+			This option has no effect if show_banner is disabled.
+		]]></description>
+		<since>0.3.0</since>
+	</option>
+
+	<option name="max_users" type="int" default="500">
+		<check min="1" max="1048576" />
+		<short>Maximum number of users allowed on the hub</short>
+		<description><![CDATA[
+			The maximum amount of users allowed on the hub.
+			No new users will be allowed to enter the hub if this number is exceeded, however privileged users (operators, admins, etc) are still able to log in.
+		]]></description>
+		<since>0.1.0</since>
+		<example><![CDATA[
+			To run a hub for max 25 users:<br />
+				max_users = 25
+		]]></example>
+	</option>
+
+	<option name="registered_users_only" type="boolean" default="0">
+		<short>Allow registered users only</short>
+		<description><![CDATA[
+			If this is enabled only registered users will be able to use the hub. A user must be registered in the acl file (file_acl).
+		]]></description>
+		<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[
+			If this is enabled users using old ADC clients are allowed to enter the hub,
+			however they cannot log in using passwords since the protocols are incompatible.
+		]]></description>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="chat_is_privileged" type="boolean" default="0">
+		<short>Allow chat for operators and above only</short>
+		<description><![CDATA[
+			If enabled only operators and admins are allowed to chat in the main chat.
+		]]></description>
+		<since>0.2.4</since>
+	</option>
+
+	<option name="hub_name" type="string" default="uhub">
+		<short>Name of hub</short>
+		<description><![CDATA[
+		Configures the name of the hub
+		]]></description>
+		<since>0.1.0</since>
+		<example><![CDATA[
+			hub_name = "my hub"
+		]]></example>
+	</option>
+
+	<option name="hub_description" type="string" default="no description">
+		<short>Short hub description, topic or subject.</short>
+		<description><![CDATA[
+		This is the description of the hub, as seen by users and hub lists.
+		]]></description>
+		<since>0.1.0</since>
+		<example><![CDATA[
+			hub_description = "a friendly hub for friendly people"
+		]]></example>
+	</option>
+
+	<option name="redirect_addr" type="string" default="">
+		<check regexp="(adc|adcs|dchub)://.*" />
+		<short>A common hub redirect address.</short>
+		<description><![CDATA[
+		This is the redirect address used when the hub wants to redirect a client for not fulfilling some requirements.
+		]]></description>
+		<since>0.3.2</since>
+	</option>
+
+
+	<option name="max_recv_buffer" type="int" default="4096" advanced="true" >
+		<check min="1024" max="1048576" />
+		<short>Max read buffer before parse, per user</short>
+		<description><![CDATA[
+			Maximum receive buffer allowed before commands are procesed. If a single ADC message exceeds this limit, it will be discarded by the hub. Use with caution.
+		]]></description>
+		<since>0.1.3</since>
+	</option>
+
+	<option name="max_send_buffer" type="int" default="131072" advanced="true" >
+		<check min="2048" />
+		<short>Max send buffer before disconnect, per user</short>
+		<description><![CDATA[
+			Maximum amount of bytes allowed to be queued for sending to any particular user before the hub will disconnect the user. The lower the limit, the more aggressive the hub will be to disconnect slow clients. Use with caution.
+		]]></description>
+		<since>0.1.3</since>
+	</option>
+
+	<option name="max_send_buffer_soft" type="int" default="98304" advanced="true" >
+		<check min="1024" />
+		<short>Max send buffer before message drops, per user</short>
+		<description><![CDATA[
+			Same as max_send_buffer, however low priority messages may be discarded if this limit is reached. Use with caution.
+		]]></description>
+		<since>0.1.3</since>
+	</option>
+
+	<option name="low_bandwidth_mode" type="boolean" default="0" advanced="true" >
+		<short>Enable bandwidth saving measures</short>
+		<description><![CDATA[
+			If this is enabled the hub will remove excessive information from each user's info message before broadcasting to all connected users.
+			Description, e-mail address will be removed. This saves upload bandwidth for the hub.
+		]]></description>
+		<since>0.2.2</since>
+	</option>
+
+	<option name="max_chat_history" type="int" default="20">
+		<check min="0" max="250" />
+		<short>Number of chat messages kept in history</short>
+		<description><![CDATA[
+			This specifies the number of main chat messages that are kept in the history buffer.
+			Users can use the "!history" command to list these messages.
+		]]></description>
+		<since>0.3.0</since>
+	</option>
+
+	<option name="max_logout_log" type="int" default="20">
+		<check min="0" max="2000" />
+		<short>Number of log entries for people leaving the hub</short>
+		<description><![CDATA[
+			Operators can use the "!log" command to list users who have recently left the hub.
+			This option specifies the maximum size of this log.
+		]]></description>
+		<since>0.3.0</since>
+	</option>
+
+	<option name="limit_max_hubs_user" type="int" default="10">
+		<check min="0" />
+		<short>Max concurrent hubs as a guest user</short>
+		<description><![CDATA[
+		This limits the number of hubs a user can be logged into as a guest user. If this number is exceeded, the user will not be allowed to enter the hub.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="limit_max_hubs_reg" type="int" default="10">
+		<check min="0" />
+		<short>Max concurrent hubs as a registered user</short>
+		<description><![CDATA[
+		This limits the number of hubs a user can be logged into as a registered user. If this number is exceeded, the user will not be allowed to enter the hub.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="limit_max_hubs_op" type="int" default="10">
+		<check min="0" />
+		<short>Max concurrent hubs as a operator (or admin)</short>
+		<description><![CDATA[
+		This limits the number of hubs a user can be logged into as an operator. If this number is exceeded, the user will not be allowed to enter the hub.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="limit_max_hubs" type="int" default="25">
+		<check min="0" />
+		<short>Max total hub connections allowed, user/reg/op combined.</short>
+		<description><![CDATA[
+		Limit the number of hubs a user can be logged into in total regardless of registrations or privileges.
+		If this number is exceeded, the user will not be allowed to enter the hub.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="limit_min_hubs_user" type="int" default="0">
+		<check min="0" />
+		<short>Minimum concurrent hubs as a guest user</short>
+		<description><![CDATA[
+		Only allow users that are logged into other hubs with guest privileges to enter this hub.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="limit_min_hubs_reg" type="int" default="0">
+		<check min="0" />
+		<short>Minimum concurrent hubs as a registered user</short>
+		<description><![CDATA[
+		Only allow users that are logged into other hubs as a registered user to enter this hub.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="limit_min_hubs_op" type="int" default="0">
+		<check min="0" />
+		<short>Minimum concurrent hubs as a operator (or admin)</short>
+		<description><![CDATA[
+		Only allow users that are logged into other hubs with operator privileges to enter this hub.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="limit_min_share" type="int" default="0">
+		<check min="0" />
+		<short>Limit minimum share size in megabytes</short>
+		<description><![CDATA[
+		Minimum share limit in megabytes (MiB). Users sharing less than this will not be allowed to enter the hub.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.2.0</since>
+		<example><![CDATA[
+			To require users to share at least 1 GB in order to enter the hub:<br />
+			limit_min_share = 1024
+		]]></example>
+	</option>
+
+	<option name="limit_max_share" type="int" default="0">
+		<check min="0" />
+		<short>Limit maximum share size in megabytes</short>
+		<description><![CDATA[
+		Maximum share limit in megabytes (MiB). Users sharing more than this will not be allowed to enter the hub.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.2.0</since>
+	</option>
+
+
+	<option name="limit_min_slots" type="int" default="0">
+		<check min="0" />
+		<short>Limit minimum number of upload slots open per user</short>
+		<description><![CDATA[
+		Minimum number of upload slots required. Users with less than this will not be allowed to enter the hub.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="limit_max_slots" type="int" default="0">
+		<check min="0" />
+		<short>Limit minimum number of upload slots open per user</short>
+		<description><![CDATA[
+		Maximum number of upload slots allowed. Users with more than this will not be allowed to enter the hub.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="flood_ctl_interval" type="int" default="0">
+		<check min="1" max="60" />
+		<short>Time interval in seconds for flood control check.</short>
+		<description><![CDATA[
+			This is the time interval that will be used for all flood control calculations.
+			If this is 0 then all flood control is disabled.
+		]]></description>
+		<example><![CDATA[
+			To limit maximum chat messages to 5 messages on 10 seconds: <br />
+			flood_ctl_interval = 10 <br />
+			flood_ctl_chat = 5<br />
+		]]></example>
+		<syntax>0 = off</syntax>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="flood_ctl_chat" type="int" default="0">
+		<short>Max chat messages allowed in time interval</short>
+		<description><![CDATA[
+			If this is 0 then no flood control is disabled for chat messages.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="flood_ctl_connect" type="int" default="0">
+		<short>Max connections requests allowed in time interval</short>
+		<description><![CDATA[
+			If this is 0 then no flood control is disabled for connection requests.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="flood_ctl_search" type="int" default="0">
+		<short>Max search requests allowed in time interval</short>
+		<description><![CDATA[
+			If this is 0 then no flood control is disabled for search requests.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.3.1</since>
+	</option>
+
+
+	<option name="flood_ctl_update" type="int" default="0">
+		<short>Max updates allowed in time interval</short>
+		<description><![CDATA[
+			If this is 0 then no flood control is disabled for info updates (INF messages).
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="flood_ctl_extras" type="int" default="0">
+		<short>Max extra messages allowed in time interval</short>
+		<description><![CDATA[
+			Extra messages are messages that don't fit into the category of chat, search, update or connect.
+		]]></description>
+		<syntax>0 = off</syntax>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="tls_enable" type="boolean" default="0">
+		<short>Enable SSL/TLS support</short>
+		<description><![CDATA[
+			Enables/disables TLS/SSL support. tls_certificate and tls_private_key must be set if this is enabled.
+		]]></description>
+		<since>0.3.0</since>
+	</option>
+
+	<option name="tls_require" type="boolean" default="0">
+		<short>If SSL/TLS enabled, should it be required (default: 0)</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.
+			This option has no effect unless tls_enable is enabled.
+		]]></description>
+		<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[
+			Path to a TLS/SSL certificate (PEM format).
+		]]></description>
+		<since>0.3.0</since>
+	</option>
+
+	<option name="tls_private_key" type="file" default="">
+		<short>Private key file</short>
+		<description><![CDATA[
+			Path to a TLS/SSL private key (PEM format).
+		]]></description>
+		<since>0.3.0</since>
+	</option>
+
+	<option name="file_acl" type="file" default="">
+		<short>File containing access control lists</short>
+		<description><![CDATA[
+			This is an access control list (acl) file.
+			In this file all registered users, bans, etc should be stored.
+			If the file is missing, or empty no registered users, or ban records are used.
+		]]></description>
+		<since>0.1.3</since>
+		<example><![CDATA[
+			<p>
+			Unix users: <br />
+				file_acl = "/etc/uhub/users.conf"
+			</p>
+			<p>
+			Windows users: <br />
+				file_acl = "c:\uhub\users.conf"
+			</p>
+		]]></example>
+	</option>
+
+	<option name="file_plugins" type="file" default="">
+		<short>Plugin configuration file</short>
+		<description><![CDATA[
+			Plugin configuration file.
+		]]></description>
+		<since>0.3.3</since>
+		<example><![CDATA[
+			<p>
+				file_plugins = "/etc/uhub/plugins.conf"
+			</p>
+		]]></example>
+	</option>
+
+	<option name="msg_hub_full" type="message" default="Hub is full" >
+		<description><![CDATA[This will be sent if the hub is full]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_hub_disabled" type="message" default="Hub is disabled" >
+		<description><![CDATA[This will be sent if the hub is disabled (hub_enable = off)]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_hub_registered_users_only" type="message" default="Hub is for registered users only" >
+		<description><![CDATA[This will be sent if the hub is configured to only accept registered users (registered_users_only = yes)]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_nick_missing" type="message" default="No nickname given">
+		<description><![CDATA[This is an error message that will be sent to clients that do not provide a nickname.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_nick_multiple" type="message" default="Multiple nicknames given">
+		<description><![CDATA[This is an error message that will be sent to clients that provide multiple nicknames.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_nick_invalid" type="message" default="Nickname is invalid">
+		<description><![CDATA[This is an error message that will be sent to clients that provides an invalid nickname.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_nick_long" type="message" default="Nickname too long">
+		<description><![CDATA[This is an error message that will be sent to clients that provides a too long nickname.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_nick_short" type="message" default="Nickname too short">
+		<description><![CDATA[This is an error message that will be sent to clients that provides a too short nickname.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_nick_spaces" type="message" default="Nickname cannot start with spaces">
+		<description><![CDATA[This is an error message that will be sent to clients that provides a nickname that starts with a space.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_nick_bad_chars" type="message" default="Nickname contains invalid characters">
+		<description><![CDATA[This is an error message that will be sent to clients that provides invalid characters in the nickname.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_nick_not_utf8" type="message" default="Nickname is not valid UTF-8">
+		<description><![CDATA[This is an error message that will be sent to clients that provides a nick name that is not valid UTF-8 encoded.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_nick_taken" type="message" default="Nickname is already in use">
+		<description><![CDATA[This message will be sent to clients if their provided nickname is alredy in use on the hub.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_nick_restricted" type="message" default="Nickname cannot be used on this hub">
+		<description><![CDATA[This message will be sent to clients if they provide a restricted nickname. Restricted names can be configured in the acl.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_cid_invalid" type="message" default="CID is not valid">
+		<description><![CDATA[This is an error message that will be sent to clients that provides an invalid client ID (CID)]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_cid_missing" type="message" default="CID is not specified">
+		<description><![CDATA[This is an error message that will be sent to clients that does not provide a client ID (CID)]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_cid_taken" type="message" default="CID is taken">
+		<description><![CDATA[This is an error message that will be sent to clients that provides a client ID (CID) already in use on the hub.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_pid_missing" type="message" default="PID is not specified">
+		<description><![CDATA[This is an error message that will be sent to clients that does not provide a private ID (PID)]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_inf_error_pid_invalid" type="message" default="PID is invalid">
+		<description><![CDATA[This is an error message that will be sent to clients that provides an invalid private ID (PID)]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_ban_permanently" type="message" default="Banned permanently">
+		<description><![CDATA[This message is sent to users if they are banned (see acl)]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_ban_temporarily"  type="message" default="Banned temporarily">
+		<description><![CDATA[This message is sent to users if they are banned temporarily]]></description>
+		<since>0.2.0</since>
+	</option>
+
+
+	<option name="msg_auth_invalid_password" type="message" default="Password is wrong">
+		<description><![CDATA[This message is sent to users if they provide a wrong password.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_auth_user_not_found" type="message" default="User not found in password database">
+		<description><![CDATA[This message is used if a user cannot be found in the password database.]]></description>
+		<since>0.2.0</since> <!-- FIXME? -->
+	</option>
+
+	<option name="msg_error_no_memory" type="message" default="No memory">
+		<description><![CDATA[]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_user_share_size_low" type="message" default="User is not sharing enough">
+		<description><![CDATA[This message is sent to users if they are not sharing enough.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_user_share_size_high" type="message" default="User is sharing too much">
+		<description><![CDATA[This message is sent to users if they are sharing too much.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_user_slots_low" type="message" default="User have too few upload slots.">
+		<description><![CDATA[This message is sent to users if they do not have enough upload slots.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_user_slots_high" type="message" default="User have too many upload slots.">
+		<description><![CDATA[This message is sent to users if they have too many upload slots.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_user_hub_limit_low" type="message" default="User is on too few hubs.">
+		<description><![CDATA[This message is sent to users if they are on too few other hubs.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_user_hub_limit_high" type="message" default="User is on too many hubs.">
+		<description><![CDATA[This message is sent to users if they are on too many other hubs.]]></description>
+		<since>0.2.0</since>
+	</option>
+
+	<option name="msg_user_flood_chat" type="message" default="Chat flood detected, messages are dropped.">
+		<description><![CDATA[This message is sent once to users who are flooding the chat.]]></description>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="msg_user_flood_connect" type="message" default="Connect flood detected, connection refused.">
+		<description><![CDATA[This message is sent once to users who are sending too many connect requests too fast.]]></description>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="msg_user_flood_search" type="message" default="Search flood detected, search is stopped.">
+		<description><![CDATA[This message is sent once to users who are sending too many search requests too fast.]]></description>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="msg_user_flood_update" type="message" default="Update flood detected.">
+		<description><![CDATA[This message is sent once to users who are sending too many updates too fast.]]></description>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="msg_user_flood_extras" type="message" default="Flood detected.">
+		<description><![CDATA[This message is sent once to users who are sending too many messages to the hub that neither are chat, searhes, updates nor connection requests..]]></description>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="msg_proto_no_common_hash" type="message" default="No common hash algorithm.">
+		<description><![CDATA[This message is sent if a client connects that does support ADC/1.0 but not a hash algorithm that the hub supports.]]></description>
+		<since>0.3.1</since>
+	</option>
+
+	<option name="msg_proto_obsolete_adc0" type="message" default="Client is using an obsolete ADC protocol version.">
+		<description><![CDATA[This message is sent if a client connects that does not support ADC/1.0, but rather the obsolete ADC/0.1 version.]]></description>
+		<since>0.3.1</since>
+	</option>
+
+</config>

src/core/gen_config.h

@@ -0,0 +1,87 @@
+/* THIS FILE IS AUTOGENERATED - DO NOT CHANGE IT! */
+
+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) */
+	int   server_listen_backlog;           /*<<< Server listen backlog (default: 50) */
+	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_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: ) */
+	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) */
+	int   low_bandwidth_mode;              /*<<< Enable bandwidth saving measures (default: 0) */
+	int   max_chat_history;                /*<<< Number of chat messages kept in history (default: 20) */
+	int   max_logout_log;                  /*<<< Number of log entries for people leaving the hub (default: 20) */
+	int   limit_max_hubs_user;             /*<<< Max concurrent hubs as a guest user (default: 10) */
+	int   limit_max_hubs_reg;              /*<<< Max concurrent hubs as a registered user (default: 10) */
+	int   limit_max_hubs_op;               /*<<< Max concurrent hubs as a operator (or admin) (default: 10) */
+	int   limit_max_hubs;                  /*<<< Max total hub connections allowed, user/reg/op combined. (default: 25) */
+	int   limit_min_hubs_user;             /*<<< Minimum concurrent hubs as a guest user (default: 0) */
+	int   limit_min_hubs_reg;              /*<<< Minimum concurrent hubs as a registered user (default: 0) */
+	int   limit_min_hubs_op;               /*<<< Minimum concurrent hubs as a operator (or admin) (default: 0) */
+	int   limit_min_share;                 /*<<< Limit minimum share size in megabytes (default: 0) */
+	int   limit_max_share;                 /*<<< Limit maximum share size in megabytes (default: 0) */
+	int   limit_min_slots;                 /*<<< Limit minimum number of upload slots open per user (default: 0) */
+	int   limit_max_slots;                 /*<<< Limit minimum number of upload slots open per user (default: 0) */
+	int   flood_ctl_interval;              /*<<< Time interval in seconds for flood control check. (default: 0) */
+	int   flood_ctl_chat;                  /*<<< Max chat messages allowed in time interval (default: 0) */
+	int   flood_ctl_connect;               /*<<< Max connections requests allowed in time interval (default: 0) */
+	int   flood_ctl_search;                /*<<< Max search requests allowed in time interval (default: 0) */
+	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_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" */
+	char* msg_inf_error_nick_missing;      /*<<< "No nickname given" */
+	char* msg_inf_error_nick_multiple;     /*<<< "Multiple nicknames given" */
+	char* msg_inf_error_nick_invalid;      /*<<< "Nickname is invalid" */
+	char* msg_inf_error_nick_long;         /*<<< "Nickname too long" */
+	char* msg_inf_error_nick_short;        /*<<< "Nickname too short" */
+	char* msg_inf_error_nick_spaces;       /*<<< "Nickname cannot start with spaces" */
+	char* msg_inf_error_nick_bad_chars;    /*<<< "Nickname contains invalid characters" */
+	char* msg_inf_error_nick_not_utf8;     /*<<< "Nickname is not valid UTF-8" */
+	char* msg_inf_error_nick_taken;        /*<<< "Nickname is already in use" */
+	char* msg_inf_error_nick_restricted;   /*<<< "Nickname cannot be used on this hub" */
+	char* msg_inf_error_cid_invalid;       /*<<< "CID is not valid" */
+	char* msg_inf_error_cid_missing;       /*<<< "CID is not specified" */
+	char* msg_inf_error_cid_taken;         /*<<< "CID is taken" */
+	char* msg_inf_error_pid_missing;       /*<<< "PID is not specified" */
+	char* msg_inf_error_pid_invalid;       /*<<< "PID is invalid" */
+	char* msg_ban_permanently;             /*<<< "Banned permanently" */
+	char* msg_ban_temporarily;             /*<<< "Banned temporarily" */
+	char* msg_auth_invalid_password;       /*<<< "Password is wrong" */
+	char* msg_auth_user_not_found;         /*<<< "User not found in password database" */
+	char* msg_error_no_memory;             /*<<< "No memory" */
+	char* msg_user_share_size_low;         /*<<< "User is not sharing enough" */
+	char* msg_user_share_size_high;        /*<<< "User is sharing too much" */
+	char* msg_user_slots_low;              /*<<< "User have too few upload slots." */
+	char* msg_user_slots_high;             /*<<< "User have too many upload slots." */
+	char* msg_user_hub_limit_low;          /*<<< "User is on too few hubs." */
+	char* msg_user_hub_limit_high;         /*<<< "User is on too many hubs." */
+	char* msg_user_flood_chat;             /*<<< "Chat flood detected, messages are dropped." */
+	char* msg_user_flood_connect;          /*<<< "Connect flood detected, connection refused." */
+	char* msg_user_flood_search;           /*<<< "Search flood detected, search is stopped." */
+	char* msg_user_flood_update;           /*<<< "Update flood detected." */
+	char* msg_user_flood_extras;           /*<<< "Flood detected." */
+	char* msg_proto_no_common_hash;        /*<<< "No common hash algorithm." */
+	char* msg_proto_obsolete_adc0;         /*<<< "Client is using an obsolete ADC protocol version." */
+};
+

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-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
@@ -21,6 +21,28 @@
 
 struct hub_info* g_hub = 0;
 
+/* FIXME: Flood control should be done in a plugin! */
+#define CHECK_FLOOD(TYPE, WARN) \
+	if (flood_control_check(&u->flood_ ## TYPE , hub->config->flood_ctl_  ## TYPE, hub->config->flood_ctl_interval, net_get_time())) \
+	{ \
+		if (WARN) \
+		{ \
+			hub_send_flood_warning(hub, u, hub->config->msg_user_flood_ ## TYPE); \
+		} \
+		break; \
+	}
+
+#define ROUTE_MSG \
+	if (user_is_logged_in(u)) \
+	{ \
+		ret = route_message(hub, u, cmd); \
+	} \
+	else \
+	{ \
+		ret = -1; \
+	} \
+	break;
+
 int hub_handle_message(struct hub_info* hub, struct hub_user* u, const char* line, size_t length)
 {
 	int ret = 0;
@@ -36,20 +58,33 @@ int hub_handle_message(struct hub_info* hub, struct hub_user* u, const char* lin
 	{
 		switch (cmd->cmd)
 		{
-			case ADC_CMD_HSUP: ret = hub_handle_support(hub, u, cmd); break;
-			case ADC_CMD_HPAS: ret = hub_handle_password(hub, u, cmd); break;
-			case ADC_CMD_BINF: ret = hub_handle_info(hub, u, cmd); break;
+			case ADC_CMD_HSUP:
+				CHECK_FLOOD(extras, 0);
+				ret = hub_handle_support(hub, u, cmd);
+				break;
+
+			case ADC_CMD_HPAS:
+				CHECK_FLOOD(extras, 0);
+				ret = hub_handle_password(hub, u, cmd);
+				break;
+
+			case ADC_CMD_BINF:
+				CHECK_FLOOD(update, 1);
+				ret = hub_handle_info(hub, u, cmd);
+				break;
+
 			case ADC_CMD_DINF:
 			case ADC_CMD_EINF:
 			case ADC_CMD_FINF:
-				/* these must never be allowed for security reasons,
-				   so we ignore them. */
+				/* these must never be allowed for security reasons, so we ignore them. */
+				CHECK_FLOOD(extras, 1);
 				break;
 
 			case ADC_CMD_EMSG:
 			case ADC_CMD_DMSG:
 			case ADC_CMD_BMSG:
 			case ADC_CMD_FMSG:
+				CHECK_FLOOD(chat, 1);
 				ret = hub_handle_chat_message(hub, u, cmd);
 				break;
 
@@ -57,26 +92,42 @@ int hub_handle_message(struct hub_info* hub, struct hub_user* u, const char* lin
 			case ADC_CMD_DSCH:
 			case ADC_CMD_ESCH:
 			case ADC_CMD_FSCH:
+				cmd->priority = -1;
+				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;
+				if (plugin_handle_search_result(hub, u, uman_get_user_by_sid(hub, cmd->target), cmd->cache) == st_deny)
+					break;
+				/* CHECK_FLOOD(search, 0); */
+				ROUTE_MSG;
+
 			case ADC_CMD_DRCM:
+				cmd->priority = -1;
+				if (plugin_handle_revconnect(hub, u, uman_get_user_by_sid(hub, cmd->target)) == st_deny)
+					break;
+				CHECK_FLOOD(connect, 1);
+				ROUTE_MSG;
+
 			case ADC_CMD_DCTM:
 				cmd->priority = -1;
-				if (hub->config->chat_only && u->credentials < cred_operator)
-				{
-					/* These below aren't allowed in chat only hubs */
+				if (plugin_handle_connect(hub, u, uman_get_user_by_sid(hub, cmd->target)) == st_deny)
 					break;
-				}
+				CHECK_FLOOD(connect, 1);
+				ROUTE_MSG;
 
 			default:
-				if (user_is_logged_in(u))
-				{
-					ret = route_message(hub, u, cmd);
-				}
-				else
-				{
-					ret = -1;
-				}
-				break;
+				CHECK_FLOOD(extras, 1);
+				ROUTE_MSG;
 		}
 		adc_msg_free(cmd);
 	}
@@ -137,17 +188,51 @@ int hub_handle_support(struct hub_info* hub, struct hub_user* u, struct adc_mess
 	if (u->state == state_protocol)
 	{
 		if (index == 0) ok = 0; /* Need to support *SOMETHING*, at least BASE */
+		if (!ok)
+		{
+			/* disconnect user. Do not send crap during initial handshake! */
+			hub_disconnect_user(hub, u, quit_logon_error);
+			return -1;
+		}
 
-		if (ok)
+		if (user_flag_get(u, feature_base))
+		{
+			/* User supports ADC/1.0 and a hash we know */
+			if (user_flag_get(u, feature_tiger))
 			{
 				hub_send_handshake(hub, u);
 				net_con_set_timeout(u->connection, TIMEOUT_HANDSHAKE);
 			}
 			else
 			{
-			/* disconnect user. Do not send crap during initial handshake! */
+				// no common hash algorithm.
+				hub_send_status(hub, u, status_msg_proto_no_common_hash, status_level_fatal);
+				hub_disconnect_user(hub, u, quit_protocol_error);
+			}
+		}
+		else if (user_flag_get(u, feature_bas0))
+		{
+			if (hub->config->obsolete_clients)
+			{
+				hub_send_handshake(hub, u);
+				net_con_set_timeout(u->connection, TIMEOUT_HANDSHAKE);
+			}
+			else
+			{
+				/* disconnect user for using an obsolete client. */
+				char* tmp = adc_msg_escape(hub->config->msg_proto_obsolete_adc0);
+				struct adc_message* message = adc_msg_construct(ADC_CMD_IMSG, 6 + strlen(tmp));
+				adc_msg_add_argument(message, tmp);
+				hub_free(tmp);
+				route_to_user(hub, u, message);
+				adc_msg_free(message);
+				hub_disconnect_user(hub, u, quit_protocol_error);
+			}
+		}
+		else
+		{
+			/* Not speaking a compatible protocol - just disconnect. */
 			hub_disconnect_user(hub, u, quit_logon_error);
-			ret = -1;
 		}
 	}
 
@@ -162,7 +247,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);
 		}
@@ -181,14 +266,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 || !user_is_logged_in(u))
+	if (!message)
 		return 0;
 
-	if ((cmd->cache[0] == 'B') && (message[0] == '!' || message[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;
+	}
+
+	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.
@@ -203,48 +309,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, 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))
@@ -286,6 +394,7 @@ 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))
 	{
@@ -299,13 +408,13 @@ 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);
@@ -362,39 +471,57 @@ 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);
 }
 
+void hub_send_flood_warning(struct hub_info* hub, struct hub_user* u, const char* message)
+{
+	struct adc_message* msg;
+	char* tmp;
+
+	if (user_flag_get(u, flag_flood))
+		return;
+
+	msg = adc_msg_construct(ADC_CMD_ISTA, 128);
+	if (msg)
+	{
+		tmp = adc_msg_escape(message);
+		adc_msg_add_argument(msg, "110");
+		adc_msg_add_argument(msg, tmp);
+		hub_free(tmp);
+
+		route_to_user(hub, u, msg);
+		user_flag_set(u, flag_flood);
+		adc_msg_free(msg);
+	}
+}
+
+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, user->id.nick);
+	if (lookup1)
+		return status_msg_inf_error_nick_taken;
+
+	lookup2 = uman_get_user_by_cid(hub,  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);
@@ -411,9 +538,19 @@ static void hub_event_dispatcher(void* callback_data, struct event_data* message
 				hub_send_password_challenge(hub, user);
 			}
 			else
+			{
+				/* 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;
 		}
 
@@ -552,7 +689,46 @@ static void server_alt_port_stop(struct hub_info* hub)
 	}
 }
 
+#ifdef SSL_SUPPORT
+static int load_ssl_certificates(struct hub_info* hub, struct hub_config* config)
+{
+	if (config->tls_enable)
+	{
+		hub->ssl_method = (SSL_METHOD*) SSLv23_method(); /* TLSv1_method() */
+		hub->ssl_ctx = SSL_CTX_new(hub->ssl_method);
 
+		/* Disable SSLv2 */
+		SSL_CTX_set_options(hub->ssl_ctx, SSL_OP_NO_SSLv2);
+		SSL_CTX_set_quiet_shutdown(hub->ssl_ctx, 1);
+
+		if (SSL_CTX_use_certificate_file(hub->ssl_ctx, config->tls_certificate, SSL_FILETYPE_PEM) < 0)
+		{
+			LOG_ERROR("SSL_CTX_use_certificate_file: %s", ERR_error_string(ERR_get_error(), NULL));
+		}
+
+		if (SSL_CTX_use_PrivateKey_file(hub->ssl_ctx, config->tls_private_key, SSL_FILETYPE_PEM) < 0)
+		{
+			LOG_ERROR("SSL_CTX_use_PrivateKey_file: %s", ERR_error_string(ERR_get_error(), NULL));
+		}
+
+		if (SSL_CTX_check_private_key(hub->ssl_ctx) != 1)
+		{
+			LOG_FATAL("SSL_CTX_check_private_key: Private key does not match the certificate public key: %s", ERR_error_string(ERR_get_error(), NULL));
+			return 0;
+		}
+		LOG_INFO("Enabling TLS, using certificate: %s, private key: %s", config->tls_certificate, config->tls_private_key);
+	}
+	return 1;
+}
+
+static void unload_ssl_certificates(struct hub_info* hub)
+{
+	if (hub->ssl_ctx)
+	{
+		SSL_CTX_free(hub->ssl_ctx);
+	}
+}
+#endif
 
 struct hub_info* hub_start_service(struct hub_config* config)
 {
@@ -583,31 +759,11 @@ struct hub_info* hub_start_service(struct hub_config* config)
 	LOG_INFO("Starting " PRODUCT "/" VERSION ", listening on %s:%d...", net_get_local_address(hub->server->sd), config->server_port);
 
 #ifdef SSL_SUPPORT
-	if (config->tls_enable)
+	if (!load_ssl_certificates(hub, config))
 	{
-		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)
-		{
-			LOG_ERROR("SSL_CTX_use_certificate_file: %s", ERR_error_string(ERR_get_error(), NULL));
-		}
-
-		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));
+		hub_free(hub);
 		return 0;
 	}
-		LOG_INFO("Enabling TLS, using certificate: %s, private key: %s", config->tls_certificate, config->tls_private_key);
-	}
 #endif
 
 	hub->config = config;
@@ -640,25 +796,15 @@ struct hub_info* hub_start_service(struct hub_config* config)
 		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;
+
+	// Start the hub command sub-system
+	hub->commands = command_initialize(hub);
 	return hub;
 }
 
@@ -667,27 +813,55 @@ void hub_shutdown_service(struct hub_info* hub)
 {
 	LOG_DEBUG("hub_shutdown_service()");
 
+#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);
 	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 */
 
@@ -707,39 +881,6 @@ void hub_set_variables(struct hub_info* hub, struct acl_handle* acl)
 		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)
 	{
@@ -758,6 +899,12 @@ void hub_set_variables(struct hub_info* hub, struct acl_handle* acl)
 		hub_free(tmp);
 	}
 
+	if (hub_plugins_load(hub) < 0)
+	{
+		hub->status = hub_status_shutdown;
+	}
+	else
+
 	hub->status = (hub->config->hub_enabled ? hub_status_running : hub_status_disabled);
 	hub_free(server);
 }
@@ -765,49 +912,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);
@@ -826,48 +937,56 @@ void hub_send_status(struct hub_info* hub, struct hub_user* user, enum status_me
 {
 	struct hub_config* cfg = hub->config;
 	struct adc_message* cmd = adc_msg_construct(ADC_CMD_ISTA, 6);
-	struct adc_message* qui = adc_msg_construct(ADC_CMD_IQUI, 256);
+	struct adc_message* qui = adc_msg_construct(ADC_CMD_IQUI, 512);
 	char code[4];
-	char buf[250];
+	char buf[256];
 	const char* text = 0;
 	const char* flag = 0;
 	char* escaped_text = 0;
 	int reconnect_time = 0;
+	int redirect = 0;
 
-	if (!cmd) return;
+	if (!cmd || !qui)
+	{
+		adc_msg_free(cmd);
+		adc_msg_free(qui);
+		return;
+	}
 
-#define STATUS(CODE, MSG, FLAG, RCONTIME) case status_ ## MSG : set_status_code(level, CODE, code); text = cfg->MSG; flag = FLAG; reconnect_time = RCONTIME; break
+#define STATUS(CODE, MSG, FLAG, RCONTIME, REDIRECT) case status_ ## MSG : set_status_code(level, CODE, code); text = cfg->MSG; flag = FLAG; reconnect_time = RCONTIME; redirect = REDIRECT; break
 	switch (msg)
 	{
-		STATUS(11, msg_hub_full, 0, 600); /* FIXME: Proper timeout? */
-		STATUS(12, msg_hub_disabled, 0, -1);
-		STATUS(26, msg_hub_registered_users_only, 0, 0);
-		STATUS(43, msg_inf_error_nick_missing, 0, 0);
-		STATUS(43, msg_inf_error_nick_multiple, 0, 0);
-		STATUS(21, msg_inf_error_nick_invalid, 0, 0);
-		STATUS(21, msg_inf_error_nick_long, 0, 0);
-		STATUS(21, msg_inf_error_nick_short, 0, 0);
-		STATUS(21, msg_inf_error_nick_spaces, 0, 0);
-		STATUS(21, msg_inf_error_nick_bad_chars, 0, 0);
-		STATUS(21, msg_inf_error_nick_not_utf8, 0, 0);
-		STATUS(22, msg_inf_error_nick_taken, 0, 0);
-		STATUS(21, msg_inf_error_nick_restricted, 0, 0);
-		STATUS(43, msg_inf_error_cid_invalid, "FBID", 0);
-		STATUS(43, msg_inf_error_cid_missing, "FMID", 0);
-		STATUS(24, msg_inf_error_cid_taken, 0, 0);
-		STATUS(43, msg_inf_error_pid_missing, "FMPD", 0);
-		STATUS(27, msg_inf_error_pid_invalid, "FBPD", 0);
-		STATUS(31, msg_ban_permanently, 0, 0);
-		STATUS(32, msg_ban_temporarily, "TL600", 600); /* FIXME: Proper timeout? */
-		STATUS(23, msg_auth_invalid_password, 0, 0);
-		STATUS(20, msg_auth_user_not_found, 0, 0);
-		STATUS(30, msg_error_no_memory, 0, 0);
-		STATUS(43, msg_user_share_size_low,   "FB" ADC_INF_FLAG_SHARED_SIZE, 0);
-		STATUS(43, msg_user_share_size_high,  "FB" ADC_INF_FLAG_SHARED_SIZE, 0);
-		STATUS(43, msg_user_slots_low,        "FB" ADC_INF_FLAG_UPLOAD_SLOTS, 0);
-		STATUS(43, msg_user_slots_high,       "FB" ADC_INF_FLAG_UPLOAD_SLOTS, 0);
-		STATUS(43, msg_user_hub_limit_low, 0, 0);
-		STATUS(43, msg_user_hub_limit_high, 0, 0);
+		STATUS(11, msg_hub_full, 0, 600, 1); /* FIXME: Proper timeout? */
+		STATUS(12, msg_hub_disabled, 0, -1, 1);
+		STATUS(26, msg_hub_registered_users_only, 0, 0, 1);
+		STATUS(43, msg_inf_error_nick_missing, 0, 0, 0);
+		STATUS(43, msg_inf_error_nick_multiple, 0, 0, 0);
+		STATUS(21, msg_inf_error_nick_invalid, 0, 0, 0);
+		STATUS(21, msg_inf_error_nick_long, 0, 0, 0);
+		STATUS(21, msg_inf_error_nick_short, 0, 0, 0);
+		STATUS(21, msg_inf_error_nick_spaces, 0, 0, 0);
+		STATUS(21, msg_inf_error_nick_bad_chars, 0, 0, 0);
+		STATUS(21, msg_inf_error_nick_not_utf8, 0, 0, 0);
+		STATUS(22, msg_inf_error_nick_taken, 0, 0, 0);
+		STATUS(21, msg_inf_error_nick_restricted, 0, 0, 0);
+		STATUS(43, msg_inf_error_cid_invalid, "FBID", 0, 0);
+		STATUS(43, msg_inf_error_cid_missing, "FMID", 0, 0);
+		STATUS(24, msg_inf_error_cid_taken, 0, 0, 0);
+		STATUS(43, msg_inf_error_pid_missing, "FMPD", 0, 0);
+		STATUS(27, msg_inf_error_pid_invalid, "FBPD", 0, 0);
+		STATUS(31, msg_ban_permanently, 0, 0, 0);
+		STATUS(32, msg_ban_temporarily, "TL600", 600, 0); /* FIXME: Proper timeout? */
+		STATUS(23, msg_auth_invalid_password, 0, 0, 0);
+		STATUS(20, msg_auth_user_not_found, 0, 0, 0);
+		STATUS(30, msg_error_no_memory, 0, 0, 0);
+		STATUS(43, msg_user_share_size_low,   "FB" ADC_INF_FLAG_SHARED_SIZE, 0, 1);
+		STATUS(43, msg_user_share_size_high,  "FB" ADC_INF_FLAG_SHARED_SIZE, 0, 1);
+		STATUS(43, msg_user_slots_low,        "FB" ADC_INF_FLAG_UPLOAD_SLOTS, 0, 1);
+		STATUS(43, msg_user_slots_high,       "FB" ADC_INF_FLAG_UPLOAD_SLOTS, 0, 1);
+		STATUS(43, msg_user_hub_limit_low, 0, 0, 1);
+		STATUS(43, msg_user_hub_limit_high, 0, 0, 1);
+		STATUS(47, msg_proto_no_common_hash, 0, -1, 1);
+		STATUS(40, msg_proto_obsolete_adc0, 0, -1, 1);
 	}
 #undef STATUS
 
@@ -885,15 +1004,23 @@ 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(cmd, buf);
+		adc_msg_add_argument(qui, buf);
 
 		if (reconnect_time != 0)
 		{
 			snprintf(buf, 10, "TL%d", reconnect_time);
-			adc_msg_add_argument(cmd, buf);
+			adc_msg_add_argument(qui, buf);
 		}
-		route_to_user(hub, user, cmd);
+
+		if (redirect && *hub->config->redirect_addr)
+		{
+			snprintf(buf, 255, "RD%s", hub->config->redirect_addr);
+			adc_msg_add_argument(qui, buf);
+		}
+		route_to_user(hub, user, qui);
 	}
 
 	hub_free(escaped_text);
@@ -936,6 +1063,8 @@ const char* hub_get_status_message(struct hub_info* hub, enum status_message msg
 		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";
@@ -975,6 +1104,8 @@ const char* hub_get_status_message_log(struct hub_info* hub, enum status_message
 		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";
@@ -1003,12 +1134,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)
@@ -1141,8 +1276,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-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
@@ -53,6 +53,10 @@ enum status_message
 	status_msg_user_hub_limit_low        = -44, /* Use is on too few hubs. */
 	status_msg_user_hub_limit_high       = -45, /* Use is on too many hubs. */
 
+	status_msg_proto_no_common_hash      = -50, /* No common hash algorithms */
+	status_msg_proto_obsolete_adc0       = -51, /* Client is using an obsolete protocol version */
+	
+
 };
 
 
@@ -99,17 +103,17 @@ 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;
@@ -146,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.
@@ -198,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
@@ -223,6 +204,11 @@ extern void hub_send_password_challenge(struct hub_info* hub, struct hub_user* u
  */
 extern void hub_send_status(struct hub_info*, struct hub_user* user, enum status_message msg, enum msg_status_level level);
 
+/**
+ * Warn user about flooding.
+ */
+extern void hub_send_flood_warning(struct hub_info*, struct hub_user* user, const char* message);
+
 /**
  * Allocates memory, initializes the hub based on the configuration,
  * and returns a hub handle.

src/core/hubevent.c

@@ -18,42 +18,9 @@
  */
 
 #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 */
@@ -64,20 +31,11 @@ void on_login_success(struct hub_info* hub, struct hub_user* u)
 	user_set_state(u, state_normal);
 	uman_add(hub, u);
 
-	/* Print log message */
-	log_user_login(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/hubio.c

@@ -126,6 +126,7 @@ void hub_sendq_add(struct hub_sendq* q, struct adc_message* msg_)
 #ifdef DEBUG_SENDQ
 	debug_msg("hub_sendq_add", msg);
 #endif
+	assert(msg->cache && *msg->cache);
 	list_append(q->queue, msg);
 	q->size += msg->length;
 }
@@ -146,7 +147,7 @@ int hub_sendq_send(struct hub_sendq* q, struct hub_user* user)
 	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);
 
 	if (ret > 0)

src/core/inf.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
@@ -378,7 +378,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 +429,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 +446,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 +456,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 +466,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 +476,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 +535,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 +592,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;
 	}
@@ -674,7 +675,6 @@ int hub_handle_info_login(struct hub_info* hub, struct hub_user* user, struct ad
 	/* Private ID must never be broadcasted - drop it! */
 	adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_PRIVATE_ID);
 
-	
 	code = set_credentials(hub, user, cmd);
 
 	/* Note: this must be done *after* set_credentials. */
@@ -798,3 +798,5 @@ int hub_handle_info(struct hub_info* hub, struct hub_user* user, const struct ad
 
 	return 0;
 }
+
+

src/core/inf.h

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

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)

src/core/netevent.c

@@ -24,41 +24,16 @@
 /* FIXME: This should not be needed! */
 extern struct hub_info* g_hub;
 
-#ifdef DEBUG_SENDQ
-void debug_sendq_send(struct hub_user* user, int sent, int total)
-{
-	LOG_DUMP("SEND: sd=%d, %d/%d bytes\n", user->connection->sd, sent, total);
-	if (sent == -1)
-	{
-		int err = net_error();
-		LOG_DUMP("    errno: %d - %s\n", err, net_error_string(err));
-	}
-}
-
-void debug_sendq_recv(struct hub_user* user, int received, int max, const char* buffer)
-{
-	LOG_DUMP("RECV: %d/%d bytes\n", received, (int) max);
-	if (received == -1)
-	{
-		int err = net_error();
-		LOG_DUMP("    errno: %d - %s\n", err, net_error_string(err));
-	}
-	else if (received > 0)
-	{
-		char* data = hub_malloc_zero(received + 1);
-		memcpy(data, buffer, received);
-		LOG_DUMP("RECV: \"%s\"\n", data);
-		hub_free(data);
-	}
-}
-#endif
-
 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);
-	ssize_t size = net_con_recv(user->connection, buf, MAX_RECV_BUF);
+	ssize_t size;
+
+	if (user_flag_get(user, flag_maxbuf))
+		buf_size = 0;
+	size = net_con_recv(user->connection, buf + buf_size, MAX_RECV_BUF - buf_size);
 
 	if (size > 0)
 		buf_size += size;
@@ -113,7 +88,7 @@ int handle_net_read(struct hub_user* user)
 
 		if (lastPos || remaining)
 		{
-			if (remaining < g_hub->config->max_recv_buffer)
+			if (remaining < (size_t) g_hub->config->max_recv_buffer)
 			{
 				hub_recvq_set(q, lastPos ? lastPos : buf, remaining);
 			}
@@ -200,15 +175,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;
 			}
@@ -219,24 +198,21 @@ 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);
-			net_con_close(con);
+			plugin_log_connection_denied(hub, &ipaddr);
+			net_close(fd);
 			continue;
 		}
 
+		plugin_log_connection_accepted(hub, &ipaddr);
+
 		probe = probe_create(hub, fd, &ipaddr);
 		if (!probe)
 		{
 			LOG_ERROR("Unable to create probe after socket accepted. Out of memory?");
-			net_con_close(con);
+			net_close(fd);
 			break;
 		}
 	}

src/core/plugincallback.c

@@ -0,0 +1,162 @@
+/*
+ * 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)
+{
+	struct plugin_callback_data* data;
+	uhub_assert(plugin && plugin->handle && plugin->handle->internals);
+	data = (struct plugin_callback_data*) plugin->handle->internals;
+	return 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;
+}
+
+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_callback_data* data)
+{
+	LOG_PLUGIN("plugin_callback_data_destroy()");
+	if (data->commands)
+	{
+		uhub_assert(list_size(data->commands) == 0);
+		list_destroy(data->commands);
+	}
+
+	hub_free(data);
+}
+
+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)
+{
+//	struct plugin_callback_data* data = get_callback_data(plugin);
+	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)
+{
+//	struct plugin_callback_data* data = get_callback_data(plugin);
+	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)
+{
+	// struct plugin_callback_data* data = get_callback_data(plugin);
+	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;
+}
+
+
+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;
+}
+
+void plugin_unregister_callback_functions(struct plugin_handle* handle)
+{
+}

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_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,197 @@
+/*
+ * 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, login_check_ip_early, addr);
+}
+
+plugin_st plugin_check_ip_late(struct hub_info* hub, struct ip_addr_encap* addr)
+{
+	PLUGIN_INVOKE_STATUS_1(hub, login_check_ip_late, 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 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,258 @@
+/*
+ * 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
+{
+	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 */
+};
+
+static struct plugin_hub_internals* get_internals(struct plugin_handle* handle)
+{
+	struct plugin_hub_internals* internals;
+	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(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);
+	plugin_unregister_callback_functions(plugin);
+	internals->unregister(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,60 @@
+/*
+ * 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 uhub_plugins
+{
+	struct linked_list* loaded;
+};
+
+// High level plugin loader ode
+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
+extern struct hub_info* plugin_get_hub(struct plugin_handle*);
+
+#endif /* HAVE_UHUB_PLUGIN_LOADER_H */
+

src/core/probe.c

@@ -46,6 +46,24 @@ static void probe_net_event(struct net_connection* con, int events, void *arg)
 			if (memcmp(probe_recvbuf, "HSUP", 4) == 0)
 			{
 				LOG_TRACE("Probed ADC");
+#ifdef SSL_SUPPORT
+				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
 				if (user_create(probe->hub, probe->connection, &probe->addr))
 				{
 					probe->connection = 0;
@@ -53,9 +71,8 @@ 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 */
@@ -75,15 +92,10 @@ static void probe_net_event(struct net_connection* con, int events, void *arg)
 				{
 					LOG_TRACE("Probed TLS %d.%d connection. TLS disabled in hub.", (int) probe_recvbuf[1], (int) probe_recvbuf[2]);
 				}
-				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]);
 			}
 #endif
 			probe_destroy(probe);
@@ -99,6 +111,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);
@@ -110,6 +124,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

@@ -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,6 +106,8 @@ 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);
+
 	if (hub_sendq_is_empty(user->send_queue) && !user_flag_get(user, flag_pipeline))
 	{
 		/* Perform oportunistic write */

src/core/user.c

@@ -54,6 +54,12 @@ struct hub_user* user_create(struct hub_info* hub, struct net_connection* con, s
 
 	memcpy(&user->id.addr, addr, sizeof(struct ip_addr_encap));
 	user_set_state(user, state_protocol);
+
+	flood_control_reset(&user->flood_chat);
+	flood_control_reset(&user->flood_connect);
+	flood_control_reset(&user->flood_search);
+	flood_control_reset(&user->flood_update);
+	flood_control_reset(&user->flood_extras);
 	return user;
 }
 
@@ -65,6 +71,12 @@ void user_destroy(struct hub_user* user)
 	hub_recvq_destroy(user->recv_queue);
 	hub_sendq_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);
 	hub_free(user);
@@ -83,7 +95,14 @@ void user_set_state(struct hub_user* user, enum user_state state)
 void user_set_info(struct hub_user* user, struct adc_message* cmd)
 {
 	adc_msg_free(user->info);
+	if (cmd)
+	{
 		user->info = adc_msg_incref(cmd);
+	}
+	else
+	{
+		user->info = 0;
+	}
 }
 
 void user_update_info(struct hub_user* u, struct adc_message* cmd)
@@ -127,10 +146,9 @@ static int convert_support_fourcc(int fourcc)
 {
 	switch (fourcc)
 	{
-		case FOURCC('B','A','S','0'): /* Obsolete */
-#ifndef OLD_ADC_SUPPORT
-			return 0;
-#endif
+		case FOURCC('B','A','S','0'):
+			return feature_bas0;
+
 		case FOURCC('B','A','S','E'):
 			return feature_base;
 
@@ -163,6 +181,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;
@@ -276,18 +298,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);
 }
 
 /**
@@ -297,19 +308,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

@@ -22,6 +22,7 @@
 
 struct hub_info;
 struct hub_iobuf;
+struct flood_control;
 
 enum user_state
 {
@@ -45,6 +46,8 @@ enum user_flags
 	feature_ping    = 0x00000080, /** PING: Hub pinger information extension */
 	feature_link    = 0x00000100, /** LINK: Hub link (not supported) */
 	feature_adcs    = 0x00000200, /** ADCS: ADC over TLS/SSL */
+	feature_bas0    = 0x00000400, /** BAS0: Obsolete pre-ADC/1.0 protocol version */
+	flag_flood      = 0x00400000, /** User has been notified about flooding. */
 	flag_muted      = 0x00800000, /** User is muted (cannot chat) */
 	flag_ignore     = 0x01000000, /** Ignore further reads */
 	flag_maxbuf     = 0x02000000, /** Hit max buf read, ignore msg */
@@ -79,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 */
 };
 
@@ -102,11 +106,10 @@ 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 */
+	enum auth_credentials   credentials;        /** see enum user_credentials */
+	enum user_state         state;              /** see enum user_state */
 	uint32_t                flags;              /** see enum user_features */
-	char                    user_agent[MAX_UA_LEN+1];/** User agent string */
 	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 */
@@ -116,6 +119,11 @@ struct hub_user
 	struct hub_user_limits  limits;             /** Data used for limitation */
 	enum user_quit_reason   quit_reason;        /** Quit reason (see user_quit_reason) */
 
+	struct flood_control   flood_chat;
+	struct flood_control   flood_connect;
+	struct flood_control   flood_search;
+	struct flood_control   flood_update;
+	struct flood_control   flood_extras;
 };
 
 

src/core/usermanager.c

@@ -33,7 +33,7 @@ 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);
 	}
 }
@@ -248,7 +248,6 @@ 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)
 {
 	struct adc_message* command = adc_msg_construct(ADC_CMD_IQUI, 6);
@@ -262,7 +261,6 @@ 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 sid = sid_alloc(hub->users->sids, user);

src/network/backend.c

@@ -72,18 +72,15 @@ 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);
-	timeout_queue_initialize(&g_backend->timeout_queue, g_backend->now, 600); /* FIXME: max 600 secs! */
+	timeout_queue_initialize(&g_backend->timeout_queue, g_backend->now, 120); /* FIXME: max 120 secs! */
 	g_backend->cleaner = net_cleanup_initialize(g_backend->common.max);
 
-	for (n = 0; n < sizeof(net_backend_init_funcs); n++)
+	for (n = 0; net_backend_init_funcs[n]; n++)
 	{
-		if (!net_backend_init_funcs[n])
-			break;
-
 		g_backend->data = net_backend_init_funcs[n](&g_backend->handler, &g_backend->common);
 		if (g_backend->data)
 		{
@@ -155,6 +152,12 @@ int net_backend_process()
 	return 1;
 }
 
+time_t net_get_time()
+{
+	return g_backend->now;
+}
+
+
 void net_con_initialize(struct net_connection* con, int sd, net_connection_cb callback, const void* ptr, int events)
 {
 	g_backend->handler.con_init(g_backend->data, con, sd, callback, ptr);
@@ -176,6 +179,14 @@ void net_con_close(struct net_connection* con)
 
 	g_backend->handler.con_del(g_backend->data, con);
 
+#ifdef SSL_SUPPORT
+	if (con->ssl)
+	{
+		SSL_shutdown(con->ssl);
+		SSL_clear(con->ssl);
+	}
+#endif
+
 	net_close(con->sd);
 	con->sd = -1;
 
@@ -193,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);
 }
@@ -210,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

@@ -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
 {
@@ -75,6 +75,11 @@ extern void net_backend_shutdown();
  */
 extern int net_backend_process();
 
+/**
+ * Get the current time.
+ */
+time_t net_get_time();
+
 extern struct timeout_queue* net_backend_get_timeout_queue();
 
 struct net_cleanup_handler* net_cleanup_initialize(size_t max);

src/network/connection.c

@@ -70,7 +70,6 @@ static int handle_openssl_error(struct net_connection* con, int ret)
 			con->ssl_state = tls_st_error;
 			return -1;
 	}
-
 	return -1;
 }
 
@@ -123,6 +122,11 @@ ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode
 	if (ssl_mode == net_con_ssl_mode_server)
 	{
 		ssl = SSL_new(ssl_ctx);
+		if (!ssl)
+		{
+			LOG_ERROR("Unable to create new SSL stream\n");
+			return -1;
+		}
 		SSL_set_fd(ssl, con->sd);
 		net_con_set_ssl(con, ssl);
 		return net_con_ssl_accept(con);
@@ -137,6 +141,10 @@ ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode
 }
 #endif /* SSL_SUPPORT */
 
+#ifdef SSL_SUPPORT
+void net_stats_add_tx(size_t bytes);
+void net_stats_add_rx(size_t bytes);
+#endif
 
 ssize_t net_con_send(struct net_connection* con, const void* buf, size_t len)
 {
@@ -148,7 +156,13 @@ 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 (
+#ifdef WINSOCK
+				net_error() == WSAEWOULDBLOCK
+#else
+				net_error() == EWOULDBLOCK 
+#endif
+				|| net_error() == EINTR)
 				return 0;
 			return -1;
 		}
@@ -161,7 +175,11 @@ ssize_t net_con_send(struct net_connection* con, const void* buf, size_t 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);
+			return handle_openssl_error(con, ret);
+		}
+		else
+		{
+			 net_stats_add_tx(ret);
 		}
 	}
 #endif
@@ -178,7 +196,13 @@ ssize_t net_con_recv(struct net_connection* con, void* buf, size_t len)
 		ret = net_recv(con->sd, buf, len, 0);
 		if (ret == -1)
 		{
-			if (net_error() == EWOULDBLOCK || net_error() == EINTR)
+			if (
+#ifdef WINSOCK
+				net_error() == WSAEWOULDBLOCK
+#else
+				net_error() == EWOULDBLOCK
+#endif
+				|| net_error() == EINTR)
 				return 0;
 			return -net_error();
 		}
@@ -198,10 +222,11 @@ ssize_t net_con_recv(struct net_connection* con, void* buf, size_t len)
 		if (ret > 0)
 		{
 			net_con_update(con, NET_EVENT_READ);
+			net_stats_add_rx(ret);
 		}
 		else
 		{
-			return -handle_openssl_error(con, ret);
+			return handle_openssl_error(con, ret);
 		}
 	}
 #endif
@@ -213,7 +238,13 @@ 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 (
+#ifdef WINSOCK
+				net_error() == WSAEWOULDBLOCK
+#else
+				net_error() == EWOULDBLOCK 
+#endif
+				|| net_error() == EINTR)
 			return 0;
 		return -net_error();
 	}
@@ -251,6 +282,9 @@ void* net_con_get_ptr(struct net_connection* con)
 
 void net_con_destroy(struct net_connection* con)
 {
+#ifdef SSL_SUPPORT
+	SSL_free(con->ssl);
+#endif
 	hub_free(con);
 }
 

src/network/epoll.c

@@ -160,6 +160,7 @@ struct net_backend* net_backend_init_epoll(struct net_backend_handler* handler,
 	if (backend->epfd == -1)
 	{
 		LOG_WARN("Unable to create epoll socket.");
+		hub_free(backend);
 		return 0;
 	}
 

src/network/kqueue.c

@@ -30,20 +30,31 @@
 struct net_connection_kqueue
 {
 	NET_CON_STRUCT_COMMON
-	struct kevent ev;
+	struct kevent ev_r;
+	struct kevent ev_w;
+	int change;
 };
 
 struct net_backend_kqueue
 {
 	int kqfd;
 	struct net_connection_kqueue** conns;
-	struct kevent** changes;
-	size_t nchanges;
+	struct kevent* changes;
+	int* change_list;
+	size_t change_list_len;
 	struct kevent events[KQUEUE_EVBUFFER];
 	struct net_backend_common* common;
 };
 
+#define CHANGE_ACTION_ADD       0x0001
+#define CHANGE_ACTION_MOD       0x0002
+#define CHANGE_ACTION_DEL       0x0004
+#define CHANGE_OP_WANT_READ     0x0100
+#define CHANGE_OP_WANT_WRITE    0x0200
+
 static void net_backend_set_handlers(struct net_backend_handler* handler);
+static void add_change(struct net_backend_kqueue* backend, struct net_connection_kqueue* con, int actions);
+static size_t create_change_list(struct net_backend_kqueue* backend);
 
 const char* net_backend_name_kqueue()
 {
@@ -55,12 +66,13 @@ int net_backend_poll_kqueue(struct net_backend* data, int ms)
 	int res;
 	struct timespec tspec = { 0, };
 	struct net_backend_kqueue* backend = (struct net_backend_kqueue*) data;
+	size_t changes;
 
 	tspec.tv_sec = (ms / 1000);
-	tspec.tv_nsec = ((ms % 1000) * 1000000); /* FIXME: correct? */
+	tspec.tv_nsec = ((ms % 1000) * 1000000);
 
-	res = kevent(backend->kqfd, *backend->changes, backend->nchanges, backend->events, KQUEUE_EVBUFFER, &tspec);
-	backend->nchanges = 0;
+	changes = create_change_list(backend);
+	res = kevent(backend->kqfd, backend->changes, changes, backend->events, KQUEUE_EVBUFFER, &tspec);
 
 	if (res == -1 && errno == EINTR)
 		return 0;
@@ -75,11 +87,14 @@ void net_backend_process_kqueue(struct net_backend* data, int res)
 	for (n = 0; n < res; n++)
 	{
 		struct net_connection_kqueue* con = (struct net_connection_kqueue*) backend->events[n].udata;
+		if (con && con->sd >= 0 && backend->conns[con->sd])
+		{
 			int ev = 0;
-		if (backend->events[n].filter & EVFILT_READ)  ev |= NET_EVENT_READ;
-		if (backend->events[n].filter & EVFILT_WRITE) ev |= NET_EVENT_WRITE;
+			if (backend->events[n].filter == EVFILT_READ) ev = NET_EVENT_READ;
+			else if (backend->events[n].filter == EVFILT_WRITE) ev = NET_EVENT_WRITE;
 			net_con_callback((struct net_connection*) con, ev);
 		}
+	}
 }
 
 struct net_connection* net_con_create_kqueue(struct net_backend* data)
@@ -100,30 +115,37 @@ void net_con_initialize_kqueue(struct net_backend* data, struct net_connection*
 
 void net_con_backend_add_kqueue(struct net_backend* data, struct net_connection* con_, int events)
 {
-	short filter = 0;
 	struct net_backend_kqueue* backend = (struct net_backend_kqueue*) data;
 	struct net_connection_kqueue* con = (struct net_connection_kqueue*) con_;
-	if  (events & NET_EVENT_READ)  filter |= EVFILT_READ;
-	if  (events & NET_EVENT_WRITE) filter |= EVFILT_READ;
-	EV_SET(&con->ev, con->sd, filter, EV_ADD, 0, 0, con);
-	backend->changes[backend->nchanges++] = &con->ev;
+	int operation;
+
 	backend->conns[con->sd] = con;
+
+	operation = CHANGE_ACTION_ADD;
+
+	if (events & NET_EVENT_READ)
+	  operation |= CHANGE_OP_WANT_READ;
+
+	if (events & NET_EVENT_WRITE)
+	  operation |= CHANGE_OP_WANT_WRITE;
+
+	add_change(backend, con, operation);
 }
 
 void net_con_backend_mod_kqueue(struct net_backend* data, struct net_connection* con_, int events)
 {
-	short filter = 0;
 	struct net_backend_kqueue* backend = (struct net_backend_kqueue*) data;
 	struct net_connection_kqueue* con = (struct net_connection_kqueue*) con_;
 
-	if  (events & NET_EVENT_READ)  filter |= EVFILT_READ;
-	if  (events & NET_EVENT_WRITE) filter |= EVFILT_READ;
+	int operation = CHANGE_ACTION_ADD;
 
-	if (filter == con->ev.filter)
-		return;
+	if (events & NET_EVENT_READ)
+	  operation |= CHANGE_OP_WANT_READ;
 
-	EV_SET(&con->ev, con->sd, filter, EV_ADD, 0, 0, con);
-	backend->changes[backend->nchanges++] = &con->ev;
+	if (events & NET_EVENT_WRITE)
+	  operation |= CHANGE_OP_WANT_WRITE;
+
+	add_change(backend, con, operation);
 }
 
 void net_con_backend_del_kqueue(struct net_backend* data, struct net_connection* con_)
@@ -131,10 +153,12 @@ void net_con_backend_del_kqueue(struct net_backend* data, struct net_connection*
 	struct net_backend_kqueue* backend = (struct net_backend_kqueue*) data;
 	struct net_connection_kqueue* con = (struct net_connection_kqueue*) con_;
 
-	backend->conns[con->sd] = 0;
-
 	/* No need to remove it from the kqueue filter, the kqueue man page says
-	   it is automatically removed when the descriptor is closed. */
+	   it is automatically removed when the descriptor is closed... */
+	add_change(backend, con, CHANGE_ACTION_DEL);
+
+	// Unmap the socket descriptor.
+	backend->conns[con->sd] = 0;
 }
 
 void net_backend_shutdown_kqueue(struct net_backend* data)
@@ -143,6 +167,7 @@ void net_backend_shutdown_kqueue(struct net_backend* data)
 	close(backend->kqfd);
 	hub_free(backend->conns);
 	hub_free(backend->changes);
+	hub_free(backend->change_list);
 	hub_free(backend);
 }
 
@@ -162,8 +187,8 @@ struct net_backend* net_backend_init_kqueue(struct net_backend_handler* handler,
 	}
 
 	backend->conns = hub_malloc_zero(sizeof(struct net_connection_kqueue*) * common->max);
-	backend->conns = hub_malloc_zero(sizeof(struct net_connection_kqueue*) * common->max);
-	backend->changes = hub_malloc_zero(sizeof(struct kevent*) * common->max);
+	backend->changes = hub_malloc_zero(sizeof(struct kevent) * common->max * 2);
+	backend->change_list = hub_malloc_zero(sizeof(int) * common->max);
 	backend->common = common;
 
 	net_backend_set_handlers(handler);
@@ -183,4 +208,71 @@ static void net_backend_set_handlers(struct net_backend_handler* handler)
 	handler->con_del = net_con_backend_del_kqueue;
 }
 
+static void add_change(struct net_backend_kqueue* backend, struct net_connection_kqueue* con, int actions)
+{
+	if (actions && !con->change)
+	{
+		backend->change_list[backend->change_list_len++] = con->sd;
+		con->change = actions;
+	}
+}
+
+static size_t create_change_list(struct net_backend_kqueue* backend)
+{
+	size_t n = 0;
+	size_t changes = 0;
+	int sd;
+	struct net_connection_kqueue* con;
+	unsigned short flags_r = 0;
+	unsigned short flags_w = 0;
+
+	for (; n < backend->change_list_len; n++)
+	{
+		sd = backend->change_list[n];
+		con = backend->conns[sd];
+		if (con)
+		{
+			flags_r = 0;
+			flags_w = 0;
+
+			if (con->change & CHANGE_ACTION_ADD)
+			{
+				flags_r |= EV_ADD;
+				flags_w |= EV_ADD;
+			}
+
+			if (con->change & CHANGE_OP_WANT_READ)
+				flags_r |= EV_ENABLE;
+			else
+				flags_r |= EV_DISABLE;
+
+			if (con->change & CHANGE_OP_WANT_WRITE)
+				flags_w |= EV_ENABLE;
+			else
+				flags_w |= EV_DISABLE;
+
+			if (con->ev_r.flags != flags_r)
+			{
+				EV_SET(&con->ev_r, sd, EVFILT_READ, flags_r, 0, 0, con);
+				memcpy(&backend->changes[changes++], &con->ev_r, sizeof(struct kevent));
+			}
+
+			if (con->ev_w.flags != flags_w)
+			{
+				EV_SET(&con->ev_w, sd, EVFILT_WRITE, flags_w, 0, 0, con);
+				memcpy(&backend->changes[changes++], &con->ev_w, sizeof(struct kevent));
+			}
+
+			con->change = 0;
+		}
+		else
+		{
+			EV_SET(&backend->changes[changes++], sd, EVFILT_READ, EV_DELETE, 0, 0, 0);
+			EV_SET(&backend->changes[changes++], sd, EVFILT_READ, EV_DELETE, 0, 0, 0);
+		}
+	}
+	backend->change_list_len = 0;
+	return changes;
+}
+
 #endif /* USE_KQUEUE */

src/network/network.c

@@ -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.");
@@ -60,7 +62,6 @@ int net_initialize()
 		LOG_TRACE("Initializing OpenSSL...");
 		SSL_library_init();
 		SSL_load_error_strings();
-		OpenSSL_add_all_algorithms();
 #endif /*  SSL_SUPPORT */
 
 		net_initialized = 1;
@@ -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;
@@ -100,7 +100,9 @@ int net_destroy()
 		net_backend_shutdown();
 		
 #ifdef SSL_SUPPORT
-		/* FIXME: Shutdown OpenSSL here. */
+		ERR_free_strings();
+		EVP_cleanup();
+		CRYPTO_cleanup_all_ex_data();
 #endif
 
 #ifdef WINSOCK
@@ -370,8 +372,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 +424,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();
@@ -528,7 +539,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 +659,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 +694,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 +717,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

@@ -254,46 +254,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/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,7 +49,8 @@ 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;
 
@@ -57,6 +59,7 @@ int net_backend_poll_select(struct net_backend* data, int ms)
 
 	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,14 @@ int net_backend_poll_select(struct net_backend* data, int ms)
 	}
 	backend->maxfd++;
 
-	res = select(backend->maxfd, &backend->rfds, &backend->wfds, 0, &tval);
-
-	if (res == -1 && errno == EINTR)
+	res = select(backend->maxfd, &backend->rfds, &backend->wfds, &backend->xfds, &tval);
+	if (res == -1)
+	{
+		printf("Error: %d\n", net_error());
+	}
+	if (res == -1 && net_error() == EINTR)
 		return 0;
+
 	return res;
 }
 
@@ -121,11 +128,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

@@ -35,7 +35,7 @@ void timeout_evt_reset(struct timeout_evt* t)
 
 int timeout_evt_is_scheduled(struct timeout_evt* t)
 {
-	return !!t->prev;
+	return t->prev != NULL;
 }
 
 void timeout_queue_initialize(struct timeout_queue* t, time_t now, size_t max)
@@ -54,10 +54,11 @@ void timeout_queue_shutdown(struct timeout_queue* t)
 
 size_t timeout_queue_process(struct timeout_queue* t, time_t now)
 {
-	size_t pos;
+	size_t pos = (size_t) t->last;
 	size_t events = 0;
 	struct timeout_evt* evt = 0;
-	for (pos = t->last; pos <= now; pos++)
+	t->last = now;
+	for (; pos <= now; pos++)
 	{
 		while ((evt = t->events[pos % t->max]))
 		{
@@ -66,7 +67,6 @@ size_t timeout_queue_process(struct timeout_queue* t, time_t now)
 			events++;
 		}
 	}
-	t->last = now;
 	return events;
 }
 
@@ -94,6 +94,7 @@ void timeout_queue_insert(struct timeout_queue* t, struct timeout_evt* evt, size
 	
 	if (first)
 	{
+		uhub_assert(first->timestamp == evt->timestamp);
 		first->prev->next = evt;
 		evt->prev = first->prev;
 		first->prev = evt;

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;
+};
+
+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)
+
+extern int plugin_command_add(struct plugin_handle*, struct plugin_command_handle*);
+extern int plugin_command_del(struct plugin_handle*, struct plugin_command_handle*);
+
+/**
+ * Send a message to a user.
+ * From the user's perspective the message will originate from the hub.
+ */
+extern int plugin_command_send_message(struct plugin_handle*, struct plugin_user* to, const char* message);
+
+/**
+ * Send a reply to a command.
+ */
+extern int plugin_command_send_reply(struct plugin_handle*, struct plugin_user* user, struct plugin_command* command, const char* message);
+
+#endif /* HAVE_UHUB_PLUGIN_API_H */

src/plugin_api/handle.h

@@ -0,0 +1,174 @@
+/*
+ * 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 "util/ipcalc.h"
+#include "plugin_api/types.h"
+
+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 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_change_nick_t)(struct plugin_handle*, struct plugin_user*, const char* new_nick);
+
+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 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 (*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.
+ */
+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_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 */
+
+	// Login check functions
+	on_check_ip_early_t     login_check_ip_early;
+	on_check_ip_late_t      login_check_ip_late;
+};
+
+struct plugin_command_handle;
+
+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*);
+
+/**
+ * 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;
+};
+
+
+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,96 @@
+/*
+ * 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 */
+};
+
+#endif /* HAVE_UHUB_PLUGIN_TYPES_H */

src/plugins/mod_auth_simple.c

@@ -0,0 +1,242 @@
+/*
+ * 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/ipcalc.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,227 @@
+/*
+ * 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/ipcalc.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 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;
+	if (sql->exclusive)
+		return st_deny;
+	return st_default;
+}
+
+static plugin_st update_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;
+}
+
+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", "0.1", "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,245 @@
+/*
+ * 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;
+	int 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;
+	int maxlines = 0;
+
+	if (!list_size(data->chat_history))
+		return command_status(plugin, user, cmd, cbuf_create_const("No messages."));
+
+	if (list_size(cmd->args) > 0)
+		maxlines = (int) (intptr_t) ((intptr_t*) (void*) list_get_first(cmd->args));
+	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);
+
+	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) // FIXME: >= ?
+	{
+		u = hub_malloc_zero(sizeof(struct user_info) * (sid + 1));
+		memcpy(u, data->users, data->max_users);
+		hub_free(data->users);
+		data->users = u;
+		data->max_users = sid;
+		u = NULL;
+	}
+
+	u = &data->users[sid];
+
+	// reset counters if the user was not previously known.
+	if (!u->sid)
+	{
+		u->sid = sid;
+		u->warnings = 0;
+		data->num_users++;
+	}
+	return u;
+}
+
+static 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,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 "system.h"
+#include "adc/adcconst.h"
+#include "adc/sid.h"
+#include "util/memory.h"
+#include "util/ipcalc.h"
+#include "plugin_api/handle.h"
+
+#include "util/misc.h"
+#include "util/config_token.h"
+#include <syslog.h>
+
+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);
+}
+
+static int log_open_syslog(struct plugin_handle* plugin)
+{
+	openlog("uhub", 0, LOG_USER);
+	return 1;
+}
+
+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;
+		}
+		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;
+			}
+		}
+		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;
+		}
+	}
+	else
+	{
+		if (!log_open_syslog(plugin))
+		{
+			hub_free(data->logfile);
+			hub_free(data);
+			set_error_message(plugin, "Unable to open syslog");
+			return 0;
+		}
+	}
+
+	return data;
+}
+
+static void log_close(struct log_data* data)
+{
+	if (data->logmode == mode_file)
+	{
+		hub_free(data->logfile);
+		close(data->fd);
+	}
+	else
+	{
+		closelog();
+	}
+	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
+		{
+#if defined _POSIX_SYNCHRONIZED_IO && _POSIX_SYNCHRONIZED_IO > 0
+			fdatasync(data->fd);
+#else
+			fsync(data->fd);
+#endif
+		}
+	}
+	else
+	{
+		va_start(args, format);
+		vsyslog(LOG_INFO, format, args);
+		va_end(args);
+	}
+}
+
+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_welcome.c

@@ -0,0 +1,304 @@
+/*
+ * 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/cbuffer.h"
+#include "util/memory.h"
+#include "util/ipcalc.h"
+#include "plugin_api/handle.h"
+#include "plugin_api/command_api.h"
+
+#include "util/misc.h"
+#include "util/config_token.h"
+#include <syslog.h>
+
+#define MAX_WELCOME_SIZE 16384
+
+struct welcome_data
+{
+	char* motd_file;
+	char* motd;
+	char* rules_file;
+	char* rules;
+	struct plugin_command_handle* cmd_motd;
+	struct plugin_command_handle* cmd_rules;
+};
+
+static int command_handler_motd(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd);
+static int command_handler_rules(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd);
+
+static char* read_file(const char* filename)
+{
+	char* str;
+	char buf[MAX_WELCOME_SIZE];
+	int fd = open(filename, O_RDONLY);
+	int ret;
+
+	if (fd == -1)
+		return NULL;
+
+	ret = read(fd, buf, MAX_WELCOME_SIZE);
+	close(fd);
+
+	buf[ret > 0 ? ret : 0] = 0;
+	str = strdup(buf);
+
+	return str;
+}
+
+int read_motd(struct welcome_data* data)
+{
+	data->motd = read_file(data->motd_file);
+	return !!data->motd;
+}
+
+int read_rules(struct welcome_data* data)
+{
+	data->rules = read_file(data->rules_file);
+	return !!data->rules;
+}
+
+static void free_welcome_data(struct welcome_data* data)
+{
+	if (!data)
+		return;
+
+	hub_free(data->cmd_motd);
+	hub_free(data->motd_file);
+	hub_free(data->motd);
+	hub_free(data->cmd_rules);
+	hub_free(data->rules_file);
+	hub_free(data->rules);
+	hub_free(data);
+}
+
+
+static void set_error_message(struct plugin_handle* plugin, const char* msg)
+{
+	plugin->error_msg = msg;
+}
+
+static struct welcome_data* parse_config(const char* line, struct plugin_handle* plugin)
+{
+	struct welcome_data* data = (struct welcome_data*) hub_malloc_zero(sizeof(struct welcome_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");
+			goto cleanup_parse_error;
+		}
+
+		if (strcmp(cfg_settings_get_key(setting), "motd") == 0)
+		{
+			data->motd_file = strdup(cfg_settings_get_value(setting));
+			if (!read_motd(data))
+			{
+				set_error_message(plugin, "Unable to read motd file.");
+				cfg_settings_free(setting);
+				goto cleanup_parse_error;
+			}
+
+			data->cmd_motd = hub_malloc_zero(sizeof(struct plugin_command_handle));
+			PLUGIN_COMMAND_INITIALIZE(data->cmd_motd, (void*) data, "motd", "", auth_cred_guest, command_handler_motd, "Show the message of the day.");
+		}
+		else if (strcmp(cfg_settings_get_key(setting), "rules") == 0)
+		{
+			data->rules_file = strdup(cfg_settings_get_value(setting));
+			if (!read_rules(data))
+			{
+				set_error_message(plugin, "Unable to read rules file.");
+				cfg_settings_free(setting);
+				goto cleanup_parse_error;
+			}
+
+			data->cmd_rules = hub_malloc_zero(sizeof(struct plugin_command_handle));
+			PLUGIN_COMMAND_INITIALIZE(data->cmd_rules, (void*) data, "rules", "", auth_cred_guest, command_handler_rules, "Show the hub rules.");
+		}
+		else
+		{
+			set_error_message(plugin, "Unknown startup parameters given");
+			cfg_settings_free(setting);
+			goto cleanup_parse_error;
+		}
+
+		cfg_settings_free(setting);
+		token = cfg_token_get_next(tokens);
+	}
+
+	cfg_tokens_free(tokens);
+	return data;
+
+cleanup_parse_error:
+	cfg_tokens_free(tokens);
+	free_welcome_data(data);
+	return 0;
+}
+
+
+static struct cbuffer* parse_message(struct plugin_user* user, const char* msg)
+{
+	struct cbuffer* buf = cbuf_create(strlen(msg));
+	const char* start = msg;
+	const char* offset = NULL;
+	time_t timestamp = time(NULL);
+	struct tm* now = localtime(&timestamp);
+
+	while ((offset = strchr(start, '%')))
+	{
+		cbuf_append_bytes(buf, start, (offset - start));
+
+		offset++;
+		switch (offset[0])
+		{
+			case 'n':
+				cbuf_append(buf, user->nick);
+				break;
+
+			case 'a':
+				cbuf_append(buf, ip_convert_to_string(&user->addr));
+				break;
+			case 'c':
+				cbuf_append(buf, auth_cred_to_string(user->credentials));
+				break;
+
+			case '%':
+				cbuf_append(buf, "%");
+				break;
+
+			case 'H':
+				cbuf_append_strftime(buf, "%H", now);
+				break;
+
+			case 'I':
+				cbuf_append_strftime(buf, "%I", now);
+				break;
+
+			case 'P':
+				cbuf_append_strftime(buf, "%P", now);
+				break;
+
+			case 'p':
+				cbuf_append_strftime(buf, "%p", now);
+				break;
+
+			case 'M':
+				cbuf_append_strftime(buf, "%M", now);
+				break;
+
+			case 'S':
+				cbuf_append_strftime(buf, "%S", now);
+				break;
+		}
+
+		start = offset + 1;
+	}
+
+	if (*start)
+		cbuf_append(buf, start);
+
+	return buf;
+}
+
+static void send_motd(struct plugin_handle* plugin, struct plugin_user* user)
+{
+	struct welcome_data* data = (struct welcome_data*) plugin->ptr;
+	struct cbuffer* buf = NULL;
+	if (data->motd)
+	{
+		buf = parse_message(user, data->motd);
+		plugin->hub.send_message(plugin, user, cbuf_get(buf));
+		cbuf_destroy(buf);
+	}
+}
+
+static void send_rules(struct plugin_handle* plugin, struct plugin_user* user)
+{
+	struct welcome_data* data = (struct welcome_data*) plugin->ptr;
+	struct cbuffer* buf = NULL;
+	if (data->rules)
+	{
+		buf = parse_message(user, data->rules);
+		plugin->hub.send_message(plugin, user, cbuf_get(buf));
+		cbuf_destroy(buf);
+	}
+}
+
+static void on_user_login(struct plugin_handle* plugin, struct plugin_user* user)
+{
+	send_motd(plugin, user);
+}
+
+static int command_handler_motd(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
+{
+	send_motd(plugin, user);
+	return 0;
+}
+
+static int command_handler_rules(struct plugin_handle* plugin, struct plugin_user* user, struct plugin_command* cmd)
+{
+	send_rules(plugin, user);
+	return 0;
+}
+
+int plugin_register(struct plugin_handle* plugin, const char* config)
+{
+	struct welcome_data* data;
+	PLUGIN_INITIALIZE(plugin, "Welcome plugin", "0.1", "Sends a welcome message to users when they log into the hub.");
+	data = parse_config(config, plugin);
+
+	if (!data)
+		return -1;
+
+	plugin->ptr = data;
+	plugin->funcs.on_user_login = on_user_login;
+
+	if (data->cmd_motd)
+		plugin->hub.command_add(plugin, data->cmd_motd);
+
+	if (data->cmd_rules)
+		plugin->hub.command_add(plugin, data->cmd_rules);
+
+	return 0;
+}
+
+int plugin_unregister(struct plugin_handle* plugin)
+{
+	struct welcome_data* data = (struct welcome_data*) plugin->ptr;
+
+	if (data->cmd_motd)
+		plugin->hub.command_del(plugin, data->cmd_motd);
+
+	if (data->cmd_rules)
+		plugin->hub.command_del(plugin, data->cmd_rules);
+
+	free_welcome_data(data);
+	return 0;
+}
+

src/system.h

@@ -22,39 +22,29 @@
 
 #define _FILE_OFFSET_BITS 64
 
-#if USE_REGPARM && __GNUC__ >= 3
-#define REGPRM1 __attribute__((regparm(1)))
-#define REGPRM2 __attribute__((regparm(2)))
-#define REGPRM3 __attribute__((regparm(3)))
-#else
-#define REGPRM1
-#define REGPRM2
-#define REGPRM3
-#endif
-
-#ifndef FORCEINLINE
-#if __GNUC__ < 3
-#define FORCEINLINE inline
-#else
-#define FORCEINLINE inline __attribute__((always_inline))
-#endif
-#endif
-
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
 
-#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__) || (defined(__APPLE__) && defined(__MACH__))
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__) || (defined(__APPLE__) && defined(__MACH__)) || defined(__FreeBSD_kernel__)
 #define BSD_LIKE
 #endif
 
-#if defined(__CYGWIN__) || defined(__MINGW32__)
+#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER)
 #ifndef WINSOCK
 #define WINSOCK
 #endif
 #endif
 
+#if defined(__CYGWIN__) || defined(__MINGW32__)
+#define HAVE_SSIZE_T
+#define NEED_GETOPT
+#endif
+
 #ifdef WINSOCK
+#ifndef FD_SETSIZE
+#define FD_SETSIZE 4096
+#endif
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #else
@@ -72,7 +62,6 @@
 #include <fcntl.h>
 
 #ifndef __sun__
-#include <getopt.h>
 #include <stdint.h>
 #endif
 
@@ -82,13 +71,17 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
-#include <unistd.h>
 
 #if !defined(WIN32)
+#include <unistd.h>
 #include <grp.h>
 #include <pwd.h>
 #include <sys/resource.h>
 #define HAVE_STRNDUP
+#define HAVE_DLOPEN
+#define HAVE_GETOPT
+#define HAVE_SSIZE_T
+#include <dlfcn.h>
 #ifndef __HAIKU__
 #define HAVE_MEMMEM
 #endif
@@ -118,8 +111,10 @@
 #endif
 
 #ifdef BSD_LIKE
+/*
 #define USE_KQUEUE
 #include <sys/event.h>
+*/
 #endif
 
 #define USE_SELECT
@@ -132,6 +127,9 @@
 #undef HAVE_MEMMEM
 #endif
 
+#ifdef HAVE_GETOPT
+#include <getopt.h>
+#endif
 
 /*
  * Detect operating system info.
@@ -149,7 +147,7 @@
 #define OPSYS "MacOSX"
 #endif
 
-#if defined(__FreeBSD__)
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 #define OPSYS "FreeBSD"
 #endif
 
@@ -173,6 +171,10 @@
 #define OPSYS "Haiku"
 #endif
 
+#if defined(__GNU__)
+#define OPSYS "Hurd"
+#endif
+
 /* Detect CPUs */
 #if defined(__alpha__) || defined(__alpha)
 #define CPUINFO "Alpha"
@@ -218,6 +220,10 @@
 #define CPUINFO "SuperH"
 #endif
 
+#if defined(__s390__) || defined(__s390x__)
+#define CPUINFO "s390"
+#endif
+
 /* Misc */
 #ifdef MSG_NOSIGNAL
 #define UHUB_SEND_SIGNAL MSG_NOSIGNAL
@@ -241,4 +247,33 @@
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 #endif
 
+#ifndef HAVE_SSIZE_T
+typedef int ssize_t;
+#define HAVE_SSIZE_T
+#endif
+
+#ifdef _MSC_VER
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
+#endif
+
+
+#ifdef _MSC_VER
+#define strdup _strdup
+#define snprintf _snprintf
+#define strcasecmp _stricmp
+#define strncasecmp _strnicmp
+#define atoll _atoi64
+#include <io.h>
+#define open _open
+#define close _close
+#define read _read
+#define NEED_GETOPT
+#endif
+
+#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER)
+#define PLUGIN_API __declspec(dllexport)
+#else
+#define PLUGIN_API
+#endif
 #endif /* HAVE_UHUB_SYSTEM_H */

src/tools/adcclient.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
@@ -23,10 +23,14 @@
 #define ADC_CID_SIZE 39
 #define BIG_BUFSIZE 32768
 #define TIGERSIZE 24
+// #define ADCC_DEBUG
 
 static ssize_t ADC_client_recv(struct ADC_client* client);
 static void ADC_client_send_info(struct ADC_client* client);
 static void ADC_client_on_connected(struct ADC_client* client);
+#ifdef SSL_SUPPORT
+static void ADC_client_on_connected_ssl(struct ADC_client* client);
+#endif
 static void ADC_client_on_disconnected(struct ADC_client* client);
 static void ADC_client_on_login(struct ADC_client* client);
 static int ADC_client_parse_address(struct ADC_client* client, const char* arg);
@@ -42,14 +46,42 @@ static void ADC_client_debug(struct ADC_client* client, const char* format, ...)
 	fprintf(stdout, "* [%p] %s\n", client, logmsg);
 }
 
+#ifdef ADCC_DEBUG
+#define ADC_TRACE fprintf(stderr, "TRACE: %s\n", __PRETTY_FUNCTION__)
+#else
+#define ADC_TRACE do { } while(0)
+#endif
+
+#ifdef ADCC_DEBUG
+static const char* ADC_client_state_string[] =
+{
+	"ps_none",
+	"ps_conn",
+	"ps_conn_ssl",
+	"ps_protocol",
+	"ps_identify",
+	"ps_verify",
+	"ps_normal",
+	0
+};
+#endif
+
 static void ADC_client_set_state(struct ADC_client* client, enum ADC_client_state state)
 {
+	ADC_TRACE;
+	if (client->state != state)
+	{
+#ifdef ADCC_DEBUG
+		ADC_client_debug(client, "Set state %s (was %s)", ADC_client_state_string[(int) state], ADC_client_state_string[(int) client->state]);
+#endif
 		client->state = state;
+	}
 }
 
 
 static void adc_cid_pid(struct ADC_client* client)
 {
+	ADC_TRACE;
 	char seed[64];
 	char pid[64];
 	char cid[64];
@@ -73,17 +105,35 @@ static void adc_cid_pid(struct ADC_client* client)
 
 static void event_callback(struct net_connection* con, int events, void *arg)
 {
+	ADC_TRACE;
 	struct ADC_client* client = (struct ADC_client*) net_con_get_ptr(con);
 
+	switch (client->state)
+	{
+		case ps_conn:
 			if (events == NET_EVENT_TIMEOUT)
-	{
-		if (client->state == ps_conn)
 			{
 				client->callback(client, ADC_CLIENT_DISCONNECTED, 0);
-		}
 				return;
 			}
 
+			if (events & NET_EVENT_WRITE)
+				ADC_client_connect(client, 0);
+			break;
+
+#ifdef SSL_SUPPORT
+		case ps_conn_ssl:
+			if (events == NET_EVENT_TIMEOUT)
+			{
+				client->callback(client, ADC_CLIENT_DISCONNECTED, 0);
+				return;
+			}
+
+			ADC_client_on_connected_ssl(client);
+			break;
+#endif
+
+		default:
 			if (events & NET_EVENT_READ)
 			{
 				if (ADC_client_recv(client) == -1)
@@ -93,12 +143,6 @@ static void event_callback(struct net_connection* con, int events, void *arg)
 			}
 
 			if (events & NET_EVENT_WRITE)
-	{
-		if (client->state == ps_conn)
-		{
-			ADC_client_connect(client, 0);
-		}
-		else
 			{
 				/* FIXME: Call send again */
 			}
@@ -127,6 +171,7 @@ static void event_callback(struct net_connection* con, int events, void *arg)
 
 static void ADC_client_on_recv_line(struct ADC_client* client, const char* line, size_t length)
 {
+	ADC_TRACE;
 #ifdef ADC_CLIENT_DEBUG_PROTO
 	ADC_client_debug(client, "- LINE: '%s'", start);
 #endif
@@ -213,6 +258,7 @@ static void ADC_client_on_recv_line(struct ADC_client* client, const char* line,
 				if (adc_msg_has_named_argument(msg, "ID"))
 				{
 					struct ADC_user user;
+					user.sid = msg->source;
 					EXTRACT_NAMED_ARG(msg, "NI", user.name);
 					EXTRACT_NAMED_ARG(msg, "DE", user.description);
 					EXTRACT_NAMED_ARG(msg, "VE", user.version);
@@ -250,6 +296,7 @@ static void ADC_client_on_recv_line(struct ADC_client* client, const char* line,
 
 static ssize_t ADC_client_recv(struct ADC_client* client)
 {
+	ADC_TRACE;
 	ssize_t size = net_con_recv(client->con, &client->recvbuf[client->r_offset], ADC_BUFSIZE - client->r_offset);
 	if (size <= 0)
 		return size;
@@ -285,6 +332,7 @@ static ssize_t ADC_client_recv(struct ADC_client* client)
 
 void ADC_client_send(struct ADC_client* client, char* msg)
 {
+	ADC_TRACE;
 	int ret = net_con_send(client->con, msg, strlen(msg));
 
 #ifdef ADC_CLIENT_DEBUG_PROTO
@@ -311,6 +359,7 @@ void ADC_client_send(struct ADC_client* client, char* msg)
 
 void ADC_client_send_info(struct ADC_client* client)
 {
+	ADC_TRACE;
 	char binf[11];
 	snprintf(binf, 11, "BINF %s\n", sid_to_string(client->sid));
 	client->info = adc_msg_create(binf);
@@ -330,6 +379,7 @@ void ADC_client_send_info(struct ADC_client* client)
 
 int ADC_client_create(struct ADC_client* client, const char* nickname, const char* description)
 {
+	ADC_TRACE;
 	memset(client, 0, sizeof(struct ADC_client));
 
 	int sd = net_socket_create(PF_INET, SOCK_STREAM, IPPROTO_TCP);
@@ -355,6 +405,7 @@ int ADC_client_create(struct ADC_client* client, const char* nickname, const cha
 
 void ADC_client_destroy(struct ADC_client* client)
 {
+	ADC_TRACE;
 	ADC_client_disconnect(client);
 #if 0
 	/* FIXME */
@@ -369,6 +420,7 @@ void ADC_client_destroy(struct ADC_client* client)
 
 int ADC_client_connect(struct ADC_client* client, const char* address)
 {
+	ADC_TRACE;
 	if (!client->hub_address)
 	{
 		if (!ADC_client_parse_address(client, address))
@@ -383,13 +435,10 @@ int ADC_client_connect(struct ADC_client* client, const char* address)
 		ADC_client_on_connected(client);
 	}
 	else if (ret == -1 && (net_error() == EALREADY || net_error() == EINPROGRESS || net_error() == EWOULDBLOCK || net_error() == EINTR))
-	{
-		if (client->state != ps_conn)
 	{
 		net_con_update(client->con, NET_EVENT_READ | NET_EVENT_WRITE);
 		ADC_client_set_state(client, ps_conn);
 	}
-	}
 	else
 	{
 		ADC_client_on_disconnected(client);
@@ -400,14 +449,38 @@ int ADC_client_connect(struct ADC_client* client, const char* address)
 
 static void ADC_client_on_connected(struct ADC_client* client)
 {
+	ADC_TRACE;
+#ifdef SSL_SUPPORT
+	if (client->ssl_enabled)
+	{
+		net_con_update(client->con, NET_EVENT_READ | NET_EVENT_WRITE);
+		client->callback(client, ADC_CLIENT_SSL_HANDSHAKE, 0);
+		ADC_client_set_state(client, ps_conn_ssl);
+	}
+	else
+#endif
+	{
+		net_con_update(client->con, NET_EVENT_READ);
+		client->callback(client, ADC_CLIENT_CONNECTED, 0);
+		ADC_client_send(client, ADC_HANDSHAKE);
+		ADC_client_set_state(client, ps_protocol);
+	}
+}
+
+#ifdef SSL_SUPPORT
+static void ADC_client_on_connected_ssl(struct ADC_client* client)
+{
+	ADC_TRACE;
 	net_con_update(client->con, NET_EVENT_READ);
 	client->callback(client, ADC_CLIENT_CONNECTED, 0);
 	ADC_client_send(client, ADC_HANDSHAKE);
 	ADC_client_set_state(client, ps_protocol);
 }
+#endif
 
 static void ADC_client_on_disconnected(struct ADC_client* client)
 {
+	ADC_TRACE;
 	net_con_close(client->con);
 	client->con = 0;
 	ADC_client_set_state(client, ps_none);
@@ -415,12 +488,14 @@ static void ADC_client_on_disconnected(struct ADC_client* client)
 
 static void ADC_client_on_login(struct ADC_client* client)
 {
+	ADC_TRACE;
 	ADC_client_set_state(client, ps_normal);
 	client->callback(client, ADC_CLIENT_LOGGED_IN, 0);
 }
 
 void ADC_client_disconnect(struct ADC_client* client)
 {
+	ADC_TRACE;
 	if (client->con && net_con_get_sd(client->con) != -1)
 	{
 		net_con_close(client->con);
@@ -430,6 +505,7 @@ void ADC_client_disconnect(struct ADC_client* client)
 
 static int ADC_client_parse_address(struct ADC_client* client, const char* arg)
 {
+	ADC_TRACE;
 	char* split;
 	int ssl = 0;
 	struct hostent* dns;
@@ -446,9 +522,12 @@ static int ADC_client_parse_address(struct ADC_client* client, const char* arg)
 
 	/* Check for ADC or ADCS */
 	if (!strncmp(arg, "adc://", 6))
-		ssl = 0;
+		client->ssl_enabled = 0;
 	else if (!strncmp(arg, "adcs://", 7))
+	{
+		client->ssl_enabled = 1;
 		ssl = 1;
+	}
 	else
 		return 0;
 
@@ -481,5 +560,6 @@ static int ADC_client_parse_address(struct ADC_client* client, const char* arg)
 
 void ADC_client_set_callback(struct ADC_client* client, adc_client_cb cb)
 {
+	ADC_TRACE;
 	client->callback = cb;
 }

src/tools/adcclient.h

@@ -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
@@ -26,12 +26,13 @@
 
 enum ADC_client_state
 {
-	ps_none     = 0x00, /* Not connected */
-	ps_conn     = 0x01, /* Connecting... */
-	ps_protocol = 0x02, /* Have sent HSUP */
-	ps_identify = 0x04, /* Have sent BINF */
-	ps_verify   = 0x08, /* Have sent HPAS */
-	ps_normal   = 0x10, /* Are fully logged in */
+	ps_none, /* Not connected */
+	ps_conn, /* Connecting... */
+	ps_conn_ssl, /* SSL handshake */
+	ps_protocol, /* Have sent HSUP */
+	ps_identify, /* Have sent BINF */
+	ps_verify, /* Have sent HPAS */
+	ps_normal, /* Are fully logged in */
 };
 
 struct ADC_client;
@@ -41,6 +42,8 @@ enum ADC_client_callback_type
 	ADC_CLIENT_CONNECTING       = 1001,
 	ADC_CLIENT_CONNECTED        = 1002,
 	ADC_CLIENT_DISCONNECTED     = 1003,
+	ADC_CLIENT_SSL_HANDSHAKE    = 1101,
+	ADC_CLIENT_SSL_OK           = 1102,
 
 	ADC_CLIENT_LOGGING_IN       = 2001,
 	ADC_CLIENT_PASSWORD_REQ     = 2002,
@@ -115,6 +118,11 @@ struct ADC_client
 	char* hub_address;
 	char* nick;
 	char* desc;
+	int ssl_enabled;
+#ifdef SSL_SUPPORT
+	const SSL_METHOD* ssl_method;
+	SSL_CTX* ssl_ctx;
+#endif /*  SSL_SUPPORT */
 };
 
 int ADC_client_create(struct ADC_client* client, const char* nickname, const char* description);

src/tools/adcrush.c

@@ -1,5 +1,20 @@
-/**
- * An ADC client emulator.
+/*
+ * 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 "adcclient.h"
@@ -23,7 +38,6 @@ static int cfg_level       = 1; /* activity level (0..3) */
 static int cfg_chat        = 0; /* chat mode, allow sending chat messages */
 static int cfg_quiet       = 0; /* quiet mode (no output) */
 static int cfg_clients     = ADC_CLIENTS_DEFAULT; /* number of clients */
-static int running         = 1;
 
 #define MAX_CHAT_MSGS 35
 const char* chat_messages[MAX_CHAT_MSGS] = {
@@ -328,9 +342,8 @@ void runloop(size_t clients)
 		ADC_client_connect(c, cfg_uri);
 	}
 
-	while (running)
+	while (net_backend_process())
 	{
-		net_backend_process();
 	}
 
 	for (n = 0; n < clients; n++)

src/tools/admin.c

@@ -1,5 +1,20 @@
-/**
- * A remote uhub admin client.
+/*
+ * 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 "adcclient.h"
@@ -20,12 +35,17 @@ static int handle(struct ADC_client* client, enum ADC_client_callback_type type,
 			puts("*** Disconnected.");
 			break;
 
+		case ADC_CLIENT_SSL_HANDSHAKE:
+			puts("*** SSL handshake.");
+			break;
+
 		case ADC_CLIENT_LOGGING_IN:
 			puts("*** Logging in...");
 			break;
 
 		case ADC_CLIENT_PASSWORD_REQ:
 			puts("*** Requesting password.");
+			break;
 
 		case ADC_CLIENT_LOGGED_IN:
 			puts("*** Logged in.");
@@ -40,7 +60,7 @@ static int handle(struct ADC_client* client, enum ADC_client_callback_type type,
 			break;
 
 		case ADC_CLIENT_USER_JOIN:
-			printf("    JOIN: %s\n", data->user->name);
+			printf("    JOIN: %s %s\n", sid_to_string(data->user->sid), data->user->name);
 			break;
 
 		case ADC_CLIENT_USER_QUIT:
@@ -80,10 +100,7 @@ int main(int argc, char** argv)
 	ADC_client_set_callback(&client, handle);
 	ADC_client_connect(&client, argv[1]);
 
-	while (running)
-	{
-		net_backend_process();
-	}
+	while (running && net_backend_process()) { }
 
 	ADC_client_destroy(&client);
 	net_destroy();

src/tools/fuzzer.h

@@ -1,3 +1,22 @@
+/*
+ * 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/>.
+ *
+ */
+
 enum commandMode
 {
 	cm_bcast    = 0x01, /* B - broadcast */

src/tools/uhub-passwd.c

@@ -0,0 +1,341 @@
+/*
+ * 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 <sqlite3.h>
+
+// #define DEBUG_SQL
+
+static sqlite3* db = NULL;
+static const char* command = NULL;
+static const char* filename = NULL;
+static const char* binary = NULL;
+
+typedef int (*command_func_t)(size_t, const char**);
+
+static int create(size_t argc, const char** argv);
+static int list(size_t argc, const char** argv);
+static int pass(size_t argc, const char** argv);
+static int add(size_t argc, const char** argv);
+static int del(size_t argc, const char** argv);
+static int mod(size_t argc, const char** argv);
+
+static struct commands
+{
+	command_func_t handle;
+	const char* command;
+	const char* usage;
+} COMMANDS[6] = {
+	{ &create, "create", "" },
+	{ &list,   "list",   "" },
+	{ &add,    "add",    "username password [credentials = user]" },
+	{ &del,    "del",    "username" },
+	{ &mod,    "mod",    "username credentials" },
+	{ &pass,   "pass",   "username password" },
+};
+
+static void print_usage(const char* str)
+{
+	fprintf(stderr, "Usage: %s filename %s %s\n", binary, command, str);
+	exit(1);
+}
+
+
+/**
+ * Escape an SQL statement and return a pointer to the string.
+ * NOTE: The returned value needs to be free'd.
+ *
+ * @return an escaped string.
+ */
+static char* sql_escape_string(const char* str)
+{
+	size_t i, n, size;
+	char* buf;
+
+	for (n = 0, size = strlen(str); n < strlen(str); n++)
+		if (str[n] == '\'')
+			size++;
+
+	buf = malloc(size+1);
+	for (n = 0, i = 0; n < strlen(str); n++)
+	{
+		if (str[n] == '\'')
+			buf[i++] = '\'';
+		buf[i++] = str[n];
+	}
+	buf[i++] = '\0';
+	return buf;
+}
+
+/**
+ * Validate credentials.
+ */
+static const char* validate_cred(const char* cred_str)
+{
+	if (!strcmp(cred_str, "admin"))
+		return "admin";
+
+	if (!strcmp(cred_str, "super"))
+		return "super";
+
+	if (!strcmp(cred_str, "op"))
+		return "op";
+
+	if (!strcmp(cred_str, "user"))
+		return "user";
+
+	fprintf(stderr, "Invalid user credentials. Must be one of: 'admin', 'super', 'op' or 'user'\n");
+	exit(1);
+}
+
+
+static void open_database()
+{
+	int res = sqlite3_open(filename, &db);
+
+	if (res)
+	{
+		fprintf(stderr, "Unable to open database: %s (result=%d)\n", filename, res);
+		exit(1);
+	}
+}
+
+static int sql_callback(void* ptr, int argc, char **argv, char **colName) { return 0; }
+
+static int sql_execute(const char* sql, ...)
+{
+	va_list args;
+	char query[1024];
+	char* errMsg;
+	int rc;
+
+	va_start(args, sql);
+	vsnprintf(query, sizeof(query), sql, args);
+
+#ifdef DEBUG_SQL
+	printf("SQL: %s\n", query);
+#endif
+
+	open_database();
+
+	rc = sqlite3_exec(db, query, sql_callback, NULL, &errMsg);
+	if (rc != SQLITE_OK) {
+		fprintf(stderr, "ERROR: %s\n", errMsg);
+		sqlite3_free(errMsg);
+	}
+
+	rc = sqlite3_changes(db);
+	sqlite3_close(db);
+	return rc;
+}
+
+static int create(size_t argc, const char** argv)
+{
+	const char* sql = "CREATE TABLE users"
+		"("
+			"nickname CHAR NOT NULL UNIQUE,"
+			"password CHAR NOT NULL,"
+			"credentials CHAR NOT NULL DEFAULT 'user',"
+			"created TIMESTAMP DEFAULT (DATETIME('NOW')),"
+			"activity TIMESTAMP DEFAULT (DATETIME('NOW'))"
+		");";
+
+	sql_execute(sql);
+	return 0;
+}
+
+
+static int sql_callback_list(void* ptr, int argc, char **argv, char **colName)
+{
+	int* found = (int*) ptr;
+	uhub_assert(strcmp(colName[0], "nickname") == 0 && strcmp(colName[2], "credentials") == 0);
+	printf("%s\t%s\n", argv[2], argv[0]);
+	(*found)++;
+	return 0;
+}
+
+static int list(size_t argc, const char** argv)
+{
+	char* errMsg;
+	int found = 0;
+	int rc;
+
+	open_database();
+
+	rc = sqlite3_exec(db, "SELECT * FROM users;", sql_callback_list, &found, &errMsg);
+	if (rc != SQLITE_OK) {
+#ifdef DEBUG_SQL
+		fprintf(stderr, "SQL: ERROR: %s (%d)\n", errMsg, rc);
+#endif
+		sqlite3_free(errMsg);
+		exit(1);
+	}
+
+	sqlite3_close(db);
+	return 0;
+}
+
+
+static int add(size_t argc, const char** argv)
+{
+	char* user = NULL;
+	char* pass = NULL;
+	const char* cred = NULL;
+	int rc;
+
+	if (argc < 2)
+		print_usage("username password [credentials = user]");
+
+	user = sql_escape_string(argv[0]);
+	pass = sql_escape_string(argv[1]);
+	cred = validate_cred(argv[2] ? argv[2] : "user");
+
+	rc = sql_execute("INSERT INTO users (nickname, password, credentials) VALUES('%s', '%s', '%s');", user, pass, cred);
+
+	free(user);
+	free(pass);
+
+	if (rc != 1)
+	{
+		fprintf(stderr, "Unable to add user \"%s\"\n", argv[0]);
+		return 1;
+	}
+	return 0;
+}
+
+static int mod(size_t argc, const char** argv)
+{
+	char* user = NULL;
+	const char* cred = NULL;
+	int rc;
+
+	if (argc < 2)
+		print_usage("username credentials");
+
+	user = sql_escape_string(argv[0]);
+	cred = validate_cred(argv[1]);
+
+	rc = sql_execute("UPDATE users SET credentials = '%s' WHERE nickname = '%s';", cred, user);
+
+	free(user);
+
+	if (rc != 1)
+	{
+		fprintf(stderr, "Unable to set credentials for user \"%s\"\n", argv[0]);
+		return 1;
+	}
+	return 0;
+}
+
+static int pass(size_t argc, const char** argv)
+{
+	char* user = NULL;
+	char* pass = NULL;
+	int rc;
+
+	if (argc < 2)
+		print_usage("username password");
+
+	user = sql_escape_string(argv[0]);
+	pass = sql_escape_string(argv[1]);
+
+	rc = sql_execute("UPDATE users SET password = '%s' WHERE nickname = '%s';", pass, user);
+
+	free(user);
+	free(pass);
+
+	if (rc != 1)
+	{
+		fprintf(stderr, "Unable to change password for user \"%s\"\n", argv[0]);
+		return 1;
+	}
+	
+	return 0;
+}
+
+
+static int del(size_t argc, const char** argv)
+{
+	char* user = NULL;
+	int rc;
+
+	if (argc < 2)
+		print_usage("username");
+
+	user = sql_escape_string(argv[0]);
+
+	rc = sql_execute("DELETE FROM users WHERE nickname = '%s';", user);
+	free(user);
+
+	if (rc != 1)
+	{
+		fprintf(stderr, "Unable to delete user \"%s\".\n", argv[0]);
+		return 1;
+	}
+
+	return 0;
+}
+
+void main_usage(const char* binary)
+{
+	printf(
+			"Usage: %s filename command [...]\n"
+			"\n"
+			"Command syntax:\n"
+			"  create\n"
+			"  add  username password [credentials = user]\n"
+			"  del  username\n"
+			"  mod  username credentials\n"
+			"  pass username password\n"
+			"  list\n"
+			"\n"
+			"Parameters:\n"
+			"  'filename' is a database file\n"
+			"  'username' is a nickname (UTF-8, up to 64 bytes)\n"
+			"  'password' is a password (UTF-8, up to 64 bytes)\n"
+			"  'credentials' is one of 'admin', 'super', 'op', 'user'\n"
+			"\n"
+		, binary);
+}
+
+int main(int argc, char** argv)
+{
+	size_t n = 0;
+	binary = argv[0];
+	filename = argv[1];
+	command = argv[2];
+
+	if (argc < 3)
+	{
+		main_usage(argv[0]);
+		return 1;
+	}
+
+	for (; n < sizeof(COMMANDS) / sizeof(COMMANDS[0]); n++)
+	{
+		if (!strcmp(command, COMMANDS[n].command))
+			return COMMANDS[n].handle(argc - 2, (const char**) &argv[3]);
+	}
+
+	// Unknown command!
+	main_usage(argv[0]);
+	return 1;
+}
+
+

src/uhub.h

@@ -45,6 +45,7 @@
 
 #define MAX_CID_LEN  39
 #define MAX_NICK_LEN 64
+#define MAX_PASS_LEN 64
 #define MAX_UA_LEN   32
 #define TIGERSIZE    24
 
@@ -57,6 +58,11 @@ extern "C" {
 
 #include "adc/adcconst.h"
 
+#include "util/cbuffer.h"
+#include "util/config_token.h"
+#include "util/credentials.h"
+#include "util/floodctl.h"
+#include "util/getopt.h"
 #include "util/ipcalc.h"
 #include "util/list.h"
 #include "util/log.h"
@@ -66,6 +72,7 @@ extern "C" {
 
 #include "adc/sid.h"
 #include "adc/message.h"
+
 #include "network/network.h"
 #include "network/connection.h"
 #include "network/timeout.h"
@@ -79,10 +86,16 @@ extern "C" {
 #include "core/user.h"
 #include "core/usermanager.h"
 #include "core/route.h"
+#include "core/pluginloader.h"
 #include "core/hub.h"
 #include "core/commands.h"
 #include "core/inf.h"
 #include "core/hubevent.h"
+#include "core/plugincallback.h"
+#include "core/plugininvoke.h"
+#include "core/pluginloader.h"
+
+
 
 #ifdef __cplusplus
 }

src/util/cbuffer.c

@@ -0,0 +1,115 @@
+/*
+ * 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"
+
+#define CBUF_FLAG_CONST_BUFFER 0x01
+
+struct cbuffer
+{
+	size_t capacity;
+	size_t size;
+	size_t flags;
+	char* buf;
+};
+
+extern struct cbuffer* cbuf_create(size_t capacity)
+{
+	struct cbuffer* buf = hub_malloc(sizeof(struct cbuffer));
+	buf->capacity = capacity;
+	buf->size = 0;
+	buf->flags = 0;
+	buf->buf = hub_malloc(capacity + 1);
+	return buf;
+}
+
+struct cbuffer* cbuf_create_const(const char* buffer)
+{
+	struct cbuffer* buf = hub_malloc(sizeof(struct cbuffer));
+	buf->capacity = 0;
+	buf->size = strlen(buffer);
+	buf->flags = CBUF_FLAG_CONST_BUFFER;
+	buf->buf = (char*) buffer;
+	return buf;
+}
+
+void cbuf_destroy(struct cbuffer* buf)
+{
+	if (!(buf->flags & CBUF_FLAG_CONST_BUFFER))
+	{
+		hub_free(buf->buf);
+	}
+	hub_free(buf);
+}
+
+void cbuf_resize(struct cbuffer* buf, size_t capacity)
+{
+	uhub_assert(buf->flags == 0);
+	buf->capacity = capacity;
+	buf->buf = hub_realloc(buf->buf, capacity + 1);
+}
+
+void cbuf_append_bytes(struct cbuffer* buf, const char* msg, size_t len)
+{
+	uhub_assert(buf->flags == 0);
+	if (buf->size + len >= buf->capacity)
+		cbuf_resize(buf, buf->size + len);
+
+	memcpy(buf->buf + buf->size, msg, len);
+	buf->size += len;
+	buf->buf[buf->size] = '\0';
+}
+
+void cbuf_append(struct cbuffer* buf, const char* msg)
+{
+	size_t len = strlen(msg);
+	uhub_assert(buf->flags == 0);
+	cbuf_append_bytes(buf, msg, len);
+}
+
+void cbuf_append_format(struct cbuffer* buf, const char* format, ...)
+{
+	static char tmp[1024];
+	va_list args;
+	int bytes;
+	uhub_assert(buf->flags == 0);
+	va_start(args, format);
+	bytes = vsnprintf(tmp, 1024, format, args);
+	va_end(args);
+	cbuf_append_bytes(buf, tmp, bytes);
+}
+
+void cbuf_append_strftime(struct cbuffer* buf, const char* format, const struct tm* tm)
+{
+	static char tmp[1024];
+	int bytes;
+	uhub_assert(buf->flags == 0);
+	bytes = strftime(tmp, sizeof(tmp), format, tm);
+	cbuf_append_bytes(buf, tmp, bytes);
+}
+
+const char* cbuf_get(struct cbuffer* buf)
+{
+	return buf->buf;
+}
+
+size_t cbuf_size(struct cbuffer* buf)
+{
+	return buf->size;
+}

src/util/cbuffer.h

@@ -0,0 +1,38 @@
+/*
+ * 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_UTIL_CBUFFER_H
+#define HAVE_UTIL_CBUFFER_H
+
+struct cbuffer;
+
+extern struct cbuffer* cbuf_create(size_t capacity);
+extern struct cbuffer* cbuf_create_const(const char* buffer);
+extern void cbuf_destroy(struct cbuffer* buf);
+extern void cbuf_resize(struct cbuffer* buf, size_t capacity);
+extern void cbuf_append_bytes(struct cbuffer* buf, const char* msg, size_t len);
+extern void cbuf_append(struct cbuffer* buf, const char* msg);
+extern void cbuf_append_format(struct cbuffer* buf, const char* format, ...);
+extern void cbuf_append_strftime(struct cbuffer* buf, const char* format, const struct tm* tm);
+
+extern const char* cbuf_get(struct cbuffer* buf);
+extern size_t cbuf_size(struct cbuffer* buf);
+
+
+#endif /* HAVE_UTIL_CBUFFER_H */

src/util/config_token.c

@@ -0,0 +1,273 @@
+/*
+ * 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/>.
+ *
+ */
+
+#include "uhub.h"
+
+#define ADD_CHAR(X) do { *out = X; out++; token_size++; } while(0)
+#define RESET_TOKEN do { ADD_CHAR('\0'); out = buffer; if (cfg_token_add(tokens, out)) token_count++; token_size = 0; buffer[0] = '\0'; } while (0)
+
+struct cfg_tokens
+{
+    struct linked_list* list;
+};
+
+struct cfg_tokens* cfg_tokenize(const char* line)
+{
+	struct cfg_tokens* tokens = (struct cfg_tokens*) hub_malloc_zero(sizeof(struct cfg_tokens));
+	char* buffer = (char*) hub_malloc_zero(strlen(line) + 1);
+	char* out = buffer;
+	const char* p = line;
+	int backslash = 0;
+	char quote = 0;
+	size_t token_count = 0;
+	size_t token_size = 0;
+	tokens->list = list_create();
+
+	for (; *p; p++)
+	{
+		switch (*p)
+		{
+			case '\\':
+				if (backslash)
+				{
+					ADD_CHAR('\\');
+					backslash = 0;
+				}
+				else
+				{
+					backslash = 1;
+				}
+				break;
+
+			case '#':
+				if (backslash)
+				{
+					ADD_CHAR('#');
+					backslash = 0;
+				}
+				else if (quote)
+				{
+					ADD_CHAR('#');
+				}
+				else
+				{
+					RESET_TOKEN;
+					hub_free(buffer);
+					return tokens;
+				}
+				break;
+
+			case '\"':
+				if (backslash)
+				{
+					ADD_CHAR('\"');
+					backslash = 0;
+				}
+				else if (quote)
+				{
+					quote = 0;
+				}
+				else
+				{
+					quote = 1;
+				}
+				break;
+
+			case '\r':
+				/* Pretend it does not exist! */
+				break;
+
+			case ' ':
+			case '\t':
+				if (quote)
+				{
+					ADD_CHAR(*p);
+				}
+				else if (backslash)
+				{
+					ADD_CHAR(*p);
+					backslash = 0;
+				}
+				else
+				{
+					RESET_TOKEN;
+				}
+				break;
+
+			default:
+				ADD_CHAR(*p);
+		}
+	}
+
+	RESET_TOKEN;
+	hub_free(buffer);
+	return tokens;
+}
+
+void cfg_tokens_free(struct cfg_tokens* tokens)
+{
+	if (tokens)
+	{
+		list_clear(tokens->list, hub_free);
+		list_destroy(tokens->list);
+		hub_free(tokens);
+	}
+}
+
+int cfg_token_add(struct cfg_tokens* tokens, char* new_token)
+{
+	if (*new_token)
+	{
+		list_append(tokens->list, hub_strdup(new_token));
+		return 1;
+	}
+	return 0;
+}
+
+size_t cfg_token_count(struct cfg_tokens* tokens)
+{
+	return list_size(tokens->list);
+}
+
+char* cfg_token_get(struct cfg_tokens* tokens, size_t offset)
+{
+	return list_get_index(tokens->list, offset);
+}
+
+char* cfg_token_get_first(struct cfg_tokens* tokens)
+{
+	return list_get_first(tokens->list);
+}
+
+char* cfg_token_get_next(struct cfg_tokens* tokens)
+{
+	return list_get_next(tokens->list);
+}
+
+struct cfg_settings
+{
+	char* key;
+	char* value;
+};
+
+struct cfg_settings* cfg_settings_split(const char* line)
+{
+	struct cfg_settings* s = NULL;
+	struct cfg_tokens* tok = NULL;
+	char* pos = NULL;
+
+	if (   !line
+		|| !*line
+		|| ((pos = (char*) strchr(line, '=')) == NULL)
+		|| ((s = hub_malloc_zero(sizeof(struct cfg_settings))) == NULL)
+		|| ((tok = cfg_tokenize(line)) == NULL)
+		|| (cfg_token_count(tok) < 1)
+		|| (cfg_token_count(tok) > 3)
+		|| (cfg_token_count(tok) == 3 && strcmp(cfg_token_get(tok, 1), "="))
+		)
+	{
+		cfg_tokens_free(tok);
+		cfg_settings_free(s);
+		return NULL;
+	}
+
+	if (cfg_token_count(tok) == 1)
+	{
+		char* key = cfg_token_get_first(tok);
+		pos = strchr(key, '=');
+		if (!pos)
+		{
+			cfg_tokens_free(tok);
+			cfg_settings_free(s);
+			return NULL;
+		}
+
+		pos[0] = 0;
+		key = strip_white_space(key);
+
+		if (!*key)
+		{
+			cfg_tokens_free(tok);
+			cfg_settings_free(s);
+			return NULL;
+		}
+
+		s->key = strdup(key);
+		s->value = strdup(strip_white_space(pos+1));
+	}
+	else if (cfg_token_count(tok) == 2)
+	{
+		char* key = cfg_token_get_first(tok);
+		char* val = cfg_token_get_next(tok);
+
+                if ((pos = strchr(key, '=')))
+		{
+			pos[0] = 0;
+			key = strip_white_space(key);
+		}
+		else if ((pos = strchr(val, '=')))
+		{
+			val = strip_white_space(pos+1);
+		}
+		else
+		{
+			cfg_tokens_free(tok);
+			cfg_settings_free(s);
+			return NULL;
+		}
+
+		if (!*key)
+		{
+			cfg_tokens_free(tok);
+			cfg_settings_free(s);
+			return NULL;
+		}
+
+		s->key = strdup(key);
+		s->value = strdup(val);
+	}
+	else
+	{
+		s->key = strdup(strip_white_space(cfg_token_get(tok, 0)));
+		s->value = strdup(strip_white_space(cfg_token_get(tok, 2)));
+	}
+	cfg_tokens_free(tok);
+	return s;
+}
+
+const char* cfg_settings_get_key(struct cfg_settings* s)
+{
+	return s->key;
+}
+
+const char* cfg_settings_get_value(struct cfg_settings* s)
+{
+	return s->value;
+}
+
+void cfg_settings_free(struct cfg_settings* s)
+{
+	if (s)
+	{
+		hub_free(s->key);
+		hub_free(s->value);
+		hub_free(s);
+	}
+}
+

src/util/config_token.h

@@ -0,0 +1,44 @@
+/*
+ * 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_CONFIG_TOKEN_H
+#define HAVE_UHUB_CONFIG_TOKEN_H
+
+struct cfg_tokens;
+
+struct cfg_tokens* cfg_tokenize(const char* line);
+void cfg_tokens_free(struct cfg_tokens*);
+
+int cfg_token_add(struct cfg_tokens*, char* new_token);
+
+size_t cfg_token_count(struct cfg_tokens*);
+
+char* cfg_token_get(struct cfg_tokens*, size_t offset);
+char* cfg_token_get_first(struct cfg_tokens*);
+char* cfg_token_get_next(struct cfg_tokens*);
+
+
+struct cfg_settings;
+struct cfg_settings* cfg_settings_split(const char* line);
+const char* cfg_settings_get_key(struct cfg_settings*);
+const char* cfg_settings_get_value(struct cfg_settings*);
+void cfg_settings_free(struct cfg_settings*);
+
+#endif /* HAVE_UHUB_CONFIG_TOKEN_H */
+

src/util/credentials.c

@@ -0,0 +1,113 @@
+/*
+ * 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/>.
+ *
+ */
+
+#include "uhub.h"
+
+int auth_cred_is_protected(enum auth_credentials cred)
+{
+	switch (cred)
+	{
+		case auth_cred_bot:
+		case auth_cred_operator:
+		case auth_cred_super:
+		case auth_cred_admin:
+		case auth_cred_link:
+			return 1;
+		default:
+			break;
+	}
+	return 0;
+}
+
+/**
+ * Returns 1 if a user is registered.
+ * Only registered users will be let in if the hub is configured for registered
+ * users only.
+ */
+int auth_cred_is_registered(enum auth_credentials cred)
+{
+	switch (cred)
+	{
+		case auth_cred_bot:
+		case auth_cred_user:
+		case auth_cred_operator:
+		case auth_cred_super:
+		case auth_cred_admin:
+		case auth_cred_link:
+			return 1;
+		default:
+			break;
+	}
+	return 0;
+}
+
+
+const char* auth_cred_to_string(enum auth_credentials cred)
+{
+	switch (cred)
+	{
+		case auth_cred_none:         return "none";
+		case auth_cred_bot:          return "bot";
+		case auth_cred_guest:        return "guest";
+		case auth_cred_user:         return "user";
+		case auth_cred_operator:     return "operator";
+		case auth_cred_super:        return "super";
+		case auth_cred_link:         return "link";
+		case auth_cred_admin:        return "admin";
+	}
+	
+	return "";
+};
+
+int auth_string_to_cred(const char* str, enum auth_credentials* out)
+{
+	if (!str || !*str || !out)
+		return 0;
+
+	switch (strlen(str))
+	{
+		case 2:
+			if (!strcasecmp(str, "op")) { *out = auth_cred_operator; return 1; }
+			return 0;
+
+		case 3:
+			if (!strcasecmp(str, "bot")) { *out = auth_cred_bot; return 1; }
+			if (!strcasecmp(str, "reg")) { *out = auth_cred_user; return 1; }
+			return 0;
+
+		case 4:
+			if (!strcasecmp(str, "none")) { *out = auth_cred_none; return 1; }
+			if (!strcasecmp(str, "user")) { *out = auth_cred_user; return 1; }
+			if (!strcasecmp(str, "link")) { *out = auth_cred_link; return 1; }
+			return 0;
+
+		case 5:
+			if (!strcasecmp(str, "admin")) { *out = auth_cred_admin; return 1; }
+			if (!strcasecmp(str, "super")) { *out = auth_cred_super; return 1; }
+			if (!strcasecmp(str, "guest")) { *out = auth_cred_guest; return 1; }
+			return 0;
+
+		case 8:
+			if (!strcasecmp(str, "operator")) { *out = auth_cred_operator; return 1; }
+			return 0;
+
+		default:
+			return 0;
+	}
+}

src/util/credentials.h

@@ -0,0 +1,57 @@
+/*
+ * 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_CREDENTIALS_H
+#define HAVE_UHUB_CREDENTIALS_H
+
+enum auth_credentials
+{
+	auth_cred_none,                 /**<<< "User has no credentials (not yet logged in)" */
+	auth_cred_bot,                  /**<<< "User is a robot" */
+	auth_cred_guest,                /**<<< "User is a guest (unregistered user)" */
+	auth_cred_user,                 /**<<< "User is identified as a registered user" */
+	auth_cred_operator,             /**<<< "User is identified as a hub operator" */
+	auth_cred_super,                /**<<< "User is a super user" (not used) */
+	auth_cred_link,                 /**<<< "User is a link (not used currently)" */
+	auth_cred_admin,                /**<<< "User is identified as a hub administrator/owner" */
+};
+
+/**
+ * Returns 1 if the credentials means that a user is protected.
+ * Returns 0 otherwise.
+ */
+int auth_cred_is_protected(enum auth_credentials cred);
+
+/**
+ * Returns 1 if a user is registered.
+ * Returns 0 otherwise.
+ * Only registered users will be let in if the hub is configured for registered
+ * users only.
+ */
+int auth_cred_is_registered(enum auth_credentials cred);
+
+/**
+ * Returns a string representation of the credentials enum.
+ */
+const char* auth_cred_to_string(enum auth_credentials cred);
+
+
+int auth_string_to_cred(const char* str, enum auth_credentials* out);
+
+#endif /* HAVE_UHUB_CREDENTIALS_H */

src/util/floodctl.c

@@ -0,0 +1,55 @@
+/*
+ * 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/>.
+ *
+ */
+
+#include "uhub.h"
+
+void flood_control_reset(struct flood_control* data)
+{
+	memset(data, 0, sizeof(struct flood_control));
+}
+
+int  flood_control_check(struct flood_control* data, size_t max_count, size_t time_delay, time_t now)
+{
+	// Is flood control disabled?
+	if (!time_delay || !max_count)
+		return 0;
+
+	if (!data->time)
+	{
+		data->time = now;
+		data->count = 0;
+		return 0;
+	}
+
+	if ((now - data->time) > time_delay)
+	{
+		data->time = now;
+		data->count = 0;
+		return 0;
+	}
+
+	if (data->count <= max_count)
+	{
+		data->count++;
+		return 0;
+	}
+
+	return 1;
+}
+

src/util/floodctl.h

@@ -0,0 +1,47 @@
+/*
+ * 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_FLOOD_CTL_H
+#define HAVE_UHUB_FLOOD_CTL_H
+
+struct flood_control
+{
+	time_t time;
+	size_t count;
+};
+
+/**
+ * Reset flood control statistics
+ */
+void flood_control_reset(struct flood_control*);
+
+/**
+ * @param ctl Flood control data structure
+ * @param max_count Max count for flood control
+ * @param window Time window for max_count to appear.
+ * @param now The current time.
+ * 
+ * @return 0 if flood no flood detected.
+ *         1 if flood detected.
+ */
+int  flood_control_check(struct flood_control* ctl, size_t max_count, size_t window, time_t now);
+
+
+#endif /* HAVE_UHUB_FLOOD_CTL_H */
+

src/util/getopt.c

@@ -0,0 +1,59 @@
+/*
+ * 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"
+
+#ifdef NEED_GETOPT
+
+char *optarg = NULL;
+int optind = 1;
+
+/*
+ * This is a very simple subset of the real getopt().
+ */
+int getopt(int argc, char* const argv[], const char *optstring)
+{
+	int ret;
+	char* pos;
+	char* arg = argv[optind++];
+	optarg = NULL;
+
+	if (optind > argc)
+		return -1;
+
+	if (*arg != '-')
+		return -1;
+
+	arg++;
+	if (*arg == '-')
+		arg++;
+
+	ret = *arg;
+
+	pos = strchr(optstring, ret);
+	if (!pos)
+		return ret;
+
+	if (*(pos+1) == ':')
+		optarg = argv[optind++];
+
+	return ret;
+}
+
+#endif

src/util/getopt.h

@@ -0,0 +1,30 @@
+/*
+ * 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"
+
+#ifdef NEED_GETOPT
+
+extern char* optarg;
+extern int optind;
+
+extern int getopt(int argc, char* const argv[], const char *optstring);
+
+#endif /* NEED_GETOPT */
+

src/util/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,7 +203,6 @@ 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/util/log.c

@@ -51,6 +51,7 @@ static const char* prefixes[] =
 	"DUMP",
 	"MEM",
 	"PROTO",
+	"PLUGIN",
 	0
 };
 
@@ -185,12 +186,12 @@ void hub_log(int log_verbosity, const char *format, ...)
 		
 		if (logfile)
 		{
-			fprintf(logfile, "%s %5s: %s\n", timestamp, prefixes[log_verbosity], logmsg);
+			fprintf(logfile, "%s %6s: %s\n", timestamp, prefixes[log_verbosity], logmsg);
 			fflush(logfile);
 		}
 		else
 		{
-			fprintf(stderr, "%s %5s: %s\n", timestamp, prefixes[log_verbosity], logmsg);	
+			fprintf(stderr, "%s %6s: %s\n", timestamp, prefixes[log_verbosity], logmsg);
 		}
 	}
 

src/util/log.h

@@ -31,6 +31,7 @@ enum log_verbosity {
 	log_dump     = 7,
 	log_memory   = 8,
 	log_protocol = 9,
+	log_plugin   = 10,
 };
 
 #define LOG_FATAL(format, ...)  hub_log(log_fatal,    format, ## __VA_ARGS__)
@@ -42,9 +43,11 @@ enum log_verbosity {
 #ifdef DEBUG
 # define LOG_DEBUG(format, ...)  hub_log(log_debug,    format, ## __VA_ARGS__)
 # define LOG_TRACE(format, ...)  hub_log(log_trace,    format, ## __VA_ARGS__)
+# define LOG_PLUGIN(format, ...) hub_log(log_plugin,   format, ## __VA_ARGS__)
 #else
 # define LOG_DEBUG(format, ...)  do { } while(0)
 # define LOG_TRACE(format, ...)  do { } while(0)
+# define LOG_PLUGIN(format, ...) do { } while(0)
 #endif
 
 #ifdef LOWLEVEL_DEBUG

src/util/memory.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, Jan Vidar Krey
+ * 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
@@ -35,9 +35,11 @@ extern char* debug_mem_strndup(const char* s, size_t n);
 
 #define hub_malloc     malloc
 #define hub_free       free
+#define hub_realloc    realloc
 #define hub_strdup     strdup
 #define hub_strndup    strndup
 
+
 #endif
 
 extern void* hub_malloc_zero(size_t size);

src/util/misc.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,6 +19,8 @@
 
 #include "uhub.h"
 
+static const char* BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
 int is_space(char c)
 {
 	if (c == ' ') return 1;
@@ -279,6 +281,27 @@ int uhub_atoi(const char* value) {
 	return value[0] == '-' ? -val : val;
 }
 
+int is_number(const char* value, int* num)
+{
+	int len = strlen(value);
+	int offset = (value[0] == '-') ? 1 : 0;
+	int val = 0;
+	int i = offset;
+
+	if (!*(value + offset))
+		return 0;
+
+	for (; i < len; i++)
+		if (value[i] > '9' || value[i] < '0')
+			return 0;
+
+	for (i = offset; i< len; i++)
+		val = val*10 + (value[i] - '0');
+	*num = value[0] == '-' ? -val : val;
+
+	return 1;
+}
+
 
 /*
  * FIXME: -INTMIN is wrong!
@@ -291,7 +314,8 @@ const char* uhub_itoa(int val)
 	memset(buf, 0, sizeof(buf));
 	if (!val)
 	{
-		strcat(buf, "0");
+		buf[0] = '0';
+		buf[1] = '\0';
 		return buf;
 	}
 	i = sizeof(buf) - 1;
@@ -312,7 +336,8 @@ const char* uhub_ulltoa(uint64_t val)
 	
 	if (!val)
 	{
-		strcat(buf, "0");
+		buf[0] = '0';
+		buf[1] = '\0';
 		return buf;
 	}
 	i = sizeof(buf) - 1;
@@ -341,7 +366,7 @@ void* memmem(const void *haystack, size_t haystacklen, const void *needle, size_
 	char* c_pat = (char*) needle;
 	char* ptr = memchr(c_buf, c_pat[0], haystacklen);
 	
-	while (ptr && (&ptr[0] - &c_buf[0] < haystacklen))
+	while (ptr && ((size_t) (&ptr[0] - &c_buf[0]) < haystacklen))
 	{
 		if (!memcmp(ptr, c_pat, needlelen))
 			return ptr;
@@ -397,6 +422,110 @@ const char* get_timestamp(time_t now)
 {
 	static char ts[32] = {0, };
 	struct tm* t  = localtime(&now);
-	sprintf(ts, "[%02d:%02d]", t->tm_hour, t->tm_min);
+	snprintf(ts, sizeof(ts), "[%02d:%02d]", t->tm_hour, t->tm_min);
 	return ts;
 }
+
+void strip_off_ini_line_comments(char* line, int line_count)
+{
+	char* p = line;
+	char* out = line;
+	int backslash = 0;
+
+	if (!*line)
+		return;
+
+	for (; *p; p++)
+	{
+		if (!backslash)
+		{
+			if (*p == '\\')
+			{
+				backslash = 1;
+			}
+			else if (*p == '#')
+			{
+				*out = '\0';
+				out++;
+				break;
+			}
+			else
+			{
+				*out = *p;
+				out++;
+			}
+		}
+		else
+		{
+			if (*p == '\\' || *p == '#' || *p == '\"')
+			{
+				*out = *p;
+				out++;
+			}
+			else
+			{
+				LOG_WARN("Invalid backslash escape on line %d", line_count);
+				*out = *p;
+				out++;
+			}
+			backslash = 0;
+		}
+	}
+	*out = '\0';
+}
+
+int string_to_boolean(const char* str, int* boolean)
+{
+	if (!str || !*str || !boolean)
+		return 0;
+
+	switch (strlen(str))
+	{
+		case 1:
+			if      (str[0] == '1') { *boolean = 1; return 1; }
+			else if (str[0] == '0') { *boolean = 0; return 1; }
+			return 0;
+
+		case 2:
+			if (!strcasecmp(str, "on")) { *boolean = 1; return 1; }
+			if (!strcasecmp(str, "no")) { *boolean = 0; return 1; }
+			return 0;
+
+		case 3:
+			if (!strcasecmp(str, "yes")) { *boolean = 1; return 1; }
+			if (!strcasecmp(str, "off")) { *boolean = 0; return 1; }
+			return 0;
+
+		case 4:
+			if (!strcasecmp(str, "true")) { *boolean = 1; return 1; }
+			return 0;
+
+		case 5:
+			if (!strcasecmp(str, "false")) { *boolean = 0; return 1; }
+			return 0;
+
+		default:
+			return 0;
+	}
+}
+
+char* strip_off_quotes(char* line)
+{
+	size_t len;
+
+	if (!*line)
+		return line;
+
+	len = strlen(line);
+	if (len < 2)
+		return line;
+
+	if ((line[0] == '"' && line[len - 1] == '"') ||
+	    (line[0] == '\'' && line[len - 1] == '\''))
+	{
+		line[len-1] = '\0';
+		return line + 1;
+	}
+	return line;
+}
+

src/util/misc.h

@@ -33,20 +33,32 @@ extern int is_valid_base32_char(char c);
 extern void base32_encode(const unsigned char* buffer, size_t len, char* result);
 extern void base32_decode(const char* src, unsigned char* dst, size_t len);
 extern char* strip_white_space(char* string);
+extern void strip_off_ini_line_comments(char* line, int line_count);
+extern char* strip_off_quotes(char* line);
+
+/**
+ * Convert number in str to integer and store it in num.
+ * @return 1 on success, or 0 on error.
+ */
+extern int is_number(const char* str, int* num);
 
 extern int file_read_lines(const char* file, void* data, file_line_handler_t handler);
 
+/**
+ * Convert a string to a boolean (0 or 1).
+ * Example:
+ * "yes", "true", "1", "on" sets 1 in boolean, and returns 1.
+ * "no", "false", "0", "off" sets 0 in boolean, and returns 1.
+ * All other values return 0, and boolean is unchanged.
+ */
+extern int string_to_boolean(const char* str, int* boolean);
+
 
 extern const char* uhub_itoa(int val);
 extern const char* uhub_ulltoa(uint64_t val);
 
 extern int uhub_atoi(const char* value);
 
-#ifdef NEED_ATOLL
-extern int atoll(const char* value);
-#endif
-
-
 #ifndef HAVE_STRNDUP
 extern char* strndup(const char* string, size_t n);
 #endif

tools/convert_to_sqlite.pl

@@ -0,0 +1,42 @@
+#!/usr/bin/perl
+
+# use script 
+# sqlite3 users.db < `tools/convert_to_sqlite.pl /etc/uhub/users.conf`
+
+my $input = $ARGV[0];
+
+
+open (FILE, "$input") || die "# Unable to open input file $input: $!";
+my @lines = <FILE>;
+close (FILE);
+
+print "CREATE TABLE users(nickname CHAR(64) UNIQUE, password CHAR(64), credentials CHAR(5));\n";
+
+foreach my $line (@lines) {
+
+	chomp($line);
+
+	$line =~ s/#.*//g;
+
+	next if ($line =~ /^\s*$/);
+
+	if ($line =~ /^\s*user_(op|admin|super|reg)\s*(.+):(.+)\s*/)
+	{
+		my $cred = $1;
+		my $nick = $2;
+		my $pass = $3;
+		
+		$nick =~ s/'/\\'/g;
+		$pass =~ s/'/\\'/g;
+
+		print "INSERT INTO users VALUES('" . $nick . "', '" . $pass . "', '" . $cred . "');\n";
+	}
+	else
+	{
+		# print "# Warning: Unrecognized line: \"" . $line . "\"\n";
+	}
+}
+
+
+
+

version.h

@@ -1,25 +1,23 @@
+#if !defined(_MSC_VER)
 #include "revision.h"
+#endif
 
 #ifndef PRODUCT
 #define PRODUCT "uhub"
 #endif
 
 #ifndef VERSION
-#define VERSION "0.3.1"
+#define VERSION "0.4.0"
 #endif
 
 #ifndef GIT_REVISION
 #define REVISION ""
 #define PRODUCT_STRING PRODUCT "/" VERSION
 #else
-#define REVISION "(git: " GIT_REVISION ")"
-#ifdef GIT_VERSION
-#define PRODUCT_STRING PRODUCT "/" GIT_VERSION
-#else
-#define PRODUCT_STRING PRODUCT "/" VERSION " " REVISION
-#endif
+#define REVISION "git-" GIT_REVISION
+#define PRODUCT_STRING PRODUCT "/" VERSION "-" REVISION
 #endif
 
 #ifndef COPYRIGHT
-#define COPYRIGHT "Copyright (c) 2007-2010, Jan Vidar Krey <janvidar@extatic.org>"
+#define COPYRIGHT "Copyright (c) 2007-2012, Jan Vidar Krey <janvidar@extatic.org>"
 #endif