Work in progress: libevent use one event per fd.

Signed-off-by: Jan Vidar Krey <janvidar@extatic.org>

.gitignore

@@ -1,8 +0,0 @@
-*~
-*.[oa]
-*.exe
-*.gch
-uhub-admin
-adcrush
-uhub
-

GNUmakefile

@@ -1,6 +1,6 @@
  ##
 ## Makefile for uhub (Use GNU make)
-## Copyright (C) 2007-2010, Jan Vidar Krey <janvidar@extatic.org>
+## Copyright (C) 2007-2008, Jan Vidar Krey <janvidar@extatic.org>
  #
 
 CC            = gcc
@@ -8,11 +8,12 @@ LD            := $(CC)
 MV            := mv
 RANLIB        := ranlib
 CFLAGS        += -pipe -Wall
+USE_PCH       ?= YES
 USE_SSL       ?= NO
-USE_LIBEVENT  ?= NO
 USE_BIGENDIAN ?= AUTO
 BITS          ?= AUTO
 SILENT        ?= YES
+LDLIBS        += -levent
 TERSE         ?= NO
 STACK_PROTECT ?= NO
 
@@ -20,12 +21,6 @@ ifeq ($(OS), Windows_NT)
 WINDOWS       ?= YES
 endif
 
-ifeq (SOLARIS,YES)
-LDLIBS        += -lsocket -lnsl
-endif
-
-CFLAGS        += -I./src/
-
 ifeq ($(WINDOWS),YES)
 USE_BIGENDIAN := NO
 LDLIBS        += -lws2_32
@@ -34,7 +29,6 @@ UHUB_PREFIX   ?= c:/uhub/
 CFLAGS        += -mno-cygwin
 LDFLAGS       += -mno-cygwin
 BIN_EXT       ?= .exe
-GIT_REVISION  ?= NO
 else
 DESTDIR       ?= /
 UHUB_CONF_DIR ?= $(DESTDIR)/etc/uhub
@@ -46,16 +40,19 @@ endif
 
 ifeq ($(SILENT),YES)
 	MSG_CC=@echo "  CC:" $(notdir $^) &&
+	MSG_PCH=@echo " PCH:" $(notdir $@) &&
 	MSG_LD=@echo "  LD:" $(notdir $@) &&
 	MSG_AR=@echo "  AR:" $(notdir $@) &&
 else
 	MSG_CC=
+	MSG_PCH=
 	MSG_LD=
 	MSG_AR=
 endif
 
 ifeq ($(TERSE), YES)
 	MSG_CC=@
+	MSG_PCH=@
 	MSG_LD=@
 	MSG_AR=@
 	MSG_CLEAN=-n ""
@@ -63,15 +60,17 @@ else
 	MSG_CLEAN="Clean as a whistle"
 endif
 
-# CFLAGS        += -I/source/libevent
-# LDFLAGS       += -L/source/libevent
 
+
+
+CFLAGS        += -I/source/libevent
+LDFLAGS       += -L/source/libevent
+
+-include release_setup.mk
 ifeq ($(RELEASE),YES)
-CFLAGS        += -O3 -DNDEBUG
+CFLAGS        += -Os -DNDEBUG
-GIT_REVISION  ?= NO
 else
-CFLAGS        += -ggdb -DDEBUG
+CFLAGS        += -g -DDEBUG
-GIT_REVISION  ?= YES
 endif
 
 ifeq ($(STACK_PROTECT),YES)
@@ -89,6 +88,13 @@ CFLAGS        += -finstrument-functions
 CFLAGS        += -DDEBUG_FUNCTION_TRACE
 endif
 
+ifeq ($(USE_PCH),YES)
+PCHSRC=src/uhub.h
+PCH=src/uhub.h.gch
+else
+PCH=
+endif
+
 ifneq ($(BITS), AUTO)
 ifeq ($(BITS), 64)
 CFLAGS        += -m64
@@ -116,59 +122,61 @@ CFLAGS        += -DSSL_SUPPORT
 LDLIBS        += -lssl
 endif
 
-ifeq ($(USE_LIBEVENT),YES)
-CFLAGS        += -DUSE_LIBEVENT
-LDLIBS        += -levent
 ifneq ($(LIBEVENT_PATH),)
 CFLAGS        += -I$(LIBEVENT_PATH)
 LDFLAGS       += -L$(LIBEVENT_PATH)
 endif
-endif
-
-ifeq ($(GIT_REVISION),YES)
-CFLAGS        += -DGIT_REVISION=\"$(shell git show --abbrev-commit | head -n 1 | cut -f 2 -d " ")\"
-endif
 
 # Sources
 libuhub_SOURCES := \
-		src/core/auth.c \
+		src/auth.c \
-		src/core/commands.c \
+		src/commands.c \
-		src/core/config.c \
+		src/config.c \
-		src/core/eventqueue.c \
+		src/eventqueue.c \
-		src/core/hub.c \
+		src/hubevent.c \
-		src/core/hubevent.c \
+		src/hub.c \
-		src/core/hubio.c \
+		src/inf.c \
-		src/core/inf.c \
+		src/ipcalc.c \
-		src/core/netevent.c \
+		src/list.c \
-		src/core/probe.c \
+		src/log.c \
-		src/core/route.c \
+		src/memory.c \
-		src/core/user.c \
+		src/message.c \
-		src/core/usermanager.c \
+		src/misc.c \
-		src/network/connection.c \
+		src/netevent.c \
-		src/network/epoll.c \
+		src/network.c \
-		src/network/libevent.c \
+		src/route.c \
-		src/network/network.c \
+		src/sid.c \
-		src/util/ipcalc.c \
+		src/tiger.c \
-		src/util/list.c \
+		src/user.c \
-		src/util/log.c \
+		src/usermanager.c
-		src/util/memory.c \
-		src/util/misc.c \
-		src/util/rbtree.c \
-		src/util/timeout.c \
-		src/util/tiger.c
 
-libadc_common_SOURCES := \
+uhub_SOURCES := src/main.c
-		src/adc/message.c \
-		src/adc/sid.c
 
-libadc_client_SOURCES := \
+adcrush_SOURCES := src/adcrush.c
-		src/tools/adcclient.c
 
-uhub_SOURCES := src/core/main.c
+uhub_HEADERS := \
-
+		src/adcconst.h \
-adcrush_SOURCES := src/tools/adcrush.c
+		src/auth.h \
-
+		src/config.h \
-admin_SOURCES := src/tools/admin.c
+		src/eventid.h \
+		src/eventqueue.h \
+		src/hubevent.h \
+		src/hub.h \
+		src/inf.h \
+		src/ipcalc.h \
+		src/list.h \
+		src/log.h \
+		src/memory.h \
+		src/message.h \
+		src/misc.h \
+		src/netevent.h \
+		src/network.h \
+		src/route.h \
+		src/sid.h \
+		src/tiger.h \
+		src/uhub.h \
+		src/user.h \
+		src/usermanager.h
 
 autotest_SOURCES := \
 		autotest/test_message.tcc \
@@ -179,49 +187,57 @@ autotest_SOURCES := \
 		autotest/test_hub.tcc \
 		autotest/test_misc.tcc \
 		autotest/test_tiger.tcc \
-		autotest/test_usermanager.tcc \
 		autotest/test_eventqueue.tcc
 
 autotest_OBJECTS = autotest.o
 
 # Source to objects
-libuhub_OBJECTS       := $(libuhub_SOURCES:.c=.o)
+libuhub_OBJECTS := $(libuhub_SOURCES:.c=.o)
-libadc_client_OBJECTS := $(libadc_client_SOURCES:.c=.o)
+uhub_OBJECTS    := $(uhub_SOURCES:.c=.o)
-libadc_common_OBJECTS := $(libadc_common_SOURCES:.c=.o)
+adcrush_OBJECTS := $(adcrush_SOURCES:.c=.o)
 
-uhub_OBJECTS          := $(uhub_SOURCES:.c=.o)
+all_OBJECTS     := $(libuhub_OBJECTS) $(uhub_OBJECTS) $(adcrush_OBJECTS) $(autotest_OBJECTS)
-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)
 
+LIBUHUB=libuhub.a
 uhub_BINARY=uhub$(BIN_EXT)
 adcrush_BINARY=adcrush$(BIN_EXT)
-admin_BINARY=uhub-admin$(BIN_EXT)
 autotest_BINARY=autotest/test$(BIN_EXT)
 
 %.o: %.c
-	$(MSG_CC) $(CC) -c $(CFLAGS) -o $@ $^
+	$(MSG_CC) $(CC) -c $(CFLAGS) -o $@.tmp $^ && \
+	$(MV) $@.tmp $@
 
-all: $(uhub_BINARY)
+all: $(uhub_BINARY) $(PCH)
 
-$(adcrush_BINARY): $(adcrush_OBJECTS) $(libuhub_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
+$(adcrush_BINARY): $(PCH) $(LIBUHUB) $(adcrush_OBJECTS)
-	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
+	$(MSG_LD) $(CC) -o $@.tmp $(adcrush_OBJECTS) $(LIBUHUB) $(LDFLAGS) $(LDLIBS) && \
+        $(MV) $@.tmp $@
 
-$(admin_BINARY): $(admin_OBJECTS) $(libuhub_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
+$(uhub_BINARY): $(PCH) $(LIBUHUB) $(uhub_OBJECTS)
-	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
+	$(MSG_LD) $(CC) -o $@.tmp $(uhub_OBJECTS) $(LIBUHUB) $(LDFLAGS) $(LDLIBS) && \
+	$(MV) $@.tmp $@
 
-$(uhub_BINARY): $(uhub_OBJECTS) $(libuhub_OBJECTS) $(libadc_common_OBJECTS)
+$(LIBUHUB): $(libuhub_OBJECTS)
-	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
+	$(MSG_AR) $(AR) rc $@.tmp $^ && \
+	$(RANLIB) $@.tmp && \
+	$(MV) $@.tmp $@
+
+ifeq ($(USE_PCH),YES)
+$(PCH): $(uhub_HEADERS)
+	$(MSG_PCH) $(CC) $(CFLAGS) -o $@.tmp $(PCHSRC) && \
+	$(MV) $@.tmp $@
+endif
 
 autotest.c: $(autotest_SOURCES)
 	$(shell exotic --standalone $(autotest_SOURCES) > $@)
 
 $(autotest_OBJECTS): autotest.c
-	$(MSG_CC) $(CC) -c $(CFLAGS) -Isrc -o $@ $<
+	$(MSG_CC) $(CC) -c $(CFLAGS) -Isrc -o $@.tmp $< && \
+	$(MV) $@.tmp $@
 
-$(autotest_BINARY): $(autotest_OBJECTS) $(libuhub_OBJECTS) $(libadc_common_OBJECTS) $(libadc_client_OBJECTS)
+$(autotest_BINARY): $(autotest_OBJECTS) $(LIBUHUB)
-	$(MSG_LD) $(CC) -o $@ $^ $(LDFLAGS) $(LDLIBS)
+	$(MSG_LD) $(CC) -o $@.tmp $^ $(LDFLAGS) $(LDLIBS) && \
+	$(MV) $@.tmp $@
 
 autotest: $(autotest_BINARY)
 	@./$(autotest_BINARY) -s -f
@@ -241,10 +257,11 @@ install: $(uhub_BINARY)
 endif
 
 dist-clean:
-	@rm -rf $(all_OBJECTS) *~ core
+	@rm -rf $(all_OBJECTS) $(PCH) *~ core
 
 clean:
-	@rm -rf $(libuhub_OBJECTS) *~ core $(uhub_BINARY) $(admin_BINARY) $(autotest_BINARY) $(adcrush_BINARY) $(all_OBJECTS) autotest.c && \
+	@rm -rf $(libuhub_OBJECTS) $(PCH) *~ core $(uhub_BINARY) $(LIBUHUB) $(all_OBJECTS) && \
 	echo $(MSG_CLEAN)
 
+-include release_targets.mk
 

autotest/test_hub.tcc

@@ -10,8 +10,8 @@ static void create_test_user()
 	if (g_user)
 		return;
 
-	g_user = (struct hub_user*) malloc(sizeof(struct hub_user));
+	g_user = (struct user*) malloc(sizeof(struct user));
-	memset(g_user, 0, sizeof(struct hub_user));
+	memset(g_user, 0, sizeof(struct user));
 	memcpy(g_user->id.nick, "exotic-tester", 13);
 	g_user->sid = 1;
 }
@@ -67,5 +67,5 @@ EXO_TEST(hub_service_shutdown, {
 });
 
 EXO_TEST(hub_net_shutdown, {
-	return (net_destroy() != -1);
+	return (net_shutdown() != -1);
 });

autotest/test_inf.tcc

@@ -5,17 +5,17 @@
 #define USER_NICK "Friend"
 #define USER_SID "AAAB"
 
-static struct hub_user* inf_user       = 0;
+static struct user* inf_user       = 0;
 static struct hub_info* inf_hub    = 0;
 
-extern int hub_handle_info_login(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd);
+extern int hub_handle_info_login(struct user* user, struct adc_message* cmd);
 
 static void inf_create_hub()
 {
 	inf_hub = (struct hub_info*) hub_malloc_zero(sizeof(struct hub_info));
-	inf_hub->users = (struct hub_user_manager*) hub_malloc_zero(sizeof(struct hub_user_manager));
+	inf_hub->users = (struct user_manager*) hub_malloc_zero(sizeof(struct user_manager));
 	inf_hub->users->list = list_create();
-	inf_hub->users->sids = sid_pool_create(500);
+	inf_hub->users->free_sid = 1;
 	
 	inf_hub->acl = (struct acl_handle*) hub_malloc_zero(sizeof(struct acl_handle));
 	inf_hub->config = (struct hub_config*) hub_malloc_zero(sizeof(struct hub_config));
@@ -27,23 +27,16 @@ static void inf_create_hub()
 static void inf_destroy_hub()
 {
 	/* FIXME */
-	list_destroy(inf_hub->users->list);
-	sid_pool_destroy(inf_hub->users->sids);
-	acl_shutdown(inf_hub->acl);
-	free_config(inf_hub->config);
-	hub_free(inf_hub->users);
-	hub_free(inf_hub->acl);
-	hub_free(inf_hub->config);
-	hub_free(inf_hub);
 }
 
 
 static void inf_create_user()
 {
 	if (inf_user) return;
-	inf_user = (struct hub_user*) hub_malloc_zero(sizeof(struct hub_user));
+	inf_user = (struct user*) hub_malloc_zero(sizeof(struct user));
-	inf_user->connection = net_con_create();
 	inf_user->id.sid = 1;
+	inf_user->sd  = -1;
+	inf_user->hub = inf_hub;
 	inf_user->limits.upload_slots = 1;
 }
 
@@ -62,13 +55,13 @@ EXO_TEST(inf_create_setup,
 });
 
 
-/* FIXME: MEMORY LEAK - Need to fix hub_handle_info_login */
+
 #define CHECK_INF(MSG, EXPECT) \
 	struct adc_message* msg = adc_msg_parse_verify(inf_user, MSG, strlen(MSG)); \
-	int ok = hub_handle_info_login(inf_hub, inf_user, msg); /* FIXME: MEMORY LEAK */ \
+	int ok = hub_handle_info_login(inf_user, msg); \
 	adc_msg_free(msg); \
-	if (ok == EXPECT) \
+	if (ok != EXPECT) \
-		user_set_info(inf_user, 0); \
+		printf("Expected %d, got %d\n", EXPECT, ok); \
 	return ok == EXPECT;
 	
 
@@ -113,7 +106,7 @@ EXO_TEST(inf_nick_10, {
 	struct adc_message* msg = adc_msg_parse_verify(inf_user, line, strlen(line));
 	
 	adc_msg_add_named_argument(msg, "NI", nick);
-	int ok = hub_handle_info_login(inf_hub, inf_user, msg);
+	int ok = hub_handle_info_login(inf_user, msg);
 	adc_msg_free(msg);
 	if (ok != status_msg_inf_error_nick_not_utf8)
 		printf("Expected %d, got %d\n", status_msg_inf_error_nick_not_utf8, ok);

autotest/test_ipfilter.tcc

@@ -9,8 +9,8 @@ static struct ip_addr_encap ip6_a;
 static struct ip_addr_encap ip6_b;
 static struct ip_addr_encap ip6_c;
 static struct ip_addr_encap mask;
-static struct ip_range ban6;
+static struct ip_ban_record ban6;
-static struct ip_range ban4;
+static struct ip_ban_record ban4;
 
 EXO_TEST(prepare_network, {
     return net_initialize() == 0;
@@ -405,74 +405,74 @@ EXO_TEST(check_ban_setup_1, {
 
 EXO_TEST(check_ban_ipv4_1, {
 	struct ip_addr_encap addr; ip_convert_to_binary("192.168.0.0", &addr);
-	return ip_in_range(&addr, &ban4);
+	return acl_check_ip_range(&addr, &ban4);
 });
 
 EXO_TEST(check_ban_ipv4_2, {
 	struct ip_addr_encap addr; ip_convert_to_binary("192.168.0.1", &addr);
-	return ip_in_range(&addr, &ban4);
+	return acl_check_ip_range(&addr, &ban4);
 });
 
 EXO_TEST(check_ban_ipv4_3, {
 	struct ip_addr_encap addr; ip_convert_to_binary("192.168.0.255", &addr);
-	return ip_in_range(&addr, &ban4);
+	return acl_check_ip_range(&addr, &ban4);
 });
 
 EXO_TEST(check_ban_ipv4_4, {
 	struct ip_addr_encap addr; ip_convert_to_binary("192.168.1.0", &addr);
-	return !ip_in_range(&addr, &ban4);
+	return !acl_check_ip_range(&addr, &ban4);
 });
 
 EXO_TEST(check_ban_ipv4_5, {
 	struct ip_addr_encap addr; ip_convert_to_binary("192.167.255.255", &addr);
-	return !ip_in_range(&addr, &ban4);
+	return !acl_check_ip_range(&addr, &ban4);
 });
 
 EXO_TEST(check_ban_ipv6_1, {
 	if (!ipv6) return 1;
 	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:0", &addr);
-	return ip_in_range(&addr, &ban6);
+	return acl_check_ip_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_ipv6_2, {
 	if (!ipv6) return 1;
 	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:1", &addr);
-	return ip_in_range(&addr, &ban6);
+	return acl_check_ip_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_ipv6_3, {
 	if (!ipv6) return 1;
 	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:fffe", &addr);
-	return ip_in_range(&addr, &ban6);
+	return acl_check_ip_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_ipv6_4, {
 	if (!ipv6) return 1;
 	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefa:ffff", &addr);
-	return ip_in_range(&addr, &ban6);
+	return acl_check_ip_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_ipv6_5, {
 	if (!ipv6) return 1;
 	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fefb:0", &addr);
-	return !ip_in_range(&addr, &ban6);
+	return !acl_check_ip_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_ipv6_6, {
 	if (!ipv6) return 1;
 	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fef9:ffff", &addr);
-	return !ip_in_range(&addr, &ban6);
+	return !acl_check_ip_range(&addr, &ban6);
 });
 
 EXO_TEST(check_ban_afmix_1, {
 	if (!ipv6) return 1;
 	struct ip_addr_encap addr; ip_convert_to_binary("2001::201:2ff:fef9:ffff", &addr);
-	return !ip_in_range(&addr, &ban4);
+	return !acl_check_ip_range(&addr, &ban4);
 });
 
 EXO_TEST(check_ban_afmix_2, {
 	struct ip_addr_encap addr; ip_convert_to_binary("10.20.30.40", &addr);
-	return !ip_in_range(&addr, &ban6);
+	return !acl_check_ip_range(&addr, &ban6);
 });
 
 EXO_TEST(ip4_bitwise_AND_1, {
@@ -594,28 +594,6 @@ EXO_TEST(ip6_bitwise_OR_3, {
 	return !strcmp(ip_convert_to_string(&ip6_c), "7777:cccc:3333:1111:ffff:ffff:ffff:1c1c");
 });
 
-EXO_TEST(ip_range_1, {
-	struct ip_range range; memset(&range, 0, sizeof(range));
-	return ip_convert_address_to_range("192.168.0.1", &range) && memcmp(&range.lo, &range.hi, sizeof(struct ip_addr_encap)) == 0;
-});
-
-EXO_TEST(ip_range_2, {
-	struct ip_range range; memset(&range, 0, sizeof(range));
-	return ip_convert_address_to_range("192.168.0.0-192.168.255.255", &range) && range.lo.af == range.hi.af && memcmp(&range.lo, &range.hi, sizeof(struct ip_addr_encap)) != 0;
-});
-
-EXO_TEST(ip_range_3, {
-	struct ip_range range; memset(&range, 0, sizeof(range));
-	return ip_convert_address_to_range("192.168.0.0/16", &range) && range.lo.af == range.hi.af && memcmp(&range.lo, &range.hi, sizeof(struct ip_addr_encap)) != 0;
-});
-
-EXO_TEST(ip_range_4, {
-	struct ip_range range1; memset(&range1, 0, sizeof(range1));
-	struct ip_range range2; memset(&range2, 0, sizeof(range2));
-	return ip_convert_address_to_range("192.168.0.0/16", &range1) && ip_convert_address_to_range("192.168.0.0-192.168.255.255", &range2) && memcmp(&range1, &range2, sizeof(struct ip_range)) == 0;
-});
-
-
 EXO_TEST(shutdown_network, {
-    return net_destroy() == 0;
+    return net_shutdown() == 0;
 });

autotest/test_message.tcc

@@ -1,5 +1,5 @@
 #include <uhub.h>
-static struct hub_user* g_user = 0;
+static struct user* g_user = 0;
 static const char* test_string1 = "IINF AAfoo BBbar CCwhat\n";
 static const char* test_string2 = "BMSG AAAB Hello\\sWorld!\n";
 static const char* test_string3 = "BINF AAAB IDAN7ZMSLIEBL53OPTM7WXGSTXUS3XOY6KQS5LBGX NIFriend DEstuff SL3 SS0 SF0 VEQuickDC/0.4.17 US6430 SUADC0,TCP4,UDP4 I4127.0.0.1 HO5 HN1 AW\n";
@@ -11,17 +11,12 @@ static void create_test_user()
 	if (g_user)
 		return;
 
-	g_user = (struct hub_user*) malloc(sizeof(struct hub_user));
+	g_user = (struct user*) malloc(sizeof(struct user));
-	memset(g_user, 0, sizeof(struct hub_user));
+	memset(g_user, 0, sizeof(struct user));
 	memcpy(g_user->id.nick, "exotic-tester", 13);
 	g_user->id.sid = 1;
 }
 
-EXO_TEST(adc_message_first, {
-	create_test_user();	
-	return g_user != 0;
-});
-
 EXO_TEST(adc_message_parse_1, {
 	struct adc_message* msg = adc_msg_create("IMSG Hello\\sWorld!");
 	int ok = msg != NULL;
@@ -31,12 +26,11 @@ EXO_TEST(adc_message_parse_1, {
 
 EXO_TEST(adc_message_parse_2, {
 	struct adc_message* msg = adc_msg_create(test_string2);
-	int ok = (msg != NULL);
+	return msg == NULL;
-	adc_msg_free(msg);
-	return ok;
 });
 
 EXO_TEST(adc_message_parse_3, {
+	create_test_user();
 	struct adc_message* msg = adc_msg_parse_verify(g_user, "BMSG AAAB Hello\\sWorld!", 23);
 	int ok = msg != NULL;
 	adc_msg_free(msg);
@@ -514,22 +508,13 @@ EXO_TEST(adc_message_update_3, {
 	return updater2 != NULL;
 });
 
+extern void update_user_info(struct user* u, struct adc_message* cmd);
+
 EXO_TEST(adc_message_update_4, {
-	user_update_info(g_user, updater2);
+	update_user_info(g_user, updater2);
 	return strlen(g_user->info->cache) == 159;
 });
 
-EXO_TEST(adc_message_update_4_cleanup, {
-	adc_msg_free(updater1);
-	updater1 = 0;
-	adc_msg_free(updater2);
-	updater2 = 0;
-	adc_msg_free(g_user->info);
-	g_user->info = 0;
-	return 1;
-});
-
-
 EXO_TEST(adc_message_empty_1, {
 	struct adc_message* msg = adc_msg_parse_verify(g_user, test_string2, strlen(test_string2));
 	int ok = adc_msg_is_empty(msg) == 0;
@@ -551,10 +536,3 @@ EXO_TEST(adc_message_empty_3, {
 	return ok;
 });
 
-EXO_TEST(adc_message_last, {
-	hub_free(g_user);
-	g_user = 0;
-	return g_user == 0;
-});
-
-

autotest/test_usermanager.tcc

@@ -1,109 +0,0 @@
-#include <uhub.h>
-
-#define MAX_USERS 64
-
-static struct hub_info um_hub;
-static struct hub_user um_user[MAX_USERS];
-// static struct net_connection um_cons[MAX_USERS];
-
-EXO_TEST(um_test_setup, {
-	int i = 0;
-	memset(&um_hub,  0, sizeof(um_hub));
-	
-	for (i = 0; i < MAX_USERS; i++)
-	{
-/*		memset(&um_cons[i], 0, sizeof(struct net_connection));
-		um_cons[i].sd = -1;
-
-		memset(&um_user[i], 0, sizeof(struct hub_user));
-		um_user[i].id.sid = i+1;
-		um_user[i].connection = &um_cons[i];*/
-	}
-	return 1;
-});
-
-EXO_TEST(um_init_1, {
-	return uman_init(0) != 0;
-});
-
-EXO_TEST(um_init_2, {
-	return uman_init(&um_hub) == 0;
-});
-
-EXO_TEST(um_shutdown_1, {
-	return uman_shutdown(0) == -1;
-});
-
-EXO_TEST(um_shutdown_2, {
-	return uman_shutdown(&um_hub) == 0;
-});
-
-EXO_TEST(um_shutdown_3, {
-	return uman_shutdown(&um_hub) == -1;
-});
-
-EXO_TEST(um_init_3, {
-	return uman_init(&um_hub) == 0;
-});
-
-EXO_TEST(um_add_1, {
-	return uman_add(&um_hub, &um_user[0]) == 0;
-});
-
-EXO_TEST(um_size_1, {
-	return hub_get_user_count(&um_hub) == 1;
-});
-
-
-EXO_TEST(um_remove_1, {
-	return uman_remove(&um_hub, &um_user[0]) == 0;
-});
-
-EXO_TEST(um_size_2, {
-	return hub_get_user_count(&um_hub) == 0;
-});
-
-
-EXO_TEST(um_add_2, {
-	int i;
-	for (i = 0; i < MAX_USERS; i++)
-	{
-		if (uman_add(&um_hub, &um_user[i]) != 0)
-			return 0;
-	}
-	return 1;
-});
-
-EXO_TEST(um_size_3, {
-	return hub_get_user_count(&um_hub) == MAX_USERS;
-});
-
-EXO_TEST(um_add_3, {
-	return uman_add(&um_hub, &um_user[5]) != 0;
-});
-
-EXO_TEST(um_remove_2, {
-	int i;
-	for (i = 0; i < MAX_USERS; i++)
-	{
-		if (uman_remove(&um_hub, &um_user[i]) != 0)
-			return 0;
-	}
-	return 1;
-});
-
-
-
-
-
-
-
-
-
-
-
-
-/* Last test */
-EXO_TEST(um_shutdown_4, {
-	return uman_shutdown(&um_hub) == 0;
-});

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

@@ -1,101 +0,0 @@
-#!/bin/sh
-#
-# chkconfig: - 91 35
-# description: Starts and stops the Uhub ( http://www.extatic.org/uhub ) daemons on RHEL\CentOS \
-#	       used to provide p2p network services.
-#
-# pidfile: /var/run/uhub.pid
-# config:  /etc/uhub/uhub.conf
-
-
-
-# Source function library.
-if [ -f /etc/init.d/functions ] ; then
-  . /etc/init.d/functions
-elif [ -f /etc/rc.d/init.d/functions ] ; then
-  . /etc/rc.d/init.d/functions
-else
-  exit 1
-fi
-
-# Avoid using root's TMPDIR
-unset TMPDIR
-
-# Source networking configuration.
-. /etc/sysconfig/network
-
-if [ -f /etc/sysconfig/uhub ]; then
-   . /etc/sysconfig/uhub
-fi
-
-# Check that networking is up.
-[ ${NETWORKING} = "no" ] && exit 1
-
-# Check that uhub.conf exists.
-[ -f /etc/uhub/uhub.conf ] || exit 6
-
-RETVAL=0
-
-
-start() {
-        KIND="UHUB"
-	echo -n $"Starting $KIND services: "
-	daemon uhub $UHUBOPTIONS
-	RETVAL=$?
-        echo "" 
-	return $RETVAL
-}	
-
-stop() {
-        KIND="UHUB"
-	echo -n $"Shutting down $KIND services: "
-	killproc uhub
-	RETVAL=$?
-	echo ""
-	return $RETVAL
-}	
-
-restart() {
-	stop
-	start
-}	
-
-reload() {
-        echo -n $"Reloading uhub.conf / user.conf file: "
-	killproc uhub -HUP
-	RETVAL=$?
-	echo ""
-	return $RETVAL
-}	
-
-rhstatus() {
-	status uhub                                                                                                                                                   
-        RETVAL=$?                                                                                                                                                     
-        if [ $RETVAL -ne 0 ] ; then                                                                                                                                   
-                return $RETVAL                                                                                                                                        
-        fi                                                                                                                                                            
-}                 
-
-
-case "$1" in
-  start)
-  	start
-	;;
-  stop)
-  	stop
-	;;
-  restart)
-  	restart
-	;;
-  reload)
-  	reload
-	;;
-  status)
-  	rhstatus
-	;;
-  *)
-	echo $"Usage: $0 {start|stop|restart|reload|status}"
-	exit 2
-esac
-
-exit $?

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

@@ -1,15 +0,0 @@
-# Options to UHUB
-#  -v          Verbose mode. Add more -v's for higher verbosity.
-#  -q          Quiet mode - no output
-#  -f          Fork to background
-#  -l <file>   Log messages to given file (default: stderr)
-#  -L          Log messages to syslog
-#  -c <file>   Specify configuration file (default: /etc/uhub/uhub.conf)
-#  -S          Show configuration parameters, but ignore defaults
-#  -u <user>   Run as given user
-#  -g <group>  Run with given group permissions
-#  -p <file>   Store pid in file (process id)
-                                 
-                                                                                                                                             
-UHUBOPTIONS=" -u uhub -f -p /var/run/uhub.pid -l /var/log/uhub.log"
-

doc/uhub.conf

@@ -4,8 +4,7 @@
 #
 # This file is read only to the uhub deamon, and if you
 # make changes to it while uhub is running you can send a
-# HUP signal to it ( $ killall -HUP uhub ), to reparse configuration (only on UNIX). 
+# HUP signal to it, to reparse configuration (only on UNIX). 
-# All configuration directives: http://www.uhub.org/config.php
 
 # Bind to this port and address
 # server_bind_addr=any means listen to "::" if IPv6 is supported
@@ -39,23 +38,6 @@ file_acl=/etc/uhub/users.conf
 # Normally this message is sent to clients when connecting.
 file_motd=/etc/uhub/motd.txt
 
-# Slots\share\hubs limits
-limit_max_hubs_user = 0
-limit_max_hubs_reg = 0
-limit_max_hubs_op = 0
-limit_max_hubs = 0
-limit_min_hubs_user = 0
-limit_min_hubs_reg = 0
-limit_min_hubs_op = 0
-limit_min_share = 0
-#    Example:	
-#    To require users to share at least 1 GB in order to enter the hub:
-#    limit_min_share = 1024
-limit_max_share = 0
-limit_min_slots = 0
-limit_max_slots = 0 
-
-
 # Configure status message as sent to clients in different circumstances.
 msg_hub_full                   = Hub is full
 msg_hub_disabled               = Hub is disabled
@@ -79,12 +61,6 @@ msg_ban_permanently            = Banned permanently
 msg_ban_temporarily            = Banned temporarily
 msg_auth_invalid_password      = Password is wrong
 msg_auth_user_not_found        = User not found in password database
-msg_user_share_size_low	       = User is not sharing enough
-msg_user_share_size_high       = User is sharing too much
-msg_user_slots_low	       = User have too few upload slots
-msg_user_slots_high	       = User have too many upload slots
-msg_user_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
 
 

doc/users.conf

@@ -12,8 +12,8 @@
 # 'ban_cid'    - banned user by cid
 
 # Administrator
-# user_admin    userA:password1
+user_admin    Dj_Offset:uhub
-# user_op       userB:password2
+user_op       janvidar:password
 
 # We don't want users with these names
 deny_nick Hub-Security

src/adc/sid.c

@@ -1,146 +0,0 @@
-/*
- * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, 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"
-
-const char* BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-
-char* sid_to_string(sid_t sid_)
-{
-	static char t_sid[5];
-	sid_t sid = (sid_ & 0xFFFFF); /*  20 bits only */
-	sid_t A, B, C, D = 0;
-	D     = (sid % 32);
-	sid   = (sid - D) / 32;
-	C     = (sid % 32);
-	sid   = (sid - C) / 32;
-	B     = (sid % 32);
-	sid   = (sid - B) / 32;
-	A     = (sid % 32);
-	t_sid[0] = BASE32_ALPHABET[A];
-	t_sid[1] = BASE32_ALPHABET[B];
-	t_sid[2] = BASE32_ALPHABET[C];
-	t_sid[3] = BASE32_ALPHABET[D];
-	t_sid[4] = 0;
-	return t_sid;
-}
-
-
-sid_t string_to_sid(const char* sid)
-{
-	sid_t nsid = 0;
-	sid_t n, x;
-	sid_t factors[] = { 32768, 1024, 32, 1};
-	
-	if (!sid || strlen(sid) != 4) return 0;
-
-	for (n = 0; n < 4; n++) {
-		for (x = 0; x < strlen(BASE32_ALPHABET); x++)
-			if (sid[n] == BASE32_ALPHABET[x]) break;
-		if (x == 32) return 0;
-		nsid += x * factors[n];
-	}
-	return nsid;
-}
-
-/*
- * Session IDs are heavily reused, since they are a fairly scarce
- * resource. Only one (2^10)-1 exist, since it is a four byte base32-encoded
- * value and 'AAAA' (0) is reserved for the hub.
- *
- * Initialize with sid_initialize(), which sets min and max to one, and count to 0.
- *
- * When allocating a session ID:
- * - If 'count' is less than the pool size (max-min), then allocate within the pool
- * - Increase the pool size (see below)
- * - If unable to do that, hub is really full - don't let anyone in!
- *
- * When freeing a session ID:
- * - If the session ID being freed is 'max', then decrease the pool size by one.
- *
- */
-
-struct sid_pool
-{
-	sid_t min;
-	sid_t max;
-	sid_t count;
-	struct hub_user** map;
-};
-
-
-struct sid_pool* sid_pool_create(sid_t max)
-{
-	struct sid_pool* pool = hub_malloc(sizeof(struct sid_pool));
-	if (!pool)
-		return 0;
-
-	pool->min = 1;
-	pool->max = max + 1;
-	pool->count = 0;
-	pool->map = hub_malloc_zero(sizeof(struct hub_user*) * pool->max);
-	if (!pool->map)
-	{
-		hub_free(pool);
-		return 0;
-	}
-	pool->map[0] = (struct hub_user*) pool; /* hack to reserve the first sid. */
-
-#ifdef DEBUG_SID
-	LOG_DUMP("SID_POOL:  max=%d", (int) pool->max);
-#endif
-	return pool;
-}
-
-void sid_pool_destroy(struct sid_pool* pool)
-{
-#ifdef DEBUG_SID
-	LOG_DUMP("SID_POOL:  destroying, current allocs=%d", (int) pool->count);
-#endif
-	hub_free(pool->map);
-	hub_free(pool);
-}
-
-sid_t sid_alloc(struct sid_pool* pool, struct hub_user* user)
-{
-	sid_t n = (++pool->count);
-	for (; (pool->map[n % pool->max]); n++) ;
-
-#ifdef DEBUG_SID
-	LOG_DUMP("SID_ALLOC: %d, user=%p", (int) n, user);
-#endif
-	pool->map[n] = user;
-	return n;
-}
-
-void sid_free(struct sid_pool* pool, sid_t sid)
-{
-#ifdef DEBUG_SID
-	LOG_DUMP("SID_FREE:  %d", (int) sid);
-#endif
-	pool->map[sid] = 0;
-	pool->count--;
-}
-
-struct hub_user* sid_lookup(struct sid_pool* pool, sid_t sid)
-{
-	if (!sid || (sid > pool->max))
-		return 0;
-	return pool->map[sid];
-}

src/adcrush.c

@@ -0,0 +1,951 @@
+/**
+ * An ADC client emulator.
+ */
+
+#include "uhub.h"
+
+#define ADC_CLIENTS_DEFAULT 100
+#define ADC_MAX_CLIENTS 25000
+
+#define ADC_BUFSIZE 16384
+#define ADC_SIDSIZE 4
+#define ADC_CID_SIZE 39
+
+#define BIG_BUFSIZE 131072
+#define TIGERSIZE 24
+
+#define ADC_HANDSHAKE "HSUP ADBASE ADTIGR\n"
+#define ADCRUSH "adcrush/0.2"
+#define ADC_NICK "[BOT]adcrush"
+#define ADC_DESC "crash\\stest\\sdummy"
+
+struct ADC_client;
+
+static void ADC_client_on_disconnected(struct ADC_client*);
+static void ADC_client_on_connected(struct ADC_client*);
+static void ADC_client_on_login(struct ADC_client*);
+static void ADC_client_connect(struct ADC_client*);
+static void ADC_client_disconnect(struct ADC_client*);
+static int  ADC_client_create(struct ADC_client* client, int num);
+static void ADC_client_destroy(struct ADC_client* client);
+
+static int cfg_mode     = 0; // See enum operationMode
+static char* cfg_host   = 0;
+static int cfg_port     = 0;
+static int cfg_debug    = 0; /* debug level */
+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;
+
+static struct sockaddr_in saddr;
+
+enum commandMode
+{
+	cm_bcast    = 0x01, /* B - broadcast */
+	cm_dir      = 0x02, /* D - direct message */
+	cm_echo     = 0x04, /* E - echo message */
+	cm_fcast    = 0x08, /* F - feature cast message */
+	cm_c2h      = 0x10, /* H - client to hub message */
+	cm_h2c      = 0x20, /* I - hub to client message */
+	cm_c2c      = 0x40, /* C - client to client message */
+	cm_udp      = 0x80, /* U - udp message (client to client) */
+};
+
+enum commandValidity
+{
+	cv_protocol = 0x01,
+	cv_identify = 0x02,
+	cv_verify   = 0x04,
+ 	cv_normal   = 0x08,
+};
+
+enum protocolState
+{
+	ps_none     = 0x00, /* none or disconnected */
+	ps_conn     = 0x01, /* connecting... */
+	ps_protocol = 0x02,
+	ps_identify = 0x04,
+	ps_verify   = 0x08,
+	ps_normal   = 0x10,
+};
+
+enum operationMode
+{
+	mode_performance = 0x01,
+	mode_bugs        = 0x02,
+	mode_security    = 0x04,
+	mode_log         = 0x08,
+};
+
+struct commandPattern
+{
+	unsigned char mode; /* see enum commandMode */
+	char cmd[3];
+	unsigned char validity; /* see enum commandValidity */
+};
+
+const struct commandPattern patterns[] =
+{
+	{ cm_c2h | cm_c2c | cm_h2c,                     "SUP", cv_protocol | cv_normal }, /* protocol support */
+	{ cm_bcast | cm_h2c | cm_c2c,                   "INF", cv_identify | cv_verify | cv_normal }, /* info message */
+	{ cm_bcast | cm_h2c | cm_c2c | cm_c2h | cm_udp, "STA", cv_protocol | cv_identify | cv_verify | cv_normal }, /* status message */
+	{ cm_bcast | cm_dir | cm_echo | cm_h2c,         "MSG", cv_normal },   /* chat message */
+	{ cm_bcast | cm_dir | cm_echo | cm_fcast,       "SCH", cv_normal },   /* search */
+	{ cm_dir | cm_udp,                              "RES", cv_normal },   /* search result */
+	{ cm_dir | cm_echo,                             "CTM", cv_normal },   /* connect to me */
+	{ cm_dir | cm_echo,                             "RCM", cv_normal },   /* reversed, connect to me */
+	{ cm_h2c,                                       "QUI", cv_normal },   /* quit message */
+	{ cm_h2c,                                       "GPA", cv_identify }, /* password request */
+	{ cm_c2h,                                       "PAS", cv_verify }    /* password response */
+};
+
+#define MAX_CHAT_MSGS 35
+const char* chat_messages[MAX_CHAT_MSGS] = {
+	"hello",
+	"I'm an annoying robot, configured to chat in order to measure performance of the hub.",
+	"I apologize for the inconvenience.",
+	".",
+	":)",
+	"can anyone help me, pls?",
+	"wtf?",
+	"bullshit",
+	"resistance is futile.", 
+	"You crossed the line first, sir. You squeezed them, you hammered them to the point of desperation. And in their desperation they turned to a man they didn't fully understand.",
+	"beam me up, scotty",
+	"morning",
+	"You know where Harvey is? You know who he is?",
+	"gtg",
+	"thanks",
+	"*punt*",
+	"*nudge*",
+	"that's ok",
+	"...anyway", 
+	"hola",
+	"hey",
+	"hi", 
+	"nevermind",
+	"i think so",
+	"dunno",
+	"debian ftw",
+	"oops",
+	"how do I search?",
+	"how do I enable active mode?",
+	"home, sweet home...",
+	"later",
+	"Good evening, ladies and gentlemen. We are tonight's entertainment! I only have one question. Where is Harvey Dent?",
+	"You know where I can find Harvey? I need to talk to him about something. Just something, a little.",
+	"We really should stop fighting, we'll miss the fireworks!",
+	"Wanna know how I got these scars?",
+};
+
+#define MAX_SEARCH_MSGS 10
+const char* search_messages[MAX_SEARCH_MSGS] = {
+	"ANmp3 TOauto",
+	"ANxxx TOauto",
+	"ANdivx TOauto",
+	"ANtest ANfoo TOauto",
+	"ANwmv TO1289718",
+	"ANbabe TO8981884",
+	"ANpr0n TOauto",
+	"ANmusic TOauto",
+	"ANvideo TOauto",
+	"ANburnout ANps3 TOauto",
+};
+
+struct ADC_client
+{
+	int  sd;
+	int  num;
+	sid_t sid;
+	enum protocolState state;
+	char info[ADC_BUFSIZE];
+	char recvbuf[BIG_BUFSIZE];
+	char sendbuf[BIG_BUFSIZE];
+	size_t s_offset;
+	size_t r_offset;
+	struct event ev_read;
+	struct event ev_write;
+	struct event ev_timer;
+	size_t timeout;
+};
+
+
+
+static void bot_output(struct ADC_client* client, const char* format, ...)
+{
+	char logmsg[1024];
+	va_list args;
+	va_start(args, format);
+	vsnprintf(logmsg, 1024, format, args);
+	va_end(args);
+	if (cfg_mode == mode_log)
+	{
+	    fprintf(stdout, "%s\n", logmsg);
+	}
+	else
+	{
+	    if (cfg_debug)
+		fprintf(stdout, "* [%4d] %s\n", client->num, logmsg);
+	}
+}
+
+static void adc_cid_pid(struct ADC_client* client)
+{
+	char seed[64];
+	char pid[64];
+	char cid[64];
+	uint64_t tiger_res1[3];
+	uint64_t tiger_res2[3];
+
+	/* create cid+pid pair */
+	memset(seed, 0, 64);
+	snprintf(seed, 64, ADCRUSH "%p/%d", client, (int) client->num);
+	
+	tiger((uint64_t*) seed, strlen(seed), tiger_res1);
+	base32_encode((unsigned char*) tiger_res1, TIGERSIZE, pid);
+	tiger((uint64_t*) tiger_res1, TIGERSIZE, tiger_res2);
+	base32_encode((unsigned char*) tiger_res2, TIGERSIZE, cid);
+	
+	cid[ADC_CID_SIZE] = 0;
+	pid[ADC_CID_SIZE] = 0;
+	
+	strcat(client->info, " PD");
+	strcat(client->info, pid);
+	strcat(client->info, " ID");
+	strcat(client->info, cid);
+}
+
+static size_t get_wait_rand(size_t max)
+{
+	static size_t next = 0;
+	if (next == 0) next = (size_t) time(0);
+	next = (next * 1103515245) + 12345;
+	return ((size_t )(next / 65536) % max);
+}
+
+static void client_reschedule_timeout(struct ADC_client* client)
+{
+	size_t next_timeout = 0;
+	struct timeval timeout = { 0, 0 };
+	
+	switch (client->state)
+	{
+		case ps_conn:     next_timeout = 30; break;
+		case ps_protocol: next_timeout = 30; break;
+		case ps_identify: next_timeout = 30; break;
+		case ps_verify:   next_timeout = 30; break;
+		case ps_normal:   next_timeout = 120; break;
+		case ps_none:     next_timeout = 120; break;
+	}
+	
+	if (client->state == ps_normal || client->state == ps_none)
+	{
+		switch (cfg_level)
+		{
+			case 0: /* polite */
+				next_timeout *= 4;
+				break;
+					
+			case 1: /* normal */
+				break;
+				
+			case 2: /* aggressive */
+				next_timeout /= 8;
+				break;
+				
+			case 3: /* excessive */
+				next_timeout /= 16;
+
+			case 4: /* excessive */
+				next_timeout /= 32;
+		}
+
+	}
+
+
+	if (client->state == ps_conn)
+		client->timeout = MAX(next_timeout, 1);
+	else
+		client->timeout = get_wait_rand(MAX(next_timeout, 1));
+
+	if (!client->timeout) client->timeout++;
+
+	timeout.tv_sec = (time_t) client->timeout;
+	evtimer_add(&client->ev_timer, &timeout);
+}
+
+static void set_state_timeout(struct ADC_client* client, enum protocolState state)
+{
+	client->state = state;
+	client_reschedule_timeout(client);
+}
+
+static void send_client(struct ADC_client* client, char* msg)
+{
+	int ret = net_send(client->sd, msg, strlen(msg), UHUB_SEND_SIGNAL);
+	
+	if (cfg_debug > 1)
+	{
+		char* dump = strdup(msg);
+		dump[strlen(msg) - 1] = 0;
+		bot_output(client, "- SEND: '%s'", dump);
+		free(dump);
+	}
+	
+ 	if (ret != strlen(msg))
+	{
+		if (ret == -1)
+		{
+			if (net_error() != EWOULDBLOCK)
+				ADC_client_on_disconnected(client);
+		}
+		else
+		{
+			/* FIXME: Not all data sent! */
+			printf("ret (%d) != msg->length (%d)\n", ret, (int) strlen(msg));
+		}
+	}
+}
+
+
+static void ADC_client_on_connected(struct ADC_client* client)
+{
+	send_client(client, ADC_HANDSHAKE);
+	set_state_timeout(client, ps_protocol);
+	bot_output(client, "connected.");
+}
+
+static void ADC_client_on_disconnected(struct ADC_client* client)
+{
+	event_del(&client->ev_read);
+	event_del(&client->ev_write);
+	
+	net_close(client->sd);
+	client->sd = -1;
+	
+	bot_output(client, "disconnected.");
+	set_state_timeout(client, ps_none);
+}
+
+static void ADC_client_on_login(struct ADC_client* client)
+{
+	bot_output(client, "logged in.");
+	set_state_timeout(client, ps_normal);
+}
+
+
+static void send_client_info(struct ADC_client* client)
+{
+	client->info[0] = 0;
+	strcat(client->info, "BINF ");
+	strcat(client->info, sid_to_string(client->sid));
+	strcat(client->info, " NI" ADC_NICK);
+	if (cfg_clients > 1)
+	{
+	    strcat(client->info, "_");
+	    strcat(client->info, uhub_itoa(client->num));
+	}
+	strcat(client->info, " VE" ADCRUSH);
+	strcat(client->info, " DE" ADC_DESC);
+	strcat(client->info, " I40.0.0.0");
+	strcat(client->info, " EMuhub@extatic.org");
+	strcat(client->info, " SL3");
+	strcat(client->info, " HN1");
+	strcat(client->info, " HR1");
+	strcat(client->info, " HO1");
+	
+	adc_cid_pid(client);
+	
+	strcat(client->info, "\n");
+	
+	send_client(client, client->info);
+}
+
+static void perf_result(struct ADC_client* client, sid_t target, const char* what, const char* token);
+
+static int recv_client(struct ADC_client* client)
+{
+	ssize_t size = 0;
+	if (cfg_mode != mode_performance || (cfg_mode == mode_performance && (get_wait_rand(100) < (90 - (15 * cfg_level)))))
+	{
+		size = net_recv(client->sd, &client->recvbuf[client->r_offset], ADC_BUFSIZE - client->r_offset, 0);
+	}
+	else
+	{
+		if (get_wait_rand(1000) == 99)
+			return -1; /* Can break tings badly! :-) */
+		else
+			return 0;
+	}
+	if (size == 0 || ((size == -1 && net_error() != EWOULDBLOCK)))
+		return -1;
+	client->recvbuf[client->r_offset + size] = 0;
+
+	char* start = client->recvbuf;
+	char* pos;
+	char* lastPos;
+	while ((pos = strchr(start, '\n')))
+	{
+		lastPos = pos;
+		pos[0] = 0;
+		
+		if (cfg_debug > 1)
+		{
+			bot_output(client, "- RECV: '%s'", start);
+		}
+		
+		fourcc_t cmd = 0;
+		if (strlen(start) < 4)
+		{
+			bot_output(client, "Unexpected response from hub: '%s'", start);
+			start = &pos[1];
+			continue;
+		}
+		
+		cmd = FOURCC(start[0], start[1], start[2], start[3]);
+		
+		switch (cmd)
+		{
+			case ADC_CMD_ISUP:
+				break;
+
+			case ADC_CMD_ISID:
+				if (client->state == ps_protocol)
+				{
+					client->sid = string_to_sid(&start[5]);
+					client->state = ps_identify;
+					send_client_info(client);
+					
+				}
+				break;
+				
+			case ADC_CMD_IINF:
+				break;
+			
+			case ADC_CMD_BSCH:
+			case ADC_CMD_FSCH:
+			{
+				if (get_wait_rand(100) > (90 - (10 * cfg_level)) && cfg_mode == mode_performance)
+				{
+					sid_t target = string_to_sid(&start[5]);
+					const char* what = strstr(&start[5], " AN");
+					const char* token = strstr(&start[5], " TO");
+					char* split = 0;
+					if (!token || !what) break;
+					
+					token += 3;
+					what += 3;
+
+					split = strchr(what, ' ');
+					if (!split) break;
+					else split[0] = '0';
+
+					split = strchr(token, ' ');
+					if (split) split[0] = '0';
+
+					perf_result(client, target, what, token);
+
+				}
+				break;
+			}
+			case ADC_CMD_BINF:
+			{
+				if (strlen(start) > 9)
+				{
+					char t = start[9]; start[9] = 0; sid_t sid = string_to_sid(&start[5]); start[9] = t;
+					
+					if (sid == client->sid)
+					{
+						if (client->state == ps_verify || client->state == ps_identify)
+						{
+							ADC_client_on_login(client);
+						}
+					}
+				}
+				break;
+			}
+			
+			case ADC_CMD_ISTA:
+				if (strncmp(start, "ISTA 000", 8))
+				{
+					bot_output(client, "status: '%s'\n", (start + 9));
+				}
+				break;
+				
+			default:
+				break;
+		}
+		
+		start = &pos[1];
+	}
+	
+	client->r_offset = strlen(lastPos);
+	memmove(client->recvbuf, lastPos, strlen(lastPos));
+	memset(&client->recvbuf[client->r_offset], 0, ADC_BUFSIZE-client->r_offset);
+	
+	
+	return 0;
+}
+
+void ADC_client_connect(struct ADC_client* client)
+{
+	struct timeval timeout = { TIMEOUT_IDLE, 0 };
+	net_connect(client->sd, (struct sockaddr*) &saddr, sizeof(struct sockaddr_in));
+	set_state_timeout(client, ps_conn);
+	event_add(&client->ev_read, &timeout);
+	event_add(&client->ev_write, &timeout);
+	bot_output(client, "connecting...");
+}
+
+void ADC_client_wait_connect(struct ADC_client* client)
+{
+	set_state_timeout(client, ps_none);
+	
+}
+
+
+
+void ADC_client_disconnect(struct ADC_client* client)
+{
+	if (client->sd != -1)
+	{
+		net_close(client->sd);
+		client->sd = -1;
+		event_del(&client->ev_read);
+		event_del(&client->ev_write);
+		bot_output(client, "disconnected.");
+		
+		if (running)
+		{
+			ADC_client_destroy(client);
+			ADC_client_create(client, client->num);
+			ADC_client_connect(client);
+		}
+
+	}
+}
+
+static void perf_chat(struct ADC_client* client, int priv)
+{
+	char buf[1024] = { 0, };
+	size_t r = get_wait_rand(MAX_CHAT_MSGS-1);
+	char* msg = adc_msg_escape(chat_messages[r]);
+
+	if (priv)
+	{
+		strcat(buf, "EMSG ");
+		strcat(buf, sid_to_string(client->sid));
+		strcat(buf, " ");
+		strcat(buf, sid_to_string(client->sid));
+	}
+	else
+	{
+		strcat(buf, "BMSG ");
+		strcat(buf, sid_to_string(client->sid));
+	}
+	strcat(buf, " ");
+
+	strcat(buf, msg);
+	hub_free(msg);
+	
+	strcat(buf, "\n");
+	send_client(client, buf);
+}
+
+static void perf_search(struct ADC_client* client)
+{
+	char buf[1024] = { 0, };
+	size_t r = get_wait_rand(MAX_SEARCH_MSGS-1);
+	size_t pst = get_wait_rand(100);
+	
+	if (pst > 80)
+	{
+		strcat(buf, "FSCH ");
+		strcat(buf, sid_to_string(client->sid));
+		strcat(buf, " +TCP4 ");
+	}
+	else
+	{
+		strcat(buf, "BSCH ");
+		strcat(buf, sid_to_string(client->sid));
+		strcat(buf, " ");
+	}
+	strcat(buf, search_messages[r]);
+	strcat(buf, "\n");
+	send_client(client, buf);
+}
+
+static void perf_result(struct ADC_client* client, sid_t target, const char* what, const char* token)
+{
+	char buf[1024] = { 0, };
+	strcat(buf, "DRES ");
+	strcat(buf, sid_to_string(client->sid));
+	strcat(buf, " ");
+	strcat(buf, sid_to_string(target));
+	strcat(buf, " FN" "test/");
+	strcat(buf, what);
+	strcat(buf, ".dat");
+	strcat(buf, " SL" "0");
+	strcat(buf, " SI" "908987128912");
+	strcat(buf, " TR" "5T6YJYKO3WECS52BKWVSOP5VUG4IKNSZBZ5YHBA");
+	strcat(buf, " TO");
+	strcat(buf, token);
+	strcat(buf, "\n");
+	send_client(client, buf);
+}
+
+static void perf_ctm(struct ADC_client* client)
+{
+	char buf[1024] = { 0, };
+	strcat(buf, "DCTM ");
+	strcat(buf, sid_to_string(client->sid));
+	strcat(buf, " ");
+	strcat(buf, sid_to_string(client->sid));
+	strcat(buf, " ");
+	strcat(buf, "ADC/1.0");
+	strcat(buf, " TOKEN111");
+	strcat(buf, sid_to_string(client->sid));
+	strcat(buf, "\n");
+	send_client(client, buf);
+}
+
+
+static void perf_update(struct ADC_client* client)
+{
+	char buf[1024] = { 0, };
+	int n = (int) get_wait_rand(10)+1;
+	
+	strcat(buf, "BINF ");
+	strcat(buf, sid_to_string(client->sid));
+	strcat(buf, " HN");
+	strcat(buf, uhub_itoa(n));
+
+	strcat(buf, "\n");
+	send_client(client, buf);
+}
+
+
+static void perf_normal_action(struct ADC_client* client)
+{
+	size_t r = get_wait_rand(5);
+	size_t p = get_wait_rand(100);
+
+	switch (r)
+	{
+		case 0:
+			if (p > (90 - (10 * cfg_level)))
+			{
+				if (cfg_debug > 1) bot_output(client, "timeout -> disconnect");
+				ADC_client_disconnect(client);
+			}
+			break;
+
+		case 1:
+			if (cfg_chat)
+			{
+				if (cfg_debug > 1) bot_output(client, "timeout -> chat");
+				perf_chat(client, 0);
+				
+			}
+			break;
+
+		case 2:
+			if (cfg_debug > 1) bot_output(client, "timeout -> search");
+			perf_search(client);
+			break;
+
+		case 3:
+			if (cfg_debug > 1) bot_output(client, "timeout -> update");
+			perf_update(client);
+			break;
+
+		case 4:
+			if (cfg_debug > 1) bot_output(client, "timeout -> privmsg");
+			perf_chat(client, 1);
+			break;
+
+		case 5:
+			if (cfg_debug > 1) bot_output(client, "timeout -> ctm/rcm");
+			perf_ctm(client);
+			break;
+
+	}
+
+	client_reschedule_timeout(client);
+}
+
+void event_callback(int fd, short ev, void *arg)
+{
+	struct ADC_client* client = (struct ADC_client*) arg;
+
+	if (ev & EV_READ)
+	{
+		if (recv_client(client) == -1)
+		{
+			ADC_client_on_disconnected(client);
+		}
+	}
+	
+	if (ev & EV_TIMEOUT)
+	{
+		if (client->state == ps_none)
+		{
+			if (client->sd == -1)
+			{
+				ADC_client_create(client, client->num);
+			}
+
+			ADC_client_connect(client);
+		}
+
+		if (fd == -1)
+		{
+			if (client->state == ps_normal && cfg_mode == mode_performance)
+			{
+				perf_normal_action(client);
+			}
+		}
+	}
+	
+	if (ev & EV_WRITE)
+	{
+		if (client->state == ps_conn)
+		{
+			ADC_client_on_connected(client);
+		}
+		else
+		{
+			/* FIXME: Call send again */
+		}
+
+	}
+}
+
+int ADC_client_create(struct ADC_client* client, int num)
+{
+	struct timeval timeout = { 0, 0 };
+	
+	memset(client, 0, sizeof(struct ADC_client));
+	client->num = num;
+	
+	client->sd = net_socket_create(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+	if (client->sd == -1) return -1;
+	
+	event_set(&client->ev_write, client->sd, EV_WRITE, event_callback, client);
+	event_set(&client->ev_read,  client->sd, EV_READ | EV_PERSIST, event_callback, client);
+	
+	net_set_nonblocking(client->sd, 1);
+	
+	timeout.tv_sec = client->timeout;
+	evtimer_set(&client->ev_timer, event_callback, client);
+
+	set_state_timeout(client, ps_none);
+
+	return 0;
+}
+
+void ADC_client_destroy(struct ADC_client* client)
+{
+	ADC_client_disconnect(client);
+	evtimer_del(&client->ev_timer);
+}
+
+
+void runloop(size_t clients)
+{
+	size_t n = 0;
+	struct ADC_client* client[ADC_MAX_CLIENTS];
+
+	for (n = 0; n < clients; n++)
+	{
+		struct ADC_client* c = malloc(sizeof(struct ADC_client));
+		client[n] = c;
+
+		ADC_client_create(c, n);
+		if (n == 0)
+		{
+			ADC_client_connect(c);
+		}
+		else
+		{
+			ADC_client_wait_connect(c);
+		}
+	}
+	
+	event_dispatch();
+
+	for (n = 0; n < clients; n++)
+	{
+		ADC_client_destroy(client[n]);
+		free(client[n]);
+	}
+}
+
+static void print_version()
+{
+	printf(ADCRUSH "\n");
+	printf("Copyright (C) 2008-2009, Jan Vidar Krey\n");
+	printf("\n");
+}
+
+static void print_usage(const char* program)
+{
+	print_version();
+
+	printf("Usage: %s <mode> (adc://<host>:<port>) [options]\n", program);
+	
+	printf("\n");
+	printf("  Modes\n");
+	printf("    perf        Do performance testing using multiple clients\n");
+	printf("    bugs        Bugs mode, use fuzzer to construct pseudo-random commands.\n");
+	printf("    security    Perform security tests for the hub.\n");
+	printf("    log         Connect one client to the hub and log the output hub.\n");
+	
+	printf("\n");
+	printf("  General options\n");
+	printf("    -c          Allow broadcasting chat messages.\n");
+	printf("    -d          Enable debug output.\n");
+	printf("    -q          Quiet mode (no output).\n");
+	
+	printf("\n");
+	printf("  Performance options:\n");
+	printf("    -l <0-3>    Level: 0=polite, 1=normal (default), 2=aggressive, 3=excessive.\n");
+	printf("    -n <num>    Number of concurrent connections\n");
+	
+	printf("\n");
+	
+	exit(0);
+}
+
+
+int set_defaults()
+{
+    switch (cfg_mode)
+    {
+	case mode_performance:
+	    break;
+	case mode_bugs:
+	    break;
+	case mode_security:
+	    break;
+	case mode_log:
+	    cfg_quiet = 0;
+	    cfg_debug = 2;
+	    cfg_clients = 1;
+	    break;
+    }
+    return 1;
+}
+
+int parse_mode(const char* arg)
+{
+	cfg_mode = 0;
+
+	if      (!strcmp(arg, "perf"))
+		cfg_mode = mode_performance;
+	else if (!strcmp(arg, "bugs"))
+		cfg_mode = mode_bugs;
+	else if (!strcmp(arg, "security"))
+		cfg_mode = mode_security;
+	else if (!strcmp(arg, "log"))
+		cfg_mode = mode_log;
+
+	return cfg_mode;
+}
+
+int parse_address(const char* arg)
+{
+	char* split;
+	struct hostent* dns;
+	struct in_addr* addr;
+
+	if (!arg)
+		return 0;
+
+	if (strlen(arg) < 9)
+		return 0;
+	
+	if (strncmp(arg, "adc://", 6))
+		return 0;
+	
+	split = strrchr(arg+6, ':');
+	if (split == 0 || strlen(split) < 2 || strlen(split) > 6)
+		return 0;
+	
+	cfg_port = strtol(split+1, NULL, 10);
+	if (cfg_port <= 0 || cfg_port > 65535)
+		return 0;
+	
+	split[0] = 0;
+
+	dns = gethostbyname(arg+6);
+	if (dns)
+	{
+		addr = (struct in_addr*) dns->h_addr_list[0];
+		cfg_host = strdup(inet_ntoa(*addr));
+	}
+	
+	if (!cfg_host)
+		return 0;
+	
+	return 1;
+}
+
+int parse_arguments(int argc, char** argv)
+{
+	int ok = 1;
+	int opt;
+	for (opt = 3; opt < argc; opt++)
+	{
+		if      (!strcmp(argv[opt], "-c"))
+			cfg_chat = 1;
+		else if (!strncmp(argv[opt], "-d", 2))
+			cfg_debug += strlen(argv[opt]) - 1;
+		else if (!strcmp(argv[opt], "-q"))
+			cfg_quiet = 1;
+		else if (!strcmp(argv[opt], "-l") && (++opt) < argc)
+		{
+			cfg_level = MIN(MAX(uhub_atoi(argv[opt]), 0), 3);
+		}
+		else if (!strcmp(argv[opt], "-n") && (++opt) < argc)
+		{
+			cfg_clients = MIN(MAX(uhub_atoi(argv[opt]), 1), ADC_MAX_CLIENTS);
+		}
+	}
+	return ok;
+}
+
+
+void parse_command_line(int argc, char** argv)
+{
+	if (argc < 2 ||
+		!parse_mode(argv[1]) ||
+		!set_defaults() ||
+		!parse_address(argv[2]) ||
+		!parse_arguments(argc, argv))
+	{
+		print_usage(argv[0]);
+	}
+}
+
+int main(int argc, char** argv)
+{
+	parse_command_line(argc, argv);
+	
+	net_initialize();
+	event_init();
+	
+	memset(&saddr, 0, sizeof(saddr));
+	saddr.sin_family = AF_INET;
+	saddr.sin_port   = htons(cfg_port);
+	net_string_to_address(AF_INET, cfg_host, &saddr.sin_addr);
+	
+	runloop(cfg_clients);
+	net_shutdown();
+
+	return 0;
+}
+

src/auth.c

@@ -55,12 +55,12 @@ static int check_cmd_bool(const char* cmd, struct linked_list* list, char* line,
 		data = strip_white_space(data);
 		if (!*data)
 		{
-			LOG_FATAL("ACL parse error on line %d", line_count);
+			hub_log(log_fatal, "ACL parse error on line %d", line_count);
 			return -1;
 		}
 		
 		list_append(list, hub_strdup(data));
-		LOG_DEBUG("ACL: Deny access for: '%s' (%s)", data, cmd);
+		hub_log(log_debug, "ACL: Deny access for: '%s' (%s)", data, cmd);
 		return 1;
 	}
 	return 0;
@@ -70,7 +70,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 user_access_info* info = 0;
 	
 	if (!strncmp(line, cmd, strlen(cmd)))
 	{
@@ -82,15 +82,15 @@ static int check_cmd_user(const char* cmd, int status, struct linked_list* list,
 		data = strip_white_space(data);
 		if (!*data)
 		{
-			LOG_FATAL("ACL parse error on line %d", line_count);
+			hub_log(log_fatal, "ACL parse error on line %d", line_count);
 			return -1;
 		}
 		
-		info = hub_malloc_zero(sizeof(struct hub_user_access_info));
+		info = hub_malloc_zero(sizeof(struct user_access_info));
 		
 		if (!info)
 		{
-			LOG_ERROR("ACL parse error. Out of memory!");
+			hub_log(log_error, "ACL parse error. Out of memory!");
 			return -1;
 		}
 		
@@ -108,14 +108,14 @@ static int check_cmd_user(const char* cmd, int status, struct linked_list* list,
 		info->password = data_extra ? hub_strdup(data_extra) : 0;
 		info->status = status;
 		list_append(list, info);
-		LOG_DEBUG("ACL: Added user '%s' (%s)", info->username, get_user_credential_string(info->status));
+		hub_log(log_debug, "ACL: Added user '%s' (%s)", info->username, get_user_credential_string(info->status));
 		return 1;
 	}
 	return 0;
 }
 
 
-static void add_ip_range(struct linked_list* list, struct ip_range* info)
+static void add_ip_range(struct linked_list* list, struct ip_ban_record* info)
 {
 	char buf1[INET6_ADDRSTRLEN+1];
 	char buf2[INET6_ADDRSTRLEN+1];
@@ -130,44 +130,125 @@ static void add_ip_range(struct linked_list* list, struct ip_range* info)
 		net_address_to_string(AF_INET6, &info->lo.internal_ip_data.in6, buf1, INET6_ADDRSTRLEN);
 		net_address_to_string(AF_INET6, &info->hi.internal_ip_data.in6, buf2, INET6_ADDRSTRLEN);
 	}
-	LOG_DEBUG("ACL: Deny access for: %s-%s", buf1, buf2);
+	hub_log(log_debug, "ACL: Deny access for: %s-%s", buf1, buf2);
 	
 	list_append(list, info);
 }
 
 
+static int check_ip_range(const char* lo, const char* hi, struct ip_ban_record* info)
+{
+	int ret1, ret2;
+	
+	if ((ip_is_valid_ipv4(lo) && ip_is_valid_ipv4(hi)) ||
+		(ip_is_valid_ipv6(lo) && ip_is_valid_ipv6(hi)))
+	{
+		ret1 = ip_convert_to_binary(lo, &info->lo);
+		ret2 = ip_convert_to_binary(hi, &info->hi);
+		if (ret1 == -1 || ret2 == -1 || ret1 != ret2)
+		{
+			return -1;
+		}
+		return 0;
+	}
+	return -1;
+}
+
+
+static int check_ip_mask(const char* text_addr, int bits, struct ip_ban_record* info)
+{
+	hub_log(log_debug, "ACL: Deny access for: %s/%d", text_addr, bits);
+	
+	if (ip_is_valid_ipv4(text_addr) ||
+		ip_is_valid_ipv6(text_addr))
+	{
+		struct ip_addr_encap addr;
+		struct ip_addr_encap mask1;
+		struct ip_addr_encap mask2;
+		int af = ip_convert_to_binary(text_addr, &addr);  /* 192.168.1.2 */
+		int maxbits = af == AF_INET6 ? 128 : 32;
+		ip_mask_create_left(af, bits, &mask1);            /* 255.255.255.0 */
+		ip_mask_create_right(af, maxbits - bits, &mask2); /* 0.0.0.255 */
+		ip_mask_apply_AND(&addr, &mask1, &info->lo);      /* 192.168.1.0 */
+		ip_mask_apply_OR(&info->lo, &mask2, &info->hi);   /* 192.168.1.255 */
+		return 0;
+	}
+	return -1;
+}
+
+
 static int check_cmd_addr(const char* cmd, struct linked_list* list, char* line, int line_count)
 {
-	char* data;
+	char* data1;
-	struct ip_range* range = 0;
+	char* data2;
+	struct ip_ban_record* info = 0;
+	int cidr_bits = 0;
 		
 	if (!strncmp(line, cmd, strlen(cmd)))
 	{
-		data = &line[strlen(cmd)];
+		data1 = &line[strlen(cmd)];
-		data[0] = '\0';
+		data2 = 0;
-		data++;
+		data1[0] = '\0';
+		data1++;
 		
-		data = strip_white_space(data);
+		data1 = strip_white_space(data1);
-		if (!*data)
+		if (!*data1)
 		{
-			LOG_FATAL("ACL parse error on line %d", line_count);
+			hub_log(log_fatal, "ACL parse error on line %d", line_count);
 			return -1;
 		}
 		
-		range = hub_malloc_zero(sizeof(struct ip_range));
+		info = hub_malloc_zero(sizeof(struct ip_ban_record));
 		
-		if (!range)
+		if (!info)
 		{
-			LOG_ERROR("ACL parse error. Out of memory!");
+			hub_log(log_error, "ACL parse error. Out of memory!");
 			return -1;
 		}
 		
-		if (ip_convert_address_to_range(data, range))
+		/* Extract IP-range */
+		data2 = strrchr(data1, '-');
+		if (data2)
 		{
-			add_ip_range(list, range);
+			cidr_bits = -1;
+			data2[0] = 0;
+			data2++;
+			
+			if (check_ip_range(data1, data2, info) == -1)
+			{
+				hub_free(info);
+				return 0;
+			}
+			
+			add_ip_range(list, info);
+
+			return 1;
+		}
+		else
+		{
+			/* Extract IP-bitmask */
+			data2 = strrchr(data1, '/');
+			if (data2)
+			{
+				data2[0] = 0;
+				data2++;
+				cidr_bits = uhub_atoi(data2);
+			}
+			else
+			{
+				cidr_bits = 128;
+			}
+			
+			if (check_ip_mask(data1, cidr_bits, info) == -1)
+			{
+				hub_free(info);
+				return 0;
+			}
+			
+			add_ip_range(list, info);
+			
 			return 1;
 		}
-		hub_free(range);
 	}
 	return 0;
 }
@@ -185,11 +266,23 @@ static int acl_parse_line(char* line, int line_count, void* ptr_data)
 		pos[0] = 0;
 	}
 	
-	line = strip_white_space(line);
 	if (!*line)
 		return 0;
 
-	LOG_DEBUG("acl_parse_line: '%s'", line);
+#ifdef ACL_DEBUG
+	hub_log(log_trace, "acl_parse_line(): '%s'", line);
+#endif
+	line = strip_white_space(line);
+	
+	if (!*line)
+	{
+		hub_log(log_fatal, "ACL parse error on line %d", line_count);
+		return -1;
+	}
+
+#ifdef ACL_DEBUG
+	hub_log(log_trace, "acl_parse_line: '%s'", line);
+#endif
 	
 	ACL_ADD_USER("bot",        handle->users, cred_bot);
 	ACL_ADD_USER("user_admin", handle->users, cred_admin);
@@ -203,7 +296,7 @@ static int acl_parse_line(char* line, int line_count, void* ptr_data)
 	ACL_ADD_ADDR("deny_ip",    handle->networks);
 	ACL_ADD_ADDR("nat_ip",     handle->nat_override);
 	
-	LOG_ERROR("Unknown ACL command on line %d: '%s'", line_count, line);
+	hub_log(log_error, "Unknown ACL command on line %d: '%s'", line_count, line);
 	return -1;
 }
 
@@ -222,7 +315,7 @@ int acl_initialize(struct hub_config* config, struct acl_handle* handle)
 	
 	if (!handle->users || !handle->cids || !handle->networks || !handle->users_denied || !handle->users_banned || !handle->nat_override)
 	{
-		LOG_FATAL("acl_initialize: Out of memory");
+		hub_log(log_fatal, "acl_initialize: Out of memory");
 		
 		list_destroy(handle->users);
 		list_destroy(handle->users_denied);
@@ -247,7 +340,7 @@ 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 user_access_info* info = (struct user_access_info*) ptr;
 	if (info)
 	{
 		hub_free(info->username);
@@ -311,16 +404,16 @@ int acl_shutdown(struct acl_handle* handle)
 }
 
 
-struct hub_user_access_info* acl_get_access_info(struct acl_handle* handle, const char* name)
+struct user_access_info* acl_get_access_info(struct acl_handle* handle, const char* name)
 {
-	struct hub_user_access_info* info = (struct hub_user_access_info*) list_get_first(handle->users);
+	struct user_access_info* info = (struct user_access_info*) list_get_first(handle->users);
 	while (info)
 	{
 		if (strcasecmp(info->username, name) == 0)
 		{
 			return info;
 		}
-		info = (struct hub_user_access_info*) list_get_next(handle->users);
+		info = (struct user_access_info*) list_get_next(handle->users);
 	}
 	return NULL;
 }
@@ -353,75 +446,19 @@ int acl_is_user_denied(struct acl_handle* handle, const char* data)
 	STR_LIST_CONTAINS(handle->users_denied, 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);
-	if (!data)
-	{
-		LOG_ERROR("ACL error: Out of memory!");
-		hub_free(info);
-		return -1;
-	}
-
-	list_append(handle->users_banned, data);
-	return 0;
-}
-
-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);
-	if (!data)
-	{
-		LOG_ERROR("ACL error: Out of memory!");
-		hub_free(info);
-		return -1;
-	}
-
-	list_append(handle->cids, data);
-	return 0;
-}
-
-int acl_user_unban_nick(struct acl_handle* handle, const char* nick)
-{
-	return -1;
-}
-
-int acl_user_unban_cid(struct acl_handle* handle, const char* cid)
-{
-	return -1;
-}
-
-
 int acl_is_ip_banned(struct acl_handle* handle, const char* ip_address)
 {
 	struct ip_addr_encap raw;
-	struct ip_range* info = (struct ip_range*) list_get_first(handle->networks);
+	struct ip_ban_record* info = (struct ip_ban_record*) list_get_first(handle->networks);
 	ip_convert_to_binary(ip_address, &raw);
 	
 	while (info)
 	{
-		if (ip_in_range(&raw, info))
+		if (acl_check_ip_range(&raw, info))
 		{
 			return 1;
 		}
-		info = (struct ip_range*) list_get_next(handle->networks);
+		info = (struct ip_ban_record*) list_get_next(handle->networks);
 	}
 	return 0;
 }
@@ -429,63 +466,71 @@ int acl_is_ip_banned(struct acl_handle* handle, const char* ip_address)
 int acl_is_ip_nat_override(struct acl_handle* handle, const char* ip_address)
 {
 	struct ip_addr_encap raw;
-	struct ip_range* info = (struct ip_range*) list_get_first(handle->nat_override);
+	struct ip_ban_record* info = (struct ip_ban_record*) list_get_first(handle->nat_override);
 	ip_convert_to_binary(ip_address, &raw);
 	
 	while (info)
 	{
-		if (ip_in_range(&raw, info))
+		if (acl_check_ip_range(&raw, info))
 		{
 			return 1;
 		}
-		info = (struct ip_range*) list_get_next(handle->nat_override);
+		info = (struct ip_ban_record*) list_get_next(handle->nat_override);
 	}
 	return 0;
 }
 
 
+int acl_check_ip_range(struct ip_addr_encap* addr, struct ip_ban_record* info)
+{
+	return (addr->af == info->lo.af && ip_compare(&info->lo, addr) <= 0 && ip_compare(addr, &info->hi) <= 0);
+}
+
 /*
  * This will generate the same challenge to the same user, always.
  * The challenge is made up of the time of the user connected
  * 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* password_generate_challenge(struct user* user)
 {
-	char buf[64];
+	char buf[32];
 	uint64_t tiger_res[3];
 	static char tiger_buf[MAX_CID_LEN+1];
 	
-	// FIXME: Generate a better nonce scheme.
+	snprintf(buf, 32, "%d%d%d", (int) user->tm_connected, (int) user->id.sid, (int) user->sd);
-	snprintf(buf, 64, "%p%d%d", user, (int) user->id.sid, (int) net_con_get_sd(user->connection));
 	
 	tiger((uint64_t*) buf, strlen(buf), (uint64_t*) tiger_res);
 	base32_encode((unsigned char*) tiger_res, TIGERSIZE, tiger_buf);
 	tiger_buf[MAX_CID_LEN] = 0;
+
+#ifdef ACL_DEBUG
+	hub_log(log_trace, "Generating challenge for user %s: '%s'", user->id.nick, tiger_buf);
+#endif
 	return (const char*) tiger_buf;
 }
 
 
-int acl_password_verify(struct acl_handle* acl, struct hub_user* user, const char* password)
+int password_verify(struct user* user, const char* password)
 {
 	char buf[1024];
-	struct hub_user_access_info* access;
+	struct user_access_info* access;
 	const char* challenge;
 	char raw_challenge[64];
 	char password_calc[64];
 	uint64_t tiger_res[3];
 	
 	if (!password || !user || strlen(password) != MAX_CID_LEN)
-		return 0;
+		return password_invalid;
 
-	access = acl_get_access_info(acl, user->id.nick);
+	access = acl_get_access_info(user->hub->acl, user->id.nick);
 	if (!access || !access->password)
-		return 0;
+		return password_invalid;
 
 	if (TIGERSIZE+strlen(access->password) >= 1024)
-		return 0;
+		return password_invalid;
 
-	challenge = acl_password_generate_challenge(acl, user);
+	challenge = password_generate_challenge(user);
 
 	base32_decode(challenge, (unsigned char*) raw_challenge, MAX_CID_LEN);
 
@@ -496,11 +541,14 @@ int acl_password_verify(struct acl_handle* acl, struct hub_user* user, const cha
 	base32_encode((unsigned char*) tiger_res, TIGERSIZE, password_calc);
 	password_calc[MAX_CID_LEN] = 0;
 
+#ifdef ACL_DEBUG
+	hub_log(log_trace, "Checking password %s against %s", password, password_calc);
+#endif
 	if (strcasecmp(password, password_calc) == 0)
 	{
-		return 1;
+		return password_ok;
 	}
-	return 0;
+	return password_invalid;
 }
 
 

src/auth.h

@@ -21,9 +21,21 @@
 #define HAVE_UHUB_ACL_H
 
 struct hub_config;
-struct hub_user;
+struct user;
 struct ip_addr_encap;
 
+enum password_status
+{
+	password_invalid  = 0,
+	password_ok       = 1,
+};
+
+enum acl_status
+{
+	acl_not_found       = 0,
+	acl_found           = 1,
+};
+
 enum user_credentials
 {
 	cred_none,                 /**<<< "User has no credentials (not yet logged in)" */
@@ -38,13 +50,19 @@ enum user_credentials
 
 const char* get_user_credential_string(enum user_credentials cred);
 
-struct hub_user_access_info
+struct user_access_info
 {
 	char* username;          /* name of user, cid or IP range */
 	char* password;          /* password */
 	enum user_credentials status;
 };
 
+struct ip_ban_record
+{
+	struct ip_addr_encap lo;
+	struct ip_addr_encap hi;
+};
+
 struct acl_handle
 {
 	struct linked_list* users;          /* Known users. See enum user_status */
@@ -59,7 +77,7 @@ 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 user_access_info* acl_get_access_info(struct acl_handle* handle, 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);
@@ -67,19 +85,9 @@ extern int acl_is_ip_nat_override(struct acl_handle* handle, const char* ip_addr
 extern int acl_is_user_banned(struct acl_handle* handle, const char* name);
 extern int acl_is_user_denied(struct acl_handle* handle, const char* name);
 
-extern int acl_user_ban_nick(struct acl_handle* handle, const char* nick);
+extern int acl_check_ip_range(struct ip_addr_encap* addr, struct ip_ban_record* info);
-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);
+extern const char* password_generate_challenge(struct user* user);
-
+extern int password_verify(struct user* user, const char* password);
-/**
- * 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);
 
 #endif /* HAVE_UHUB_ACL_H */

src/commands.c

@@ -0,0 +1,193 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2009, 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"
+
+typedef int (*command_handler)(struct user* user, const char* message);
+
+struct commands_handler
+{
+	const char* prefix;
+	size_t length;
+	enum user_credentials cred;
+	command_handler handler;
+	const char* description;
+};
+
+static struct commands_handler command_handlers[];
+
+static void send_message(struct user* user, const char* message)
+{
+	char* buffer = adc_msg_escape(message);
+	struct adc_message* command = adc_msg_construct(ADC_CMD_IMSG, strlen(buffer) + 6);
+	adc_msg_add_argument(command, buffer);
+	route_to_user(user, command);
+	adc_msg_free(command);
+	hub_free(buffer);
+}
+
+static int command_access_denied(struct user* user, const char* command)
+{
+	char temp[64];
+	snprintf(temp, 64, "*** Access denied: \"%s\"", command);
+	send_message(user, temp);
+	return 0;
+}
+
+
+static int command_stats(struct user* user, const char* message)
+{
+	char temp[128];
+	snprintf(temp, 128, "*** Stats: %zu users, peak: %zu. Network (up/down): %d/%d KB/s, peak: %d/%d KB/s",
+	user->hub->users->count,
+	user->hub->users->count_peak,
+	(int) user->hub->stats.net_tx / 1024,
+	(int) user->hub->stats.net_rx / 1024,
+	(int) user->hub->stats.net_tx_peak / 1024,
+	(int) user->hub->stats.net_rx_peak / 1024);
+	
+	send_message(user, temp);
+	return 0;
+}
+
+
+static int command_help(struct user* user, const char* message)
+{
+#define MAX_HELP_MSG 1024
+	size_t n;
+	char msg[MAX_HELP_MSG];
+	msg[0] = 0;
+	strcat(msg, "\n*** Available commands:\n");
+	
+	for (n = 0; command_handlers[n].prefix; n++)
+	{
+		if (command_handlers[n].cred <= user->credentials)
+		{
+			strcat(msg, command_handlers[n].prefix);
+			strcat(msg, " - ");
+			strcat(msg, command_handlers[n].description);
+			strcat(msg, "\n");
+		}
+	}
+	send_message(user, msg);
+    return 0;
+}
+
+static int command_uptime(struct user* user, const char* message)
+{
+	char tmp[128];
+	size_t d;
+	size_t h;
+	size_t m;
+	size_t D = (size_t) difftime(time(0), user->hub->tm_started);
+
+	d = D / (24 * 3600);
+	D = D % (24 * 3600);
+	h = D / 3600;
+	D = D % 3600;
+	m = D / 60;
+
+	tmp[0] = 0;
+	strcat(tmp, "*** Uptime: ");
+
+	if (d)
+	{
+		strcat(tmp, uhub_itoa((int) d));
+		strcat(tmp, " day");
+		if (d != 1) strcat(tmp, "s");
+		strcat(tmp, ", ");
+	}
+
+	if (h < 10) strcat(tmp, "0");
+		strcat(tmp, uhub_itoa((int) h));
+	strcat(tmp, ":");
+	if (m < 10) strcat(tmp, "0");
+		strcat(tmp, uhub_itoa((int) m));
+
+	send_message(user, tmp);
+	return 0;
+}
+
+static int command_kick(struct user* user, const char* message)
+{
+	send_message(user, "*** Kick not implemented!");
+	return 0;
+}
+
+static int command_reload(struct user* user, const char* message)
+{
+	send_message(user, "*** Reloading configuration");
+	user->hub->status = hub_status_restart;
+	return 0;
+}
+
+static int command_shutdown(struct user* user, const char* message)
+{
+	send_message(user, "*** Hub shuting down...");
+	user->hub->status = hub_status_shutdown;
+	return 0;
+}
+
+
+static int command_version(struct user* user, const char* message)
+{
+    send_message(user, "*** Powered by " PRODUCT "/" VERSION);
+    return 0;
+}
+
+static int command_myip(struct user* user, const char* message)
+{
+    char tmp[128];
+    snprintf(tmp, 128, "*** Your IP: %s", ip_convert_to_string(&user->ipaddr));
+    send_message(user, tmp);
+    return 0;
+}
+
+int command_dipatcher(struct user* user, const char* message)
+{
+	size_t n = 0;
+	for (n = 0; command_handlers[n].prefix; n++)
+	{
+		if (!strncmp(message, command_handlers[n].prefix, command_handlers[n].length))
+		{
+			if (command_handlers[n].cred <= user->credentials)
+			{
+				return command_handlers[n].handler(user, message);
+			}
+			else
+			{
+				return command_access_denied(user, &command_handlers[n].prefix[1]);
+			}
+		}
+	}
+	return 1;
+}
+
+static struct commands_handler command_handlers[] = {
+	{ "!help",       5, cred_guest,     command_help,     "Show this help message." },
+	{ "!stats",      6, cred_super,     command_stats,    "Show hub statistics." },
+	{ "!version",    8, cred_guest,     command_version,  "Show hub version info."  },
+	{ "!uptime",     7, cred_guest,     command_uptime,   "Display hub uptime info." },
+	{ "!kick",       5, cred_operator,  command_kick,     "Kick a user" },
+	{ "!reload",     7, cred_admin,     command_reload,   "Reload configuration files." },
+	{ "!shutdown",   9, cred_admin,     command_shutdown, "Shutdown hub." },
+	{ "+myip",       5, cred_guest,     command_myip,     "Show your own IP." },
+	{ 0,             0, cred_none,      command_help,     "{ Last dummy option }" }
+};
+

src/commands.h

@@ -19,4 +19,17 @@
 
 #include "uhub.h"
 
-extern int command_dipatcher(struct hub_info* hub, struct hub_user* user, const char* message);
+#define CHAT_MSG_HANDLED  1
+#define CHAT_MSG_IGNORED  0
+#define CHAT_MSG_INVALID -1
+
+typedef int (*plugin_event_chat_message)(struct hub_info*, struct user*, struct adc_message*);
+
+struct command_info
+{
+	const char* prefix;
+	enum user_credentials cred;
+	plugin_event_chat_message function;
+};
+
+int command_dipatcher(struct user* user, const char* message);

src/config.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2009, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -42,7 +42,7 @@
 		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); \
+			hub_log(log_fatal, "Configuration error on line %d: '%s' must be either '1' or '0'", line_count, key); \
 			return -1; \
 		} \
 		TARGET |= 0x80000000; \
@@ -65,7 +65,7 @@
 		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); \
+			hub_log(log_fatal, "Configuration error on line %d: '%s' must be a number", line_count, key); \
 			return -1; \
 		} \
 		TARGET = val; \
@@ -103,22 +103,19 @@
 #define IGNORED(NAME) \
     if (strcmp(#NAME, key) == 0) \
     { \
-        LOG_WARN("Configuration option %s deprecated and ingnored.", key); \
+        hub_log(log_warning, "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_HUB_NAME                        "uhub"
 #define DEF_HUB_DESCRIPTION                 ""
 #define DEF_HUB_ENABLED                     1
 #define DEF_FILE_ACL                        ""
 #define DEF_FILE_MOTD                       ""
 #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
@@ -138,10 +135,6 @@
 #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"
@@ -181,10 +174,7 @@ void config_defaults(struct hub_config* config)
 	DEFAULT_STRING (file_acl,              DEF_FILE_ACL);
 	DEFAULT_STRING (file_motd,             DEF_FILE_MOTD);
 	DEFAULT_INTEGER(server_port,           DEF_SERVER_PORT);
-	DEFAULT_INTEGER(server_listen_backlog, DEF_SERVER_BACKLOG);
 	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);
@@ -238,10 +228,10 @@ void config_defaults(struct hub_config* config)
 	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_enable,             0);
-	DEFAULT_INTEGER(tls_require,                   DEF_TLS_REQUIRE);
+	DEFAULT_INTEGER(tls_require,            0);
-	DEFAULT_STRING (tls_certificate,               DEF_TLS_CERTIFICATE);
+	DEFAULT_STRING (tls_certificate,       "");
-	DEFAULT_STRING (tls_private_key,               DEF_TLS_PRIVATE_KEY);
+	DEFAULT_STRING (tls_private_key,       "");
 }
 
 
@@ -251,13 +241,10 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 	GET_STR (file_motd);
 	GET_STR (server_bind_addr);
 	GET_INT (server_port);
-	GET_INT (server_listen_backlog);
 	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);
@@ -317,7 +304,7 @@ static int apply_config(struct hub_config* config, char* key, char* data, int li
 	GET_STR (tls_private_key);
 
     /* Still here -- unknown directive */
-	LOG_ERROR("Unknown configuration directive: '%s'", key);
+	hub_log(log_fatal, "Unknown configuration directive: '%s'", key);
 	return -1;
 }
 
@@ -400,13 +387,10 @@ void dump_config(struct hub_config* config, int ignore_defaults)
 	DUMP_STR (file_motd, DEF_FILE_MOTD);
 	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 (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);
@@ -416,13 +400,6 @@ void dump_config(struct hub_config* config, int ignore_defaults)
 	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);
@@ -483,12 +460,9 @@ static int config_parse_line(char* line, int line_count, void* ptr_data)
 
 	if (!*line) return 0;
 
-	LOG_DUMP("config_parse_line(): '%s'", line);
+#ifdef CONFIG_DUMP
-
+	hub_log(log_trace, "config_parse_line(): '%s'", line);
-	if (!is_valid_utf8(line))
+#endif
-	{
-		LOG_WARN("Invalid utf-8 characters on line %d", line_count);
-	}
 
 	if ((pos = strchr(line, '=')) != NULL)
 	{
@@ -507,11 +481,13 @@ static int config_parse_line(char* line, int line_count, void* ptr_data)
 
 	if (!*key || !*data)
 	{
-		LOG_FATAL("Configuration parse error on line %d", line_count);
+		hub_log(log_fatal, "Configuration parse error on line %d", line_count);
 		return -1;
 	}
 
-	LOG_DUMP("config_parse_line: '%s' => '%s'", key, data);
+#ifdef CONFIG_DUMP
+	hub_log(log_trace, "config_parse_line: '%s' => '%s'", key, data);
+#endif
 
 	return apply_config(config, key, data, line_count);
 }
@@ -528,7 +504,7 @@ int read_config(const char* file, struct hub_config* config, int allow_missing)
 	{
 		if (allow_missing && ret == -2)
 		{
-			LOG_DUMP("Using default configuration.");
+			hub_log(log_debug, "Using default configuration.");
 		}
 		else
 		{

src/config.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2009, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,7 +24,6 @@ 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)" */
 	int hub_enabled;             /**<<< "Is server enabled (default: 1)" */
 	int show_banner;             /**<<< "Show banner on connect (default: 1)" */
 	int max_users;               /**<<< "Maximum number of users allowed on the hub (default: 500)" */
@@ -40,9 +39,6 @@ struct hub_config
 	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)" */

src/core/commands.c

@@ -1,573 +0,0 @@
-/*
- * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, 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 DEBUG
-#define CRASH_DEBUG
-#endif
-
-#define MAX_HELP_MSG 1024
-
-struct hub_command
-{
-	const char* message;
-	char* prefix;
-	size_t prefix_len;
-	struct linked_list* args;
-};
-
-typedef int (*command_handler)(struct hub_info* hub, struct hub_user* user, struct hub_command*);
-
-struct commands_handler
-{
-	const char* prefix;
-	size_t length;
-	const char* args;
-	enum user_credentials cred;
-	command_handler handler;
-	const char* description;
-};
-
-static struct commands_handler command_handlers[];
-
-static void command_destroy(struct hub_command* cmd)
-{
-	if (!cmd) return;
-	hub_free(cmd->prefix);
-
-	if (cmd->args)
-	{
-		list_clear(cmd->args, &hub_free);
-		list_destroy(cmd->args);
-	}
-
-	hub_free(cmd);
-}
-
-static struct hub_command* command_create(const char* message)
-{
-	struct hub_command* cmd = hub_malloc_zero(sizeof(struct hub_command));
-	if (!cmd) return 0;
-
-	cmd->message = message;
-	cmd->args = list_create();
-
-	int n = split_string(message, "\\s", cmd->args, 0);
-	if (n <= 0)
-	{
-		command_destroy(cmd);
-		return 0;
-	}
-
-	char* prefix = list_get_first(cmd->args);
-	if (prefix && prefix[0] && prefix[1])
-	{
-		cmd->prefix = hub_strdup(&prefix[1]);
-		cmd->prefix_len = strlen(cmd->prefix);
-	}
-	else
-	{
-		command_destroy(cmd);
-		return 0;
-	}
-	list_remove(cmd->args, prefix);
-	hub_free(prefix);
-	return cmd;
-}
-
-static void send_message(struct hub_info* hub, struct hub_user* user, const char* message)
-{
-	char* buffer = adc_msg_escape(message);
-	struct adc_message* command = adc_msg_construct(ADC_CMD_IMSG, strlen(buffer) + 6);
-	adc_msg_add_argument(command, buffer);
-	route_to_user(hub, user, command);
-	adc_msg_free(command);
-	hub_free(buffer);
-}
-
-static int command_access_denied(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	char temp[128];
-	snprintf(temp, 128, "*** %s: Access denied.", cmd->prefix);
-	send_message(hub, user, temp);
-	return 0;
-}
-
-static int command_not_found(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	char temp[128];
-	snprintf(temp, 128, "*** %s: Command not found", cmd->prefix);
-	send_message(hub, user, temp);
-	return 0;
-}
-
-static int command_status_user_not_found(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd, const char* nick)
-{
-	char temp[128];
-	snprintf(temp, 128, "*** %s: No user \"%s\"", cmd->prefix, nick);
-	send_message(hub, user, temp);
-	return 0;
-}
-
-const char* command_get_syntax(struct commands_handler* handler)
-{
-	static char args[128];
-	args[0] = 0;
-	size_t n = 0;
-	if (handler->args)
-	{
-		for (n = 0; n < strlen(handler->args); n++)
-		{
-			if (n > 0) strcat(args, " ");
-			switch (handler->args[n])
-			{
-				case 'n': strcat(args, "<nick>"); break;
-				case 'c': strcat(args, "<cid>");  break;
-				case 'a': strcat(args, "<addr>"); break;
-				case 'm': strcat(args, "<message>"); break;
-			}
-		}
-	}
-	return args;
-}
-
-static int command_arg_mismatch(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd, struct commands_handler* handler)
-{
-	char temp[256];
-	const char* args = command_get_syntax(handler);
-	if (args) snprintf(temp, 256, "*** %s: Use: !%s %s", cmd->prefix, cmd->prefix, args);
-	else      snprintf(temp, 256, "*** %s: Use: !%s", cmd->prefix, cmd->prefix);
-	send_message(hub, user, temp);
-	return 0;
-}
-
-static int command_status(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd, const char* message)
-{
-	char temp[1024];
-	snprintf(temp, 1024, "*** %s: %s", cmd->prefix, message);
-	send_message(hub, user, temp);
-	return 0;
-}
-
-static int command_stats(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	char temp[128];
-	snprintf(temp, 128, PRINTF_SIZE_T " users, peak: " PRINTF_SIZE_T ". Network (up/down): %d/%d KB/s, peak: %d/%d KB/s",
-	hub->users->count,
-	hub->users->count_peak,
-	(int) hub->stats.net_tx / 1024,
-	(int) hub->stats.net_rx / 1024,
-	(int) hub->stats.net_tx_peak / 1024,
-	(int) hub->stats.net_rx_peak / 1024);
-	return command_status(hub, user, cmd, temp);
-}
-
-static int command_help(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	size_t n;
-	char msg[MAX_HELP_MSG];
-	msg[0] = 0;
-	strcat(msg, "Available commands:\n");
-
-	for (n = 0; command_handlers[n].prefix; n++)
-	{
-		if (command_handlers[n].cred <= user->credentials)
-		{
-			strcat(msg, "!");
-			strcat(msg, command_handlers[n].prefix);
-			strcat(msg, " - ");
-			strcat(msg, command_handlers[n].description);
-			strcat(msg, "\n");
-		}
-	}
-	return command_status(hub, user, cmd, msg);
-}
-
-static int command_uptime(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	char tmp[128];
-	size_t d;
-	size_t h;
-	size_t m;
-	size_t D = (size_t) difftime(time(0), hub->tm_started);
-
-	d = D / (24 * 3600);
-	D = D % (24 * 3600);
-	h = D / 3600;
-	D = D % 3600;
-	m = D / 60;
-
-	tmp[0] = 0;
-	if (d)
-	{
-		strcat(tmp, uhub_itoa((int) d));
-		strcat(tmp, " day");
-		if (d != 1) strcat(tmp, "s");
-		strcat(tmp, ", ");
-	}
-
-	if (h < 10) strcat(tmp, "0");
-	strcat(tmp, uhub_itoa((int) h));
-	strcat(tmp, ":");
-	if (m < 10) strcat(tmp, "0");
-	strcat(tmp, uhub_itoa((int) m));
-
-	return command_status(hub, user, cmd, tmp);
-}
-
-static int command_kick(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	char* nick = list_get_first(cmd->args);
-	if (!nick)
-		return -1; // FIXME: bad syntax.
-
-	struct hub_user* target = uman_get_user_by_nick(hub, nick);
-	
-	if (!target)
-		return command_status_user_not_found(hub, user, cmd, nick);
-	
-	if (target == user)
-		return command_status(hub, user, cmd, "Cannot kick yourself");
-	
-	hub_disconnect_user(hub, target, quit_kicked);
-	return command_status(hub, user, cmd, nick);
-}
-
-static int command_ban(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	char* nick = list_get_first(cmd->args);
-	if (!nick)
-		return -1; // FIXME: bad syntax.
-
-	struct hub_user* target = uman_get_user_by_nick(hub, nick);
-
-	if (!target)
-		return command_status_user_not_found(hub, user, cmd, nick);
-
-	if (target == user)
-		return command_status(hub, user, cmd, "Cannot kick/ban yourself");
-
-	hub_disconnect_user(hub, target, quit_kicked);
-	acl_user_ban_nick(hub->acl, target->id.nick);
-	acl_user_ban_cid(hub->acl, target->id.cid);
-
-	return command_status(hub, user, cmd, nick);
-}
-
-static int command_unban(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	return command_status(hub, user, cmd, "Not implemented");
-}
-
-static int command_reload(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	hub->status = hub_status_restart;
-	return command_status(hub, user, cmd, "Reloading configuration...");
-}
-
-static int command_shutdown(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	hub->status = hub_status_shutdown;
-	return command_status(hub, user, cmd, "Hub shutting down...");
-}
-
-static int command_version(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	return command_status(hub, user, cmd, "Powered by " PRODUCT "/" VERSION);
-}
-
-static int command_myip(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	char tmp[128];
-	snprintf(tmp, 128, "Your address is \"%s\"", user_get_address(user));
-	return command_status(hub, user, cmd, tmp);
-}
-
-static int command_getip(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	char tmp[128];
-
-	char* nick = list_get_first(cmd->args);
-	if (!nick);
-		return -1; // FIXME: bad syntax/OOM
-
-	struct hub_user* target = uman_get_user_by_nick(hub, nick);
-
-	if (!target)
-		return command_status_user_not_found(hub, user, cmd, nick);
-
-	snprintf(tmp, 128, "%s has address \"%s\"", nick, user_get_address(user));
-	return command_status(hub, user, cmd, tmp);
-}
-
-static int command_whoip(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	char* address = list_get_first(cmd->args);
-	struct ip_range range;
-	struct linked_list* users;
-	struct hub_user* u;
-	int ret = 0;
-
-	if (!address)
-		return -1; // FIXME: bad syntax.
-
-	ret = ip_convert_address_to_range(address, &range);
-	if (!ret)
-		return command_status(hub, user, cmd, "Invalid IP address/range/mask");
-
-	users = (struct linked_list*) list_create();
-	if (!users)
-		return -1; // FIXME: OOM
-
-	ret = uman_get_user_by_addr(hub, users, &range);
-
-	if (!ret)
-	{
-		list_destroy(users);
-		return command_status(hub, user, cmd, "No users found.");
-	}
-
-	char tmp[128];
-	snprintf(tmp, 128, "*** %s: Found %d match%s:", cmd->prefix, ret, ((ret != 1) ? "es" : ""));
-
-	char* buffer = hub_malloc(((MAX_NICK_LEN + INET6_ADDRSTRLEN + 5) * ret) + strlen(tmp) + 3);
-	if (!buffer)
-	{
-		list_destroy(users);
-		return -1; // FIXME: OOM
-	}
-
-	buffer[0] = 0;
-	strcat(buffer, tmp);
-	strcat(buffer, "\n");
-
-	u = (struct hub_user*) list_get_first(users);
-	while (u)
-	{
-		strcat(buffer, u->id.nick);
-		strcat(buffer, " (");
-		strcat(buffer, user_get_address(u));
-		strcat(buffer, ")\n");
-		u = (struct hub_user*) list_get_next(users);
-	}
-	strcat(buffer, "\n");
-
-	send_message(hub, user, buffer);
-	hub_free(buffer);
-	list_destroy(users);
-	return 0;
-}
-
-static int command_broadcast(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	struct adc_message* command = adc_msg_construct(ADC_CMD_IMSG, strlen((cmd->message + 10)) + 6);
-	adc_msg_add_argument(command, (cmd->message + 10));
-	route_to_all(hub, command);
-	adc_msg_free(command);
-	return 0;
-}
-
-static int command_history(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	char* buffer;
-	struct linked_list* messages = hub->chat_history;
-	char* message = 0;
-	int ret = (int) list_size(messages);
-	size_t bufsize;
-
-	if (!ret)
-	{
-		return command_status(hub, user, cmd, "No messages.");
-	}
-
-	char tmp[128];
-	snprintf(tmp, 128, "*** %s: Found %d message%s:", cmd->prefix, ret, ((ret != 1) ? "s" : ""));
-	bufsize = strlen(tmp);
-	message = (char*) list_get_first(messages);
-	while (message)
-	{
-		bufsize += strlen(message);
-		message = (char*) list_get_next(messages);
-	}
-
-	buffer = hub_malloc(bufsize+4);
-	if (!buffer)
-	{
-		return command_status(hub, user, cmd, "Not enough memory.");
-	}
-
-	buffer[0] = 0;
-	strcat(buffer, tmp);
-	strcat(buffer, "\n");
-
-	message = (char*) list_get_first(messages);
-	while (message)
-	{
-		strcat(buffer, message);
-		message = (char*) list_get_next(messages);
-	}
-	strcat(buffer, "\n");
-
-	send_message(hub, user, buffer);
-	hub_free(buffer);
-	return 0;
-}
-
-static int command_log(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	struct linked_list* messages = hub->logout_info;
-	struct hub_logout_info* log;
-	char tmp[1024];
-	char* search = 0;
-	size_t search_len = 0;
-	size_t search_hits = 0;
-
-	if (!list_size(messages))
-	{
-		return command_status(hub, user, cmd, "No entries logged.");
-	}
-
-	search = list_get_first(cmd->args);
-	if (search)
-	{
-		search_len = strlen(search);
-	}
-
-	if (search_len)
-	{
-		sprintf(tmp, "Logged entries: " PRINTF_SIZE_T ", searching for \"%s\"", list_size(messages), search);
-	}
-	else
-	{
-		sprintf(tmp, "Logged entries: " PRINTF_SIZE_T, list_size(messages));
-	}
-	command_status(hub, user, cmd, tmp);
-
-	log = (struct hub_logout_info*) list_get_first(messages);
-	while (log)
-	{
-		const char* address = ip_convert_to_string(&log->addr);
-		int show = 0;
-
-		if (search_len)
-		{
-			if (memmem(log->cid, MAX_CID_LEN, search, search_len) || memmem(log->nick, MAX_NICK_LEN, search, search_len) || memmem(address, strlen(address), search, search_len))
-			{
-				search_hits++;
-				show = 1;
-			}
-		}
-		else
-		{
-			show = 1;
-		}
-
-		if (show)
-		{
-			sprintf(tmp, "* %s %s, %s [%s] - %s", get_timestamp(log->time), log->cid, log->nick, ip_convert_to_string(&log->addr), user_get_quit_reason_string(log->reason));
-			send_message(hub, user, tmp);
-		}
-		log = (struct hub_logout_info*) list_get_next(messages);
-	}
-
-	if (search_len)
-	{
-		sprintf(tmp, PRINTF_SIZE_T " entries shown.", search_hits);
-		command_status(hub, user, cmd, tmp);
-	}
-
-	return 0;
-}
-
-#ifdef CRASH_DEBUG
-static int command_crash(struct hub_info* hub, struct hub_user* user, struct hub_command* cmd)
-{
-	void (*crash)(void) = NULL;
-	crash();
-	return 0;
-}
-#endif
-
-int command_dipatcher(struct hub_info* hub, struct hub_user* user, const char* message)
-{
-	size_t n = 0;
-	int rc;
-
-	/* Parse and validate the command */
-	struct hub_command* cmd = command_create(message);
-	if (!cmd) return 0;
-
-	for (n = 0; command_handlers[n].prefix; n++)
-	{
-		struct commands_handler* handler = &command_handlers[n];
-		if (cmd->prefix_len != handler->length)
-			continue;
-
-		if (!strncmp(cmd->prefix, handler->prefix, handler->length))
-		{
-			if (handler->cred <= user->credentials)
-			{
-				if (!handler->args || (handler->args && list_size(cmd->args) >= strlen(handler->args)))
-				{
-					rc = handler->handler(hub, user, cmd);
-				}
-				else
-				{
-					rc = command_arg_mismatch(hub, user, cmd, handler);
-				}
-				command_destroy(cmd);
-				return rc;
-			}
-			else
-			{
-				rc = command_access_denied(hub, user, cmd);
-				command_destroy(cmd);
-				return rc;
-			}
-		}
-	}
-
-	command_not_found(hub, user, cmd);
-	command_destroy(cmd);
-	return 0;
-}
-
-static struct commands_handler command_handlers[] = {
-	{ "help",       4, 0,   cred_guest,     command_help,     "Show this help message."      },
-	{ "stats",      5, 0,   cred_super,     command_stats,    "Show hub statistics."         },
-	{ "version",    7, 0,   cred_guest,     command_version,  "Show hub version info."       },
-	{ "history",    7, 0,   cred_guest,     command_history,  "Show the last chat messages." },
-	{ "uptime",     6, 0,   cred_guest,     command_uptime,   "Display hub uptime info."     },
-	{ "kick",       4, "n", cred_operator,  command_kick,     "Kick a user"                  },
-	{ "ban",        3, "n", cred_operator,  command_ban,      "Ban a user"                   },
-	{ "unban",      5, "n", cred_operator,  command_unban,    "Lift ban on a user"           },
-	{ "reload",     6, 0,   cred_admin,     command_reload,   "Reload configuration files."  },
-	{ "shutdown",   8, 0,   cred_admin,     command_shutdown, "Shutdown hub."                },
-	{ "myip",       4, 0,   cred_guest,     command_myip,     "Show your own IP."            },
-	{ "getip",      5, "n", cred_operator,  command_getip,    "Show IP address for a user"   },
-	{ "whoip",      5, "a", cred_operator,  command_whoip,    "Show users matching IP range" },
-	{ "broadcast",  9, "m", cred_operator,  command_broadcast,"Send a message to all users"  },
-	{ "log",        3, 0,   cred_operator,  command_log,      "Display log"                  },
-#ifdef CRASH_DEBUG
-	{ "crash",      5, 0,   cred_admin,     command_crash,    "Crash the hub (DEBUG)."       },
-#endif
-	{ 0,            0, 0,   cred_none,      command_help,     ""                             }
-};
-

src/core/hubevent.c

@@ -1,96 +0,0 @@
-/*
- * 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"
-
-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_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 */
-void on_login_success(struct hub_info* hub, struct hub_user* u)
-{
-	/* Send user list of all existing users */
-	if (!uman_send_user_list(hub, u))
-		return;
-
-	/* Mark as being in the normal state, and add user to the user list */
-	user_set_state(u, state_normal);
-	uman_add(hub, u);
-
-	/* Print log message */
-	log_user_login(u);
-
-	/* 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);
-
-	/* reset timeout */
-	net_con_clear_timeout(u->connection);
-}
-
-void on_login_failure(struct hub_info* hub, struct hub_user* u, enum status_message msg)
-{
-	log_user_login_error(u, msg);
-	hub_send_status(hub, u, msg, status_level_fatal);
-	hub_disconnect_user(hub, u, quit_logon_error);
-}
-
-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);
-	}
-}
-
-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);
-	hub_logout_log(hub, user);
-}
-

src/core/hubio.c

@@ -1,171 +0,0 @@
-/*
- * 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"
-#include "hubio.h"
-
-#ifdef DEBUG_SENDQ
-static void debug_msg(const char* prefix, struct adc_message* msg)
-{
-	size_t n;
-	char* buf = strdup(msg->cache);
-	for (n = 0; n < msg->length; n++)
-	{
-		if (buf[n] == '\r' || buf[n] == '\n')
-			buf[n] = '_';
-	}
-	LOG_TRACE("%s: [%s] (%d bytes)", prefix, buf, (int) msg->length);
-	free(buf);
-}
-#endif
-
-struct hub_recvq* hub_recvq_create()
-{
-	struct hub_recvq* q = hub_malloc_zero(sizeof(struct hub_recvq));
-	return q;
-}
-
-void hub_recvq_destroy(struct hub_recvq* q)
-{
-	if (q)
-	{
-		hub_free(q->buf);
-		hub_free(q);
-	}
-}
-
-size_t hub_recvq_get(struct hub_recvq* q, void* buf, size_t bufsize)
-{
-	assert(bufsize >= q->size);
-	if (q->size)
-	{
-		size_t n = q->size;
-		memcpy(buf, q->buf, n);
-		hub_free(q->buf);
-		q->buf = 0;
-		q->size = 0;
-		return n;
-	}
-	return 0;
-}
-
-size_t hub_recvq_set(struct hub_recvq* q, void* buf, size_t bufsize)
-{
-	if (q->buf)
-	{
-		hub_free(q->buf);
-		q->buf = 0;
-		q->size = 0;
-	}
-	
-	if (!bufsize)
-	{
-		return 0;
-	}
-
-	q->buf = hub_malloc(bufsize);
-	if (!q->buf)
-		return 0;
-
-	q->size = bufsize;
-	memcpy(q->buf, buf, bufsize);
-	return bufsize;
-}
-
-
-struct hub_sendq* hub_sendq_create()
-{
-	struct hub_sendq* q = hub_malloc_zero(sizeof(struct hub_sendq));
-	if (!q)
-		return 0;
-
-	q->queue = list_create();
-	if (!q->queue)
-	{
-		hub_free(q);
-		return 0;
-	}
-
-	return q;
-}
-
-static void clear_send_queue_callback(void* ptr)
-{
-	adc_msg_free((struct adc_message*) ptr);
-}
-
-void hub_sendq_destroy(struct hub_sendq* q)
-{
-	if (q)
-	{
-		list_clear(q->queue, &clear_send_queue_callback);
-		list_destroy(q->queue);
-		hub_free(q);
-	}
-}
-
-void hub_sendq_add(struct hub_sendq* q, struct adc_message* msg_)
-{
-	struct adc_message* msg = adc_msg_incref(msg_);
-#ifdef DEBUG_SENDQ
-	debug_msg("hub_sendq_add", msg);
-#endif
-	list_append(q->queue, msg);
-	q->size += msg->length;
-}
-
-void hub_sendq_remove(struct hub_sendq* q, struct adc_message* msg)
-{
-#ifdef DEBUG_SENDQ
-	debug_msg("hub_sendq_remove", msg);
-#endif
-	list_remove(q->queue, msg);
-	q->size  -= msg->length;
-	adc_msg_free(msg);
-	q->offset = 0;
-}
-
-int hub_sendq_send(struct hub_sendq* q, struct hub_user* user)
-{
-	struct adc_message* msg = list_get_first(q->queue);
-	if (!msg) return 0;
-
-	int ret = net_con_send(user->connection, msg->cache + q->offset, msg->length - q->offset);
-
-	if (ret > 0)
-	{
-		q->offset += ret;
-		if (msg->length - q->offset > 0)
-			return 0;
-
-		hub_sendq_remove(q, msg);
-		return 1;
-	}
-	return ret;
-}
-
-int hub_sendq_is_empty(struct hub_sendq* q)
-{
-	return (q->size - q->offset) == 0;
-}
-
-size_t hub_sendq_get_bytes(struct hub_sendq* q)
-{
-	return q->size - q->offset;
-}

src/core/hubio.h

@@ -1,106 +0,0 @@
-/*
- * 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_HUB_IO_H
-#define HAVE_UHUB_HUB_IO_H
-
-struct adc_message;
-struct linked_list;
-typedef int (*hub_recvq_write)(void* desc, const void* buf, size_t len);
-typedef int (*hub_recvq_read)(void* desc, void* buf, size_t len);
-
-struct hub_sendq
-{
-	size_t               size;      /** Size of send queue (in bytes, not messages) */
-	size_t               offset;    /** Queue byte offset in the first message. Should be 0 unless a partial write. */
-#ifdef SSL_SUPPORT
-	size_t               last_send; /** When using SSL, one have to send the exact same buffer and length if a write cannot complete. */
-#endif
-	struct linked_list*  queue;     /** List of queued messages */
-};
-
-struct hub_recvq
-{
-	char* buf;
-	size_t size;
-};
-
-/**
- * Create a send queue
- */
-extern struct hub_sendq* hub_sendq_create();
-
-/**
- * Destroy a send queue, and delete any queued messages.
- */
-extern void hub_sendq_destroy(struct hub_sendq*);
-
-/**
- * Add a message to the send queue.
- */
-extern void hub_sendq_add(struct hub_sendq*, struct adc_message* msg);
-
-/**
- * Process the send queue, and send as many messages as possible.
- * @returns -1 on error, 0 if unable to send more, 1 if more can be sent.
- */
-extern int  hub_sendq_send(struct hub_sendq*, struct hub_user*);
-
-/**
- * @returns 1 if send queue is empty, 0 otherwise.
- */
-extern int hub_sendq_is_empty(struct hub_sendq*);
-
-/**
- * @returns the number of bytes remaining to be sent in the queue.
- */
-extern size_t hub_sendq_get_bytes(struct hub_sendq*);
-
-
-
-/**
- * Create a receive queue.
- */
-extern struct hub_recvq* hub_recvq_create();
-
-/**
- * Destroy a receive queue.
- */
-extern void hub_recvq_destroy(struct hub_recvq*);
-
-/**
- * Gets the buffer, copies it into buf and deallocates it.
- * NOTE: bufsize *MUST* be larger than the buffer, otherwise it asserts.
- * @return the number of bytes copied into buf.
- */
-extern size_t hub_recvq_get(struct hub_recvq*, void* buf, size_t bufsize);
-
-/**
- * Sets the buffer
- */
-extern size_t hub_recvq_set(struct hub_recvq*, void* buf, size_t bufsize);
-
-/**
- * @return 1 if size is zero, 0 otherwise.
- */
-extern int hub_recvq_is_empty(struct hub_recvq* buf);
-
-
-
-#endif /* HAVE_UHUB_HUB_IO_H */

src/core/netevent.c

@@ -1,254 +0,0 @@
-/*
- * 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>
-#include "hubio.h"
-#include "probe.h"
-
-/* 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->net.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);
-
-	if (size > 0)
-		buf_size += size;
-
-	if (size < 0)
-	{
-		if (size == -1)
-			return quit_disconnected;
-		else
-			return quit_socket_error;
-	}
-	else if (size == 0)
-	{
-		return 0;
-	}
-	else
-	{
-		char* lastPos = 0;
-		char* start = buf;
-		char* pos = 0;
-		size_t remaining = buf_size;
-
-		while ((pos = memchr(start, '\n', remaining)))
-		{
-			lastPos = pos;
-			pos[0] = '\0';
-
-#ifdef DEBUG_SENDQ
-			LOG_DUMP("PROC: \"%s\" (%d)\n", start, (int) (pos - start));
-#endif
-
-			if (user_flag_get(user, flag_maxbuf))
-			{
-				user_flag_unset(user, flag_maxbuf);
-			}
-			else
-			{
-				if (((pos - start) > 0) && g_hub->config->max_recv_buffer > (pos - start))
-				{
-					if (hub_handle_message(g_hub, user, start, (pos - start)) == -1)
-					{
-							return quit_protocol_error;
-					}
-				}
-			}
-
-			pos[0] = '\n'; /* FIXME: not needed */
-			pos ++;
-			remaining -= (pos - start);
-			start = pos;
-		}
-
-		if (lastPos || remaining)
-		{
-			if (remaining < g_hub->config->max_recv_buffer)
-			{
-				hub_recvq_set(q, lastPos ? lastPos : buf, remaining);
-			}
-			else
-			{
-				hub_recvq_set(q, 0, 0);
-				user_flag_set(user, flag_maxbuf);
-				LOG_WARN("Received message past max_recv_buffer, dropping message.");
-			}
-		}
-		else
-		{
-			hub_recvq_set(q, 0, 0);
-		}
-	}
-	return 0;
-}
-
-int handle_net_write(struct hub_user* user)
-{
-	int ret = 0;
-	while (hub_sendq_get_bytes(user->send_queue))
-	{
-		ret = hub_sendq_send(user->send_queue, user);
-		if (ret <= 0)
-			break;
-	}
-
-	if (ret < 0)
-		return quit_socket_error;
-
-	if (hub_sendq_get_bytes(user->send_queue))
-	{
-		user_net_io_want_write(user);
-	}
-	else
-	{
-		user_net_io_want_read(user);
-	}
-	return 0;
-}
-
-void net_event(struct net_connection* con, int event, void *arg)
-{
-	struct hub_user* user = (struct hub_user*) arg;
-	int flag_close = 0;
-
-#ifdef DEBUG_SENDQ
-	LOG_TRACE("net_event() : fd=%d, ev=%d, arg=%p", fd, (int) event, arg);
-#endif
-
-	if (event == NET_EVENT_SOCKERROR)
-	{
-		hub_disconnect_user(g_hub, user, quit_socket_error);
-		return;
-	}
-	else if (event == NET_EVENT_CLOSED)
-	{
-		hub_disconnect_user(g_hub, user, quit_disconnected);
-		return;
-	}
-	else if (event == NET_EVENT_TIMEOUT)
-	{
-		if (user_is_connecting(user))
-		{
-			hub_disconnect_user(g_hub, user, quit_timeout);
-			return;
-		}
-	}
-
-	if (event & NET_EVENT_READ)
-	{
-		flag_close = handle_net_read(user);
-		if (flag_close)
-		{
-			hub_disconnect_user(g_hub, user, flag_close);
-			return;
-		}
-	}
-
-	if (event & NET_EVENT_WRITE)
-	{
-		flag_close = handle_net_write(user);
-		if (flag_close)
-		{
-			hub_disconnect_user(g_hub, user, flag_close);
-			return;
-		}
-	}
-}
-
-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);
-
-	for (;;)
-	{
-		int fd = net_accept(server_fd, &ipaddr);
-		if (fd == -1)
-		{
-			if (net_error() == EWOULDBLOCK)
-			{
-				break;
-			}
-			else
-			{
-				LOG_ERROR("Accept error: %d %s", net_error(), strerror(net_error()));
-				break;
-			}
-		}
-
-		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))
-		{
-			LOG_INFO("Denied      [%s] (IP banned)", addr);
-			net_close(fd);
-			continue;
-		}
-
-		probe = probe_create(hub, fd, &ipaddr);
-		if (!probe)
-		{
-			LOG_ERROR("Unable to create probe after socket accepted. Out of memory?");
-			net_close(fd);
-			break;
-		}
-	}
-}
-

src/core/probe.c

@@ -1,120 +0,0 @@
-/*
- * 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"
-#include "probe.h"
-
-#define PROBE_RECV_SIZE 12
-static char probe_recvbuf[PROBE_RECV_SIZE];
-
-static void probe_net_event(struct net_connection* con, int events, void *arg)
-{
-	struct hub_probe* probe = (struct hub_probe*) net_con_get_ptr(con);
-
-	if (events == NET_EVENT_SOCKERROR || events == NET_EVENT_CLOSED || events == NET_EVENT_TIMEOUT)
-	{
-		probe_destroy(probe);
-		return;
-	}
-
-	if (events & NET_EVENT_READ)
-	{
-		int bytes = net_con_peek(con, probe_recvbuf, PROBE_RECV_SIZE);
-		if (bytes < 0)
-		{
-			probe_destroy(probe);
-			return;
-		}
-
-		if (bytes >= 4)
-		{
-			if (memcmp(probe_recvbuf, "HSUP", 4) == 0)
-			{
-				LOG_TRACE("Probed ADC");
-				if (user_create(probe->hub, probe->connection, &probe->addr))
-				{
-					probe->connection = 0;
-				}
-				probe_destroy(probe);
-				return;
-			}
-
-#ifdef SSL_SUPPORT
-			if (bytes >= 11 &&
-				probe_recvbuf[0] == 22 && 
-				probe_recvbuf[1] == 3 && /* protocol major version */
-				probe_recvbuf[5] == 1 && /* message type */
-				probe_recvbuf[9] == probe_recvbuf[1] &&
-				probe_recvbuf[10] == probe_recvbuf[2])
-			{
-				if (probe->hub->config->tls_enable)
-				{
-					LOG_TRACE("Probed TLS %d.%d connection", (int) probe_recvbuf[1], (int) probe_recvbuf[2]);
-					if (user_create(probe->hub, probe->connection, &probe->addr))
-					{
-						probe->connection = 0;
-					}
-					net_con_ssl_handshake(con, net_con_ssl_mode_server, probe->hub->ssl_ctx);
-				}
-				else
-				{
-					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;
-			}
-#endif
-			probe_destroy(probe);
-			return;
-		}
-	}
-}
-
-struct hub_probe* probe_create(struct hub_info* hub, int sd, struct ip_addr_encap* addr)
-{
-	struct hub_probe* probe = (struct hub_probe*) hub_malloc_zero(sizeof(struct hub_probe));
-
-	if (probe == NULL)
-		return NULL; /* OOM */
-
-	probe->hub = hub;
-	probe->connection = net_con_create();
-	net_con_initialize(probe->connection, sd, probe_net_event, probe, NET_EVENT_READ);
-	net_con_set_timeout(probe->connection, TIMEOUT_CONNECTED);
-
-	memcpy(&probe->addr, addr, sizeof(struct ip_addr_encap));
-	return probe;
-}
-
-void probe_destroy(struct hub_probe* probe)
-{
-	if (probe->connection)
-	{
-		net_con_close(probe->connection);
-		probe->connection = 0;
-	}
-	hub_free(probe);
-}

src/core/probe.h

@@ -1,35 +0,0 @@
-/*
- * 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_PROBE_H
-#define HAVE_UHUB_PROBE_H
-
-#include "uhub.h"
-
-struct hub_probe
-{
-	struct hub_info*        hub;                /** The hub instance this probe belong to */
-	struct net_connection*  connection;         /** Connection data */
-	struct ip_addr_encap    addr;               /** IP address */
-};
-
-extern struct hub_probe* probe_create(struct hub_info* hub, int sd, struct ip_addr_encap* addr);
-extern void probe_destroy(struct hub_probe* probe);
-
-#endif /* HAVE_UHUB_PROBE_H */

src/core/route.c

@@ -1,228 +0,0 @@
-/*
- * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, 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 route_message(struct hub_info* hub, struct hub_user* u, struct adc_message* msg)
-{
-	struct hub_user* target = NULL;
-
-	switch (msg->cache[0])
-	{
-		case 'B': /* Broadcast to all logged in clients */
-			route_to_all(hub, msg);
-			break;
-			
-		case 'D':
-			target = uman_get_user_by_sid(hub, msg->target);
-			if (target)
-			{
-				route_to_user(hub, target, msg);
-			}
-			break;
-			
-		case 'E':
-			target = uman_get_user_by_sid(hub, msg->target);
-			if (target)
-			{
-				route_to_user(hub, target, msg);
-				route_to_user(hub, u, msg);
-			}
-			break;
-			
-		case 'F':
-			route_to_subscribers(hub, msg);
-			break;	
-		
-		default:
-			/* Ignore the message */
-			break;
-	}
-	return 0;
-}
-
-static inline 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)));
-	 */
-	return hub->config->max_send_buffer;
-}
-
-static inline size_t get_max_send_queue_soft(struct hub_info* hub)
-{
-	return hub->config->max_send_buffer_soft;
-}
-
-/*
- * @return 1 if send queue is OK.
- *         -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)
-{
-	if (user_flag_get(user, flag_user_list))
-		return 1;
-
-	if ((user->send_queue->size + msg->length) > get_max_send_queue(hub))
-	{
-		LOG_WARN("send queue overflowed, message discarded.");
-		return -1;
-	}
-
-	if (user->send_queue->size > get_max_send_queue_soft(hub))
-	{
-		LOG_WARN("send queue soft overflowed.");
-		return 0;
-	}
-
-	return 1;
-}
-
-int route_to_user(struct hub_info* hub, struct hub_user* user, struct adc_message* msg)
-{
-#ifdef DEBUG_SENDQ
-	char* data = strndup(msg->cache, msg->length-1);
-	LOG_PROTO("send %s: \"%s\"", sid_to_string(user->id.sid), data);
-	free(data);
-#endif
-
-	if (!user->connection)
-		return 0;
-
-	if (hub_sendq_is_empty(user->send_queue) && !user_flag_get(user, flag_pipeline))
-	{
-		/* Perform oportunistic write */
-		hub_sendq_add(user->send_queue, msg);
-		handle_net_write(user);
-	}
-	else
-	{
-		if (check_send_queue(hub, user, msg) >= 0)
-		{
-			hub_sendq_add(user->send_queue, msg);
-			if (!user_flag_get(user, flag_pipeline))
-				user_net_io_want_write(user);
-		}
-	}
-	return 1;
-}
-
-int route_flush_pipeline(struct hub_info* hub, struct hub_user* u)
-{
-	if (hub_sendq_is_empty(u->send_queue))
-		return 0;
-
-	handle_net_write(u);
-	user_flag_unset(u, flag_pipeline);
-	return 1;
-}
-
-
-int route_to_all(struct hub_info* hub, struct adc_message* command) /* iterate users */
-{
-	struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list);
-	while (user)
-	{
-		route_to_user(hub, user, command);
-		user = (struct hub_user*) list_get_next(hub->users->list);
-	}
-	
-	return 0;
-}
-
-int route_to_subscribers(struct hub_info* hub, struct adc_message* command) /* iterate users */
-{
-	int do_send;
-	char* tmp;
-	
-	struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list);
-	while (user)
-	{
-		if (user->feature_cast)
-		{
-			do_send = 1;
-			
-			tmp = list_get_first(command->feature_cast_include);
-			while (tmp)
-			{
-				if (!user_have_feature_cast_support(user, tmp))
-				{
-					do_send = 0;
-					break;
-				}
-				tmp = list_get_next(command->feature_cast_include);;
-			}
-			
-			if (!do_send) {
-				user = (struct hub_user*) list_get_next(hub->users->list);
-				continue;
-			}
-			
-			tmp = list_get_first(command->feature_cast_exclude);
-			while (tmp)
-			{
-				if (user_have_feature_cast_support(user, tmp))
-				{
-					do_send = 0;
-					break;
-				}
-				tmp = list_get_next(command->feature_cast_exclude);
-			}
-			
-			if (do_send)
-			{
-				route_to_user(hub, user, command);
-			}
-		}
-		user = (struct hub_user*) list_get_next(hub->users->list);
-	}
-	
-	return 0;
-}
-
-int route_info_message(struct hub_info* hub, struct hub_user* u)
-{
-	if (!user_is_nat_override(u))
-	{
-		return route_to_all(hub, u->info);
-	}
-	else
-	{
-		struct adc_message* cmd = adc_msg_copy(u->info);
-		const char* address = user_get_address(u);
-		struct hub_user* user = 0;
-		
-		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV4_ADDR);
-		adc_msg_add_named_argument(cmd, ADC_INF_FLAG_IPV4_ADDR, address);
-	
-		user = (struct hub_user*) list_get_first(hub->users->list);
-		while (user)
-		{
-			if (user_is_nat_override(user))
-				route_to_user(hub, user, cmd);
-			else
-				route_to_user(hub, user, u->info);
-			
-			user = (struct hub_user*) list_get_next(hub->users->list);
-		}
-		adc_msg_free(cmd);
-	}
-	return 0;
-}

src/core/user.c

@@ -1,349 +0,0 @@
-/*
- * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, 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 DEBUG_SENDQ
-static const char* user_log_str(struct hub_user* user)
-{
-	static char buf[128];
-	if (user)
-	{
-		snprintf(buf, 128, "user={ %p, \"%s\", %s/%s}", user, user->id.nick, sid_to_string(user->id.sid), user->id.cid);
-	}
-	else
-	{
-		snprintf(buf, 128, "user={ %p }", user);
-	}
-	return buf;
-}
-#endif
-
-struct hub_user* user_create(struct hub_info* hub, struct net_connection* con, struct ip_addr_encap* addr)
-{
-	struct hub_user* user = NULL;
-	
-	LOG_TRACE("user_create(), hub=%p, con[sd=%d]", hub, net_con_get_sd(con));
-
-	user = (struct hub_user*) hub_malloc_zero(sizeof(struct hub_user));
-
-	if (user == NULL)
-		return NULL; /* OOM */
-
-	user->send_queue = hub_sendq_create();
-	user->recv_queue = hub_recvq_create();
-
-	user->connection = con;
-	net_con_reinitialize(user->connection, net_event, user, NET_EVENT_READ);
-
-	memcpy(&user->id.addr, addr, sizeof(struct ip_addr_encap));
-	user_set_state(user, state_protocol);
-	return user;
-}
-
-
-void user_destroy(struct hub_user* user)
-{
-	LOG_TRACE("user_destroy(), user=%p", user);
-
-	hub_recvq_destroy(user->recv_queue);
-	hub_sendq_destroy(user->send_queue);
-
-	adc_msg_free(user->info);
-	user_clear_feature_cast_support(user);
-	hub_free(user);
-}
-
-void user_set_state(struct hub_user* user, enum user_state state)
-{
-	if ((user->state == state_cleanup && state != state_disconnected) || (user->state == state_disconnected))
-	{
-		return;
-	}
-	
-	user->state = state;
-}
-
-void user_set_info(struct hub_user* user, struct adc_message* cmd)
-{
-	adc_msg_free(user->info);
-	user->info = adc_msg_incref(cmd);
-}
-
-void user_update_info(struct hub_user* u, struct adc_message* cmd)
-{
-	char prefix[2];
-	char* argument;
-	size_t n = 0;
-	struct adc_message* cmd_new = adc_msg_copy(u->info);
-	if (!cmd_new)
-	{
-		/* FIXME: OOM! */
-		return;
-	}
-	
-	/*
-	 * FIXME: Optimization potential:
-	 *
-	 * remove parts of cmd that do not really change anything in cmd_new.
-	 * this can save bandwidth if clients send multiple updates for information
-	 * that does not really change anything.
-	 */
-	argument = adc_msg_get_argument(cmd, n++);
-	while (argument)
-	{
-		if (strlen(argument) >= 2)
-		{
-			prefix[0] = argument[0];
-			prefix[1] = argument[1];
-			adc_msg_replace_named_argument(cmd_new, prefix, argument+2);
-		}
-		
-		hub_free(argument);
-		argument = adc_msg_get_argument(cmd, n++);
-	}
-	user_set_info(u, cmd_new);
-	adc_msg_free(cmd_new);
-}
-
-
-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','E'):
-			return feature_base;
-
-		case FOURCC('A','U','T','0'):
-			return  feature_auto;
-
-		case FOURCC('U','C','M','0'):
-		case FOURCC('U','C','M','D'):
-			return feature_ucmd;
-
-		case FOURCC('Z','L','I','F'):
-			return feature_zlif;
-
-		case FOURCC('B','B','S','0'):
-			return feature_bbs;
-
-		case FOURCC('T','I','G','R'):
-			return feature_tiger;
-
-		case FOURCC('B','L','O','M'):
-		case FOURCC('B','L','O','0'):
-			return feature_bloom;
-
-		case FOURCC('P','I','N','G'):
-			return feature_ping;
-
-		case FOURCC('L','I','N','K'):
-			return feature_link;
-
-		case FOURCC('A','D','C','S'):
-			return feature_adcs;
-
-		default:
-			LOG_DEBUG("Unknown extension: %x", fourcc);
-			return 0;
-	}
-}
-
-void user_support_add(struct hub_user* user, int fourcc)
-{
-	int feature_mask = convert_support_fourcc(fourcc);
-	user->flags |= feature_mask;
-}
-
-int user_flag_get(struct hub_user* user, enum user_flags flag)
-{
-    return user->flags & flag;
-}
-
-void user_flag_set(struct hub_user* user, enum user_flags flag)
-{
-    user->flags |= flag;
-}
-
-void user_flag_unset(struct hub_user* user, enum user_flags flag)
-{
-    user->flags &= ~flag;
-}
-
-void user_set_nat_override(struct hub_user* user)
-{
-	user_flag_set(user, flag_nat);
-}
-
-int user_is_nat_override(struct hub_user* user)
-{
-	return user_flag_get(user, flag_nat);
-}
-
-void user_support_remove(struct hub_user* user, int fourcc)
-{
-	int feature_mask = convert_support_fourcc(fourcc);
-	user->flags &= ~feature_mask;
-}
-
-int user_have_feature_cast_support(struct hub_user* user, char feature[4])
-{
-	char* tmp = list_get_first(user->feature_cast);
-	while (tmp)
-	{
-		if (strncmp(tmp, feature, 4) == 0)
-			return 1;
-	
-		tmp = list_get_next(user->feature_cast);
-	}
-	
-	return 0;
-}
-
-int user_set_feature_cast_support(struct hub_user* u, char feature[4])
-{
-	if (!u->feature_cast)
-	{
-		u->feature_cast = list_create();
-	}
-
-	if (!u->feature_cast)
-	{
-		return 0; /* OOM! */
-	}
-
-	list_append(u->feature_cast, hub_strndup(feature, 4));
-	return 1;
-}
-
-void user_clear_feature_cast_support(struct hub_user* u)
-{
-	if (u->feature_cast)
-	{
-		list_clear(u->feature_cast, &hub_free);
-		list_destroy(u->feature_cast);
-		u->feature_cast = 0;
-	}
-}
-
-int user_is_logged_in(struct hub_user* user)
-{
-	if (user->state == state_normal)
-		return 1;
-	return 0;
-}
-
-int user_is_connecting(struct hub_user* user)
-{
-	if (user->state == state_protocol || user->state == state_identify || user->state == state_verify)
-		return 1;
-	return 0;
-}
-
-int user_is_protocol_negotiating(struct hub_user* user)
-{
-	if (user->state == state_protocol)
-		return 1;
-	return 0;
-}
-
-int user_is_disconnecting(struct hub_user* user)
-{
-	if (user->state == state_cleanup || user->state == state_disconnected)
-		return 1;
-	return 0;
-}
-
-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;
-}
-
-/**
- * Returns 1 if a user is registered.
- * Only registered users will be let in if the hub is configured for registered
- * users only.
- */
-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;
-}
-
-void user_net_io_want_write(struct hub_user* user)
-{
-	net_con_update(user->connection, NET_EVENT_READ | NET_EVENT_WRITE);
-}
-
-void user_net_io_want_read(struct hub_user* user)
-{
-	net_con_update(user->connection, NET_EVENT_READ);
-}
-
-const char* user_get_quit_reason_string(enum user_quit_reason reason)
-{
-	switch (reason)
-	{
-		case quit_unknown:          return "unknown";        break;
-		case quit_disconnected:     return "disconnected";   break;
-		case quit_kicked:           return "kicked";         break;
-		case quit_banned:           return "banned";         break;
-		case quit_timeout:          return "timeout";        break;
-		case quit_send_queue:       return "send queue";     break;
-		case quit_memory_error:     return "out of memory";  break;
-		case quit_socket_error:     return "socket error";   break;
-		case quit_protocol_error:   return "protocol error"; break;
-		case quit_logon_error:      return "login error";    break;
-		case quit_hub_disabled:     return "hub disabled";   break;
-		case quit_ghost_timeout:    return "ghost";          break;
-	}
-
-	return "unknown";
-}
-
-const char* user_get_address(struct hub_user* user)
-{
-	return ip_convert_to_string(&user->id.addr);
-}

src/core/usermanager.c

@@ -1,290 +0,0 @@
-/*
- * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, 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 USERMANAGER_TIMER
-
-/*
- * This callback function is used to clear user objects from the userlist.
- * Should only be used in uman_shutdown().
- */
-static void clear_user_list_callback(void* ptr)
-{
-	if (ptr)
-	{
-		struct hub_user* u = (struct hub_user*) ptr;
-		
-		/* Mark the user as already being disconnected.
-		 * This prevents the hub from trying to send
-		 * quit messages to other users.
-		 */
-		u->credentials = cred_none;
-		user_destroy(u);
-	}
-}
-
-
-void uman_update_stats(struct hub_info* hub)
-{
-	const int factor = TIMEOUT_STATS;
-	struct net_statistics* total;
-	struct net_statistics* intermediate;
-	net_stats_get(&intermediate, &total);
-
-	hub->stats.net_tx = (intermediate->tx / factor);
-	hub->stats.net_rx = (intermediate->rx / factor);
-	hub->stats.net_tx_peak = MAX(hub->stats.net_tx, hub->stats.net_tx_peak);
-	hub->stats.net_rx_peak = MAX(hub->stats.net_rx, hub->stats.net_rx_peak);
-	hub->stats.net_tx_total = total->tx;
-	hub->stats.net_rx_total = total->rx;
-	
-	net_stats_reset();
-}
-
-
-void uman_print_stats(struct hub_info* hub)
-{
-	LOG_INFO("Statistics  users=" PRINTF_SIZE_T " (peak_users=" PRINTF_SIZE_T "), net_tx=%d KB/s, net_rx=%d KB/s (peak_tx=%d KB/s, peak_rx=%d KB/s)",
-		hub->users->count,
-		hub->users->count_peak,
-		(int) hub->stats.net_tx / 1024,
-		(int) hub->stats.net_rx / 1024,
-		(int) hub->stats.net_tx_peak / 1024,
-		(int) hub->stats.net_rx_peak / 1024);
-}
-
-#ifdef USERMANAGER_TIMER
-#ifdef USE_LIBEVENT
-static void timer_statistics(int fd, short ev, void *arg)
-{
-	struct hub_info* hub = (struct hub_info*) arg;
-	struct timeval timeout = { TIMEOUT_STATS, 0 };
-	uman_update_stats(hub);
-	evtimer_set(&hub->ev_timer, timer_statistics, hub);
-	evtimer_add(&hub->ev_timer, &timeout);
-}
-#endif
-#endif
-
-
-int uman_init(struct hub_info* hub)
-{
-	struct hub_user_manager* users = NULL;
-#ifdef USERMANAGER_TIMER
-#ifdef USE_LIBEVENT
-	struct timeval timeout = { TIMEOUT_STATS, 0 };
-#endif
-#endif
-	if (!hub)
-		return -1;
-
-	users = (struct hub_user_manager*) hub_malloc_zero(sizeof(struct hub_user_manager));
-	if (!users)
-		return -1;
-
-	users->list = list_create();
-	users->sids = sid_pool_create(net_get_max_sockets());
-
-	if (!users->list)
-	{
-		list_destroy(users->list);
-		hub_free(users);
-		return -1;
-	}
-
-	hub->users = users;
-
-#ifdef USERMANAGER_TIMER
-#ifdef USE_LIBEVENT
-	if (net_get_evbase())
-	{
-		evtimer_set(&hub->ev_timer, timer_statistics, hub);
-		evtimer_add(&hub->ev_timer, &timeout);
-	}
-#endif
-#endif // 0
-	return 0;
-}
-
-
-int uman_shutdown(struct hub_info* hub)
-{
-	if (!hub || !hub->users)
-		return -1;
-
-#ifdef USERMANAGER_TIMER
-#ifdef USE_LIBEVENT
-	if (evtimer_pending(&hub->ev_timer, 0))
-		evtimer_del(&hub->ev_timer);
-#endif
-#endif
-
-	if (hub->users->list)
-	{
-		list_clear(hub->users->list, &clear_user_list_callback);
-		list_destroy(hub->users->list);
-	}
-	sid_pool_destroy(hub->users->sids);
-	hub_free(hub->users);
-	hub->users = 0;
-
-	return 0;
-}
-
-
-int uman_add(struct hub_info* hub, struct hub_user* user)
-{
-	if (!hub || !user)
-		return -1;
-
-	if (user->hub)
-		return -1;
-
-	list_append(hub->users->list, user);
-	hub->users->count++;
-	hub->users->count_peak = MAX(hub->users->count, hub->users->count_peak);
-
-	hub->users->shared_size  += user->limits.shared_size;
-	hub->users->shared_files += user->limits.shared_files;
-
-	user->hub = hub;
-	return 0;
-}
-
-int uman_remove(struct hub_info* hub, struct hub_user* user)
-{
-	if (!hub || !user)
-		return -1;
-
-	list_remove(hub->users->list, user);
-	
-	if (hub->users->count > 0)
-	{
-		hub->users->count--;
-	}
-	else
-	{
-		assert(!"negative count!");
-	}
-	
-	hub->users->shared_size  -= user->limits.shared_size;
-	hub->users->shared_files -= user->limits.shared_files;
-
-	user->hub = 0;
-	
-	return 0;
-}
-
-
-struct hub_user* uman_get_user_by_sid(struct hub_info* hub, sid_t sid)
-{
-	return sid_lookup(hub->users->sids, sid);
-}
-
-
-struct hub_user* uman_get_user_by_cid(struct hub_info* hub, const char* cid)
-{
-	struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list); /* iterate users - only on incoming INF msg */
-	while (user)
-	{
-		if (strcmp(user->id.cid, cid) == 0)
-			return user;
-		user = (struct hub_user*) list_get_next(hub->users->list);
-	}
-	return NULL;
-}
-
-
-struct hub_user* uman_get_user_by_nick(struct hub_info* hub, const char* nick)
-{
-	struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list); /* iterate users - only on incoming INF msg */
-	while (user)
-	{
-		if (strcmp(user->id.nick, nick) == 0)
-			return user;
-		user = (struct hub_user*) list_get_next(hub->users->list);
-	}
-	return NULL;
-}
-
-size_t uman_get_user_by_addr(struct hub_info* hub, struct linked_list* users, struct ip_range* range)
-{
-	size_t num = 0;
-	struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list); /* iterate users - only on incoming INF msg */
-	while (user)
-	{
-		if (ip_in_range(&user->id.addr, range))
-		{
-			list_append(users, user);
-			num++;
-		}
-		user = (struct hub_user*) list_get_next(hub->users->list);
-	}
-	return num;
-}
-
-int uman_send_user_list(struct hub_info* hub, struct hub_user* target)
-{
-	int ret = 1;
-	user_flag_set(target, flag_user_list);
-	struct hub_user* user = (struct hub_user*) list_get_first(hub->users->list); /* iterate users - only on INF or PAS msg */
-	while (user)
-	{
-		if (user_is_logged_in(user))
-		{
-			ret = route_to_user(hub, target, user->info);
-			if (!ret)
-				break;
-		}
-		user = (struct hub_user*) list_get_next(hub->users->list);
-	}
-	
-#if 0
-	FIXME: FIXME FIXME handle send queue excess
-	if (!target->send_queue_size)
-	{
-	    user_flag_unset(target, flag_user_list);
-	}
-#endif
-	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);
-	adc_msg_add_argument(command, (const char*) sid_to_string(leaving->id.sid));
-	
-	if (leaving->quit_reason == quit_banned || leaving->quit_reason == quit_kicked)
-	{
-		adc_msg_add_argument(command, ADC_QUI_FLAG_DISCONNECT);
-	}
-	route_to_all(hub, command);
-	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);
-	user->id.sid = sid;
-	return sid;
-}
-

src/eventid.h

@@ -28,14 +28,10 @@
 /* Send a broadcast message */
 #define UHUB_EVENT_BROADCAST         0x2000
 
-/* Shutdown hub */
-#define UHUB_EVENT_HUB_SHUTDOWN      0x3001
-
 /* Statistics, OOM, reconfigure */
 #define UHUB_EVENT_STATISTICS        0x4000
 #define UHUB_EVENT_OUT_OF_MEMORY     0x4001
 #define UHUB_EVENT_RECONFIGURE       0x4002
 
-
 #endif /* HAVE_UHUB_EVENT_ID_H */
 

src/eventqueue.c

@@ -22,7 +22,7 @@
 #ifdef EQ_DEBUG
 static void eq_debug(const char* prefix, struct event_data* data)
 {
-	LOG_DUMP(">>> %s: %p, id: %x, flags=%d\n", prefix, data, data->id, data->flags);
+	printf(">>> %s: %p, id: %x, flags=%d\n", prefix, data, data->id, data->flags);
 }
 #endif
 
@@ -130,7 +130,7 @@ void event_queue_post(struct event_queue* queue, struct event_data* message)
 	}
 	else
 	{
-		LOG_ERROR("event_queue_post: OUT OF MEMORY");
+		hub_log(log_error, "event_queue_post: OUT OF MEMORY");
 	}
 }
 

src/hub.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2009, 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
@@ -79,26 +79,22 @@ struct hub_stats
 	size_t net_rx_total;
 };
 
-struct hub_logout_info
-{
-	time_t time;
-	char cid[MAX_CID_LEN+1];
-	char nick[MAX_NICK_LEN+1];
-	struct ip_addr_encap addr;
-	enum user_quit_reason reason;
-};
-
 struct hub_info
 {
-	struct net_connection* server;
+	int fd_tcp;
-#ifdef USE_LIBEVENT
+#ifdef ADC_UDP_OPERATION
+	int fd_udp;
+#endif
 	struct event ev_accept;
 	struct event ev_timer;
+#ifdef ADC_UDP_OPERATION
+	struct event ev_datagram;
 #endif
 	struct hub_stats stats;
 	struct event_queue* queue;
+	struct event_base* evbase;
 	struct hub_config* config;
-	struct hub_user_manager* users;
+	struct user_manager* users;
 	struct acl_handle* acl;
 	struct adc_message* command_info;    /* The hub's INF command */
 	struct adc_message* command_support; /* The hub's SUP command */
@@ -106,12 +102,6 @@ struct hub_info
 	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. */
-
 #ifdef SSL_SUPPORT
 	SSL_METHOD* ssl_method;
 	SSL_CTX* ssl_ctx;
@@ -126,104 +116,106 @@ struct hub_info
  *
  * @return 0 on success, -1 on error
  */
-extern int hub_handle_message(struct hub_info* hub, struct hub_user* u, const char* message, size_t length);
+extern int hub_handle_message(struct user* u, const char* message, size_t length);
 
 /**
  * Handle protocol support/subscription messages received clients.
  *
  * @return 0 on success, -1 on error
  */
-extern int hub_handle_support(struct hub_info* hub, struct hub_user* u, struct adc_message* cmd);
+extern int hub_handle_support(struct user* u, struct adc_message* cmd);
 
 /**
  * Handle password messages received from clients.
  *
  * @return 0 on success, -1 on error
  */
-extern int hub_handle_password(struct hub_info* hub, struct hub_user* u, struct adc_message* cmd);
+extern int hub_handle_password(struct user* u, struct adc_message* cmd);
 
 /**
  * Handle chat messages received from clients.
  * @return 0 on success, -1 on error.
  */
-extern int hub_handle_chat_message(struct hub_info* hub, struct hub_user* u, struct adc_message* cmd);
+extern int hub_handle_chat_message(struct 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.
  */
-extern int  hub_handle_info_check_nick(struct hub_info* hub, struct hub_user* u, struct adc_message* cmd);
+extern int  hub_handle_info_check_nick(struct user* u, struct adc_message* cmd);
 
 /**
  * Used internally by hub_handle_info
  * @return 1 if CID/PID is OK, or 0 if not valid.
  */
-extern int  hub_handle_info_check_cid(struct hub_info* hub, struct hub_user* u, struct adc_message* cmd);
+extern int  hub_handle_info_check_cid(struct user* u, struct adc_message* cmd);
+
+/**
+ * Can only be used by administrators or operators.
+ *
+ * @return 0 on success, -1 on error
+ */
+extern int hub_handle_kick(struct user* u, struct adc_message* cmd);
+
+#ifdef ADC_UDP_OPERATION
+/**
+ * Handle incoming autocheck message.
+ */
+extern int hub_handle_autocheck(struct user* u, struct adc_message* cmd);
+#endif
 
 /**
  * Send the support line for the hub to a particular user.
  * Only used during the initial handshake.
  */
-extern void hub_send_support(struct hub_info* hub, struct hub_user* u);
+extern void hub_send_support(struct user* u);
 
 /**
  * Send a message assigning a SID for a user.
  * This is only sent after hub_send_support() during initial handshake.
  */
-extern void hub_send_sid(struct hub_info* hub, struct hub_user* u);
+extern void hub_send_sid(struct user* u);
 
 /**
  * Send a 'ping' message to user.
  */
-extern void hub_send_ping(struct hub_info* hub, struct hub_user* user);
+extern void hub_send_ping(struct user* user);
 
 /**
  * Send a message containing hub information to a particular user.
  * This is sent during user connection, but can safely be sent at any
  * point later.
  */
-extern void hub_send_hubinfo(struct hub_info* hub, struct hub_user* u);
+extern void hub_send_hubinfo(struct user* u);
 
 /**
  * Send handshake. This basically calls
  * hub_send_support() and hub_send_sid()
  */
-extern void hub_send_handshake(struct hub_info* hub, struct hub_user* u);
+extern void hub_send_handshake(struct 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.
  */
-extern void hub_send_motd(struct hub_info* hub, struct hub_user* u);
+extern void hub_send_motd(struct user* u);
 
 /**
  * Send a password challenge to a user.
  * This is only used if the user tries to access the hub using a
  * password protected nick name.
  */
-extern void hub_send_password_challenge(struct hub_info* hub, struct hub_user* u);
+extern void hub_send_password_challenge(struct user* u);
 
 /**
- * Sends a status_message to a user.
+ * Send an autocheck message to a user.
+ * This is basically a UDP message. The user's client can then determine
+ * if UDP communication works by either hole punching or configuring UPnP.
  */
-extern void hub_send_status(struct hub_info*, struct hub_user* user, enum status_message msg, enum msg_status_level level);
+extern void hub_send_autocheck(struct user* u, uint16_t port, const char* token);
 
 /**
- * Allocates memory, initializes the hub based on the configuration,
+ * This starts the hub.
- * and returns a hub handle.
- * This hub handle must be passed to hub_shutdown_service() in order to cleanup before exiting.
- *
- * @return a pointer to the hub info.
  */
 extern struct hub_info* hub_start_service(struct hub_config* config);
 
@@ -248,6 +240,12 @@ extern void hub_free_variables(struct hub_info* hub);
 extern const char* hub_get_status_message(struct hub_info* hub, enum status_message msg);
 extern const char* hub_get_status_message_log(struct hub_info* hub, enum status_message msg);
 
+
+/**
+ * Sends a status_message to a user.
+ */
+extern void hub_send_status(struct user* user, enum status_message msg, enum msg_status_level level);
+
 /**
  * Returns the number of logged in users on the hub.
  */
@@ -344,21 +342,6 @@ extern void hub_schedule_runslice(struct hub_info* hub);
  */
 extern void hub_event_loop(struct hub_info* hub);
 
-/**
- * Schedule destroying a user.
- */
-extern void hub_schedule_destroy_user(struct hub_info* hub, struct hub_user* user);
-
-/**
- * Disconnect a user from the hub.
- */
-extern void hub_disconnect_user(struct hub_info* hub, struct hub_user* user, int reason);
-
-/**
- * Log a user logging out.
- */
-extern void hub_logout_log(struct hub_info* hub, struct hub_user* user);
-
 
 #endif /* HAVE_UHUB_HUB_H */
 

src/hubevent.c

@@ -0,0 +1,116 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2009, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+
+static void log_user_login(struct user* u)
+{
+	const char* cred = get_user_credential_string(u->credentials);
+	const char* addr = ip_convert_to_string(&u->ipaddr);
+	hub_log(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 user* u, enum status_message msg)
+{
+	const char* addr = ip_convert_to_string(&u->ipaddr);
+	const char* message = hub_get_status_message_log(u->hub, msg);
+	hub_log(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_logout(struct user* u, const char* message)
+{
+	const char* addr = ip_convert_to_string(&u->ipaddr);
+	hub_log(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 user* u, const char* nick)
+{
+	const char* addr = ip_convert_to_string(&u->ipaddr);
+	hub_log(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 */
+void on_login_success(struct user* u)
+{
+	/* Send user list of all existing users */
+	if (!send_user_list(u))
+		return;
+
+	/* Mark as being in the normal state, and add user to the user list */
+	user_set_state(u, state_normal);
+	user_manager_add(u);
+
+	/* Print log message */
+	log_user_login(u);
+
+	/* Announce new user to all connected users */
+	if (user_is_logged_in(u))
+		route_info_message(u);
+	
+	/* Send message of the day (if any) */
+	if (user_is_logged_in(u)) /* Previous send() can fail! */
+		hub_send_motd(u);
+}
+
+void on_login_failure(struct user* u, enum status_message msg)
+{
+	log_user_login_error(u, msg);
+	hub_send_status(u, msg, status_level_fatal);
+	user_disconnect(u, quit_logon_error);
+}
+
+void on_nick_change(struct user* u, const char* nick)
+{
+	if (user_is_logged_in(u))
+	{
+		log_user_nick_change(u, nick);
+	}
+}
+
+void on_logout_user(struct user* user)
+{
+	const char* reason = "";
+	
+	/* These are used for logging purposes */
+	switch (user->quit_reason)
+	{
+		case quit_disconnected:     reason = "disconnected";   break;
+		case quit_kicked:           reason = "kicked";         break;
+		case quit_banned:           reason = "banned";         break;
+		case quit_timeout:          reason = "timeout";        break;
+		case quit_send_queue:       reason = "send queue";     break;
+		case quit_memory_error:     reason = "out of memory";  break;
+		case quit_socket_error:     reason = "socket error";   break;
+		case quit_protocol_error:   reason = "protocol error"; break;
+		case quit_logon_error:      reason = "login error";    break;
+		case quit_hub_disabled:     reason = "hub disabled";   break;
+		case quit_ghost_timeout:    reason = "ghost";          break;
+		default:
+			if (user->hub->status == hub_status_shutdown)
+				reason = "hub shutdown";
+			else
+				reason = "unknown error";
+			break;
+	}
+	
+	log_user_logout(user, reason);
+	user->quit_reason = 0;
+}
+

src/hubevent.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2009, 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,22 +23,22 @@
 /**
  * This event is triggered whenever a user successfully logs in to the hub.
  */
-extern void on_login_success(struct hub_info* hub, struct hub_user* u);
+extern void on_login_success(struct user* u);
 
 /**
  * This event is triggered whenever a user failed to log in to the hub.
  */
-extern void on_login_failure(struct hub_info* hub, struct hub_user* u, enum status_message msg);
+extern void on_login_failure(struct user* u, enum status_message msg);
 
 /**
  * This event is triggered whenever a previously logged in user leaves the hub.
  */
-extern void on_logout_user(struct hub_info* hub, struct hub_user* u);
+extern void on_logout_user(struct user* u);
 
 /**
  * This event is triggered whenever a user changes his/her nickname.
  */
-extern void on_nick_change(struct hub_info* hub, struct hub_user* u, const char* nick);
+extern void on_nick_change(struct user* u, const char* nick);
 
 
 #endif /* HAVE_UHUB_HUB_EVENT_H */

src/inf.c

@@ -39,16 +39,15 @@ static void remove_server_restricted_flags(struct adc_message* cmd)
 	adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_REFERER);
 }
 
-static int set_feature_cast_supports(struct hub_user* u, struct adc_message* cmd)
+static int user_is_protected(struct user* user);
+
+static int set_feature_cast_supports(struct user* u, struct adc_message* cmd)
 {
 	char *it, *tmp;
 	
 	if (adc_msg_has_named_argument(cmd, ADC_INF_FLAG_SUPPORT))
 	{
 		tmp = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_SUPPORT);
-		if (!tmp)
-			return -1; // FIXME: OOM
-
 		user_clear_feature_cast_support(u);
 		
 		it = tmp;
@@ -90,7 +89,7 @@ static int check_hash_tiger(const char* cid, const char* pid)
 /*
  * FIXME: Only works for tiger hash. If a client doesnt support tiger we cannot let it in!
  */
-static int check_cid(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
+static int check_cid(struct user* user, struct adc_message* cmd)
 {
 	size_t pos;
 	char* cid = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_CLIENT_ID);
@@ -151,7 +150,7 @@ static int check_cid(struct hub_info* hub, struct hub_user* user, struct adc_mes
 }
 
 
-static int check_required_login_flags(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
+static int check_required_login_flags(struct user* user, struct adc_message* cmd)
 {
 	int num = 0;
 	
@@ -187,15 +186,15 @@ static int check_required_login_flags(struct hub_info* hub, struct hub_user* use
  * remove any wrong address, and replace it with the correct one
  * as seen by the hub.
  */
-int check_network(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
+int check_network(struct user* user, struct adc_message* cmd)
 {
-	const char* address = user_get_address(user);
+	const char* address = ip_convert_to_string(&user->ipaddr);
 	
 	/* Check for NAT override address */
-	if (acl_is_ip_nat_override(hub->acl, address))
+	if (acl_is_ip_nat_override(user->hub->acl, address))
 	{
 		char* client_given_ip = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_IPV4_ADDR);
-		if (client_given_ip && strcmp(client_given_ip, "0.0.0.0") != 0)
+		if (strcmp(client_given_ip, "0.0.0.0") != 0)
 		{
 			user_set_nat_override(user);
 			adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV6_ADDR);
@@ -223,13 +222,6 @@ int check_network(struct hub_info* hub, struct hub_user* user, struct adc_messag
 	return 0;
 }
 
-void strip_network(struct hub_user* user, struct adc_message* cmd)
-{
-	adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV6_ADDR);
-	adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV6_UDP_PORT);
-	adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV4_ADDR);
-	adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV4_UDP_PORT);
-}
 
 static int nick_length_ok(const char* nick)
 {
@@ -277,7 +269,7 @@ static int nick_is_utf8(const char* nick)
 }
 
 
-static int check_nick(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
+static int check_nick(struct user* user, struct adc_message* cmd)
 {
 	char* nick;
 	char* tmp;
@@ -325,10 +317,10 @@ static int check_nick(struct hub_info* hub, struct hub_user* user, struct adc_me
 }
 
 
-static int check_logged_in(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
+static int check_logged_in(struct user* user, struct adc_message* cmd)
 {
-	struct hub_user* lookup1 = uman_get_user_by_nick(hub, user->id.nick);
+	struct user* lookup1 = get_user_by_nick(user->hub, user->id.nick);
-	struct hub_user* lookup2 = uman_get_user_by_cid(hub,  user->id.cid);
+	struct user* lookup2 = get_user_by_cid(user->hub,  user->id.cid);
 	
 	if (lookup1 == user)
 	{
@@ -339,20 +331,20 @@ static int check_logged_in(struct hub_info* hub, struct hub_user* user, struct a
 	{
 		if (lookup1 == lookup2)
 		{
-			LOG_DEBUG("check_logged_in: exact same user is logged in: %s", user->id.nick);
+			hub_log(log_debug, "check_logged_in: exact same user is logged in: %s", user->id.nick);
-			hub_disconnect_user(hub, lookup1, quit_ghost_timeout);
+			user_disconnect(lookup1, quit_ghost_timeout);
 			return 0;
 		}
 		else
 		{
 			if (lookup1)
 			{
-				LOG_DEBUG("check_logged_in: nickname is in use: %s", user->id.nick);
+				hub_log(log_debug, "check_logged_in: nickname is in use: %s", user->id.nick);
 				return status_msg_inf_error_nick_taken;
 			}
 			else
 			{
-				LOG_DEBUG("check_logged_in: CID is in use: %s", user->id.cid);
+				hub_log(log_debug, "check_logged_in: CID is in use: %s", user->id.cid);
 				return status_msg_inf_error_cid_taken;
 			}
 		}
@@ -366,7 +358,7 @@ static int check_logged_in(struct hub_info* hub, struct hub_user* user, struct a
  * But this is not something we want to do, and is deprecated in the ADC specification.
  * One should rather look at capabilities/features.
  */
-static int check_user_agent(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
+static int check_user_agent(struct user* user, struct adc_message* cmd)
 {
 	char* ua_encoded = 0;
 	char* ua = 0;
@@ -387,19 +379,19 @@ static int check_user_agent(struct hub_info* hub, struct hub_user* user, struct
 }
 
 
-static int check_acl(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
+static int check_acl(struct user* user, struct adc_message* cmd)
 {
-	if (acl_is_cid_banned(hub->acl, user->id.cid))
+	if (acl_is_cid_banned(user->hub->acl, user->id.cid))
 	{
 		return status_msg_ban_permanently;
 	}
 	
-	if (acl_is_user_banned(hub->acl, user->id.nick))
+	if (acl_is_user_banned(user->hub->acl, user->id.nick))
 	{
 		return status_msg_ban_permanently;
 	}
 
-	if (acl_is_user_denied(hub->acl, user->id.nick))
+	if (acl_is_user_denied(user->hub->acl, user->id.nick))
 	{
 		return status_msg_inf_error_nick_restricted;
 	}
@@ -407,7 +399,7 @@ static int check_acl(struct hub_info* hub, struct hub_user* user, struct adc_mes
 	return 0;
 }
 
-static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
+static int check_limits(struct user* user, struct adc_message* cmd)
 {
 	char* arg = adc_msg_get_named_argument(cmd, ADC_INF_FLAG_SHARED_SIZE);
 	if (arg)
@@ -418,8 +410,8 @@ static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_
 		
 		if (user_is_logged_in(user))
 		{
-			hub->users->shared_size  -= user->limits.shared_size;
+			user->hub->users->shared_size  -= user->limits.shared_size;
-			hub->users->shared_size  += shared_size;
+			user->hub->users->shared_size  += shared_size;
 		}
 		user->limits.shared_size = shared_size;
 		hub_free(arg);
@@ -435,8 +427,8 @@ static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_
 		
 		if (user_is_logged_in(user))
 		{
-			hub->users->shared_files -= user->limits.shared_files;
+			user->hub->users->shared_files -= user->limits.shared_files;
-			hub->users->shared_files += shared_files;
+			user->hub->users->shared_files += shared_files;
 		}
 		user->limits.shared_files = shared_files;
 		hub_free(arg);
@@ -488,37 +480,37 @@ static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_
 
 	if (!user_is_protected(user))
 	{
-		if (user->limits.shared_size < hub_get_min_share(hub) && hub_get_min_share(hub))
+		if (user->limits.shared_size < hub_get_min_share(user->hub) && hub_get_min_share(user->hub))
 		{
 			return status_msg_user_share_size_low;
 		}
 
-		if (user->limits.shared_size > hub_get_max_share(hub) && hub_get_max_share(hub))
+		if (user->limits.shared_size > hub_get_max_share(user->hub) && hub_get_max_share(user->hub))
 		{
 			return status_msg_user_share_size_high;
 		}
 		
-		if ((user->limits.hub_count_user           > hub_get_max_hubs_user(hub)  && hub_get_max_hubs_user(hub)) ||
+		if ((user->limits.hub_count_user       > hub_get_max_hubs_user(user->hub)  && hub_get_max_hubs_user(user->hub)) ||
-			(user->limits.hub_count_registered > hub_get_max_hubs_reg(hub)   && hub_get_max_hubs_reg(hub))  ||
+			(user->limits.hub_count_registered > hub_get_max_hubs_reg(user->hub)   && hub_get_max_hubs_reg(user->hub)) ||
-			(user->limits.hub_count_operator   > hub_get_max_hubs_op(hub)    && hub_get_max_hubs_op(hub))   ||
+			(user->limits.hub_count_operator   > hub_get_max_hubs_op(user->hub)    && hub_get_max_hubs_op(user->hub)) ||
-			(user->limits.hub_count_total      > hub_get_max_hubs_total(hub) && hub_get_max_hubs_total(hub)))
+			(user->limits.hub_count_total      > hub_get_max_hubs_total(user->hub) && hub_get_max_hubs_total(user->hub)))
 		{
 			return status_msg_user_hub_limit_high;
 		}
 		
-		if ((user->limits.hub_count_user           < hub_get_min_hubs_user(hub)  && hub_get_min_hubs_user(hub)) ||
+		if ((user->limits.hub_count_user       < hub_get_min_hubs_user(user->hub)  && hub_get_min_hubs_user(user->hub)) ||
-			(user->limits.hub_count_registered < hub_get_min_hubs_reg(hub)   && hub_get_min_hubs_reg(hub))  ||
+			(user->limits.hub_count_registered < hub_get_min_hubs_reg(user->hub)   && hub_get_min_hubs_reg(user->hub)) ||
-			(user->limits.hub_count_operator   < hub_get_min_hubs_op(hub)    && hub_get_min_hubs_op(hub)))
+			(user->limits.hub_count_operator   < hub_get_min_hubs_op(user->hub)    && hub_get_min_hubs_op(user->hub)))
 		{
 			return status_msg_user_hub_limit_low;
 		}
 		
-		if (user->limits.upload_slots < hub_get_min_slots(hub) && hub_get_min_slots(hub))
+		if (user->limits.upload_slots < hub_get_min_slots(user->hub) && hub_get_min_slots(user->hub))
 		{
 			return status_msg_user_slots_low;
 		}
 
-		if (user->limits.upload_slots > hub_get_max_slots(hub) && hub_get_max_slots(hub))
+		if (user->limits.upload_slots > hub_get_max_slots(user->hub) && hub_get_max_slots(user->hub))
 		{
 			return status_msg_user_slots_high;
 		}
@@ -533,10 +525,10 @@ static int check_limits(struct hub_info* hub, struct hub_user* user, struct adc_
  * If the hub is configured to allow only registered users and the user
  * is not recognized this will return 1.
  */
-static int set_credentials(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
+static int set_credentials(struct 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 user_access_info* info = acl_get_access_info(user->hub->acl, user->id.nick);
 	
 	if (info)
 	{
@@ -585,14 +577,85 @@ static int set_credentials(struct hub_info* hub, struct hub_user* user, struct a
 }
 
 
+/**
+ * Determines if a user is to be let into the hub even if the hub is "full".
+ */
+static int user_is_protected(struct 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;
+}
 
-static int check_is_hub_full(struct hub_info* hub, struct hub_user* user)
+/**
+ * Returns 1 if a user is registered.
+ * Only registered users will be let in if the hub is configured for registered
+ * users only.
+ */
+static int user_is_registered(struct 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;
+}
+
+
+void update_user_info(struct user* u, struct adc_message* cmd)
+{
+	char prefix[2];
+	char* argument;
+	size_t n = 0;
+	struct adc_message* cmd_new = adc_msg_copy(u->info);
+	if (!cmd_new)
+	{
+		/* FIXME: OOM! */
+		return;
+	}
+	
+	argument = adc_msg_get_argument(cmd, n++);
+	while (argument)
+	{
+		if (strlen(argument) >= 2)
+		{
+			prefix[0] = argument[0];
+			prefix[1] = argument[1];
+			adc_msg_replace_named_argument(cmd_new, prefix, argument+2);
+		}
+		
+		hub_free(argument);
+		argument = adc_msg_get_argument(cmd, n++);
+	}
+	user_set_info(u, cmd_new);
+	adc_msg_free(cmd_new);
+}
+
+
+static int check_is_hub_full(struct 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 (user->hub->config->max_users && user->hub->users->count >= user->hub->config->max_users && !user_is_protected(user))
 	{
 		return 1;
 	}
@@ -600,16 +663,23 @@ static int check_is_hub_full(struct hub_info* hub, struct hub_user* user)
 }
 
 
-static int check_registered_users_only(struct hub_info* hub, struct hub_user* user)
+static int check_registered_users_only(struct user* user)
 {
-	if (hub->config->registered_users_only && !user_is_registered(user))
+	if (user->hub->config->registered_users_only && !user_is_registered(user))
 	{
 		return 1;
 	}
 	return 0;
 }
 
-static int hub_handle_info_common(struct hub_user* user, struct adc_message* cmd)
+#define INF_CHECK(FUNC, USER, CMD) \
+	do { \
+		int ret = FUNC(USER, CMD); \
+		if (ret < 0) \
+			return ret; \
+	} while(0)
+
+static int hub_handle_info_common(struct user* user, struct adc_message* cmd)
 {
 	/* Remove server restricted flags */
 	remove_server_restricted_flags(cmd);
@@ -620,9 +690,9 @@ static int hub_handle_info_common(struct hub_user* user, struct adc_message* cmd
 	return 0;
 }
 
-static int hub_handle_info_low_bandwidth(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
+static int hub_handle_info_low_bandwidth(struct user* user, struct adc_message* cmd)
 {
-	if (hub->config->low_bandwidth_mode)
+	if (user->hub->config->low_bandwidth_mode)
 	{
 		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_USER_AGENT);
 		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_SHARED_FILES);
@@ -641,63 +711,45 @@ static int hub_handle_info_low_bandwidth(struct hub_info* hub, struct hub_user*
 	return 0;
 }
 
-#define INF_CHECK(FUNC, HUB, USER, CMD) \
+int hub_handle_info_login(struct user* user, struct adc_message* cmd)
-	do { \
-		int ret = FUNC(HUB, USER, CMD); \
-		if (ret < 0) \
-			return ret; \
-	} while(0)
-
-int hub_perform_login_checks(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
 {
+	int need_auth = 0;
+	
 	/* Make syntax checks.  */
-	INF_CHECK(check_required_login_flags, hub, user, cmd);
+	INF_CHECK(check_required_login_flags,     user, cmd);
-	INF_CHECK(check_cid,                  hub, user, cmd);
+	INF_CHECK(check_cid,                      user, cmd);
-	INF_CHECK(check_nick,                 hub, user, cmd);
+	INF_CHECK(check_nick,                     user, cmd);
-	INF_CHECK(check_network,              hub, user, cmd);
+	INF_CHECK(check_network,                  user, cmd);
-	INF_CHECK(check_user_agent,           hub, user, cmd);
+	INF_CHECK(check_user_agent,               user, cmd);
-	INF_CHECK(check_acl,                  hub, user, cmd);
+	INF_CHECK(check_acl,                      user, cmd);
-	INF_CHECK(check_logged_in,            hub, user, cmd);
+	INF_CHECK(check_logged_in,                user, cmd);
-	return 0;
-}
-
-/**
- * Perform additional INF checks used at time of login.
- *
- * @return 0 if success, <0 if error, >0 if authentication needed.
- */
-int hub_handle_info_login(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
-{
-	int code = 0;
-
-	INF_CHECK(hub_perform_login_checks, hub, user, cmd);
 	
 	/* Private ID must never be broadcasted - drop it! */
 	adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_PRIVATE_ID);
 	
-	
+	/* FIXME: This needs some cleaning up */
-	code = set_credentials(hub, user, cmd);
+	need_auth = set_credentials(user, cmd);
 	
 	/* Note: this must be done *after* set_credentials. */
-	if (check_is_hub_full(hub, user))
+	if (check_is_hub_full(user))
 	{
 		return status_msg_hub_full;
 	}
 	
-	if (check_registered_users_only(hub, user))
+	if (check_registered_users_only(user))
 	{
 		return status_msg_hub_registered_users_only;
 	}
 	
-	INF_CHECK(check_limits, hub, user, cmd);
+	INF_CHECK(check_limits, user, cmd);
 	
 	/* strip off stuff if low_bandwidth_mode is enabled */
-	hub_handle_info_low_bandwidth(hub, user, cmd);
+	hub_handle_info_low_bandwidth(user, cmd);
 	
 	/* Set initial user info */
 	user_set_info(user, cmd);
 	
-	return code;
+	return need_auth;
 }
 
 /*
@@ -713,7 +765,7 @@ int hub_handle_info_login(struct hub_info* hub, struct hub_user* user, struct ad
  * - CID/PID (valid, not taken, etc).
  * - IP addresses (IPv4 and IPv6)
  */
-int hub_handle_info(struct hub_info* hub, struct hub_user* user, const struct adc_message* cmd_unmodified)
+int hub_handle_info(struct user* user, const struct adc_message* cmd_unmodified)
 {
 	struct adc_message* cmd = adc_msg_copy(cmd_unmodified);
 	if (!cmd) return -1; /* OOM */
@@ -737,10 +789,10 @@ int hub_handle_info(struct hub_info* hub, struct hub_user* user, const struct ad
 			return 0;
 		}
 	
-		int ret = hub_handle_info_login(hub, user, cmd);
+		int ret = hub_handle_info_login(user, cmd);
 		if (ret < 0)
 		{
-			on_login_failure(hub, user, ret);
+			on_login_failure(user, ret);
 			adc_msg_free(cmd);
 			return -1;
 		}
@@ -752,7 +804,7 @@ int hub_handle_info(struct hub_info* hub, struct hub_user* user, const struct ad
 			post.id    = UHUB_EVENT_USER_JOIN;
 			post.ptr   = user;
 			post.flags = ret; /* 0 - all OK, 1 - need authentication */
-			event_queue_post(hub->queue, &post);
+			event_queue_post(user->hub->queue, &post);
 			adc_msg_free(cmd);
 			return 0;
 		}
@@ -769,22 +821,20 @@ int hub_handle_info(struct hub_info* hub, struct hub_user* user, const struct ad
 		 */
 		if (adc_msg_has_named_argument(cmd, ADC_INF_FLAG_NICK))
 		{
-#ifdef ALLOW_CHANGE_NICK
+#if ALLOW_CHANGE_NICK
-			if (!check_nick(hub, user, cmd))
+			if (!check_nick(user, cmd))
 #endif
 				adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_NICK);
 		}
 		
 		/* FIXME - What if limits are not met ? */
-		check_limits(hub, user, cmd);
+		check_limits(user, cmd);
-		strip_network(user, cmd);
+		hub_handle_info_low_bandwidth(user, cmd);
-		hub_handle_info_low_bandwidth(hub, user, cmd);
+		update_user_info(user, cmd);
-		
-		user_update_info(user, cmd);
 		
 		if (!adc_msg_is_empty(cmd))
 		{
-			route_message(hub, user, cmd);
+			route_message(user, cmd);
 		}
 		
 		adc_msg_free(cmd);

src/inf.h

@@ -47,7 +47,7 @@ enum nick_status
  *
  * @return 0 on success, -1 on error
  */
-extern int hub_handle_info(struct hub_info* hub, struct hub_user* u, const struct adc_message* cmd);
+extern int hub_handle_info(struct user* u, const struct adc_message* cmd);
 
 
 #endif /* HAVE_UHUB_INF_PARSER_H */

src/ipcalc.c

@@ -19,6 +19,7 @@
 
 #include "uhub.h"
 
+
 int ip_is_valid_ipv4(const char* address)
 {
 	int i = 0; /* address index */
@@ -146,7 +147,7 @@ int ip_convert_address(const char* text_address, int port, struct sockaddr* addr
 		addr6.sin6_port = htons(port);
 		if (net_string_to_address(AF_INET6, taddr, &addr6.sin6_addr) <= 0)
 		{
-			LOG_ERROR("Unable to convert socket address (ipv6)");
+			hub_log(log_fatal, "Unable to convert socket address (ipv6)");
 			return 0;
 		}
 
@@ -162,7 +163,7 @@ int ip_convert_address(const char* text_address, int port, struct sockaddr* addr
 		addr4.sin_port = htons(port);
 		if (net_string_to_address(AF_INET, taddr, &addr4.sin_addr) <= 0)
 		{
-			LOG_ERROR("Unable to convert socket address (ipv4)");
+			hub_log(log_fatal, "Unable to convert socket address (ipv4)");
 			return 0;
 		}
 		memcpy(addr, &addr4, sockaddr_size);
@@ -218,7 +219,7 @@ int ip_mask_create_left(int af, int bits, struct ip_addr_encap* result)
 
 #ifdef IP_CALC_DEBUG
 	char* r_str = hub_strdup(ip_convert_to_string(result));
-	LOG_DUMP("Created left mask: %s", r_str);
+	hub_log(log_debug, "Created left mask: %s", r_str);
 	hub_free(r_str);
 #endif
 
@@ -271,7 +272,7 @@ int ip_mask_create_right(int af, int bits, struct ip_addr_encap* result)
 	
 #ifdef IP_CALC_DEBUG
 	char* r_str = hub_strdup(ip_convert_to_string(result));
-	LOG_DUMP("Created right mask: %s", r_str);
+	hub_log(log_debug, "Created right mask: %s", r_str);
 	hub_free(r_str);
 #endif
 	
@@ -404,7 +405,7 @@ int ip_compare(struct ip_addr_encap* a, struct ip_addr_encap* b)
 #ifdef IP_CALC_DEBUG
 	char* a_str = hub_strdup(ip_convert_to_string(a));
 	char* b_str = hub_strdup(ip_convert_to_string(b));
-	LOG_DUMP("Comparing IPs '%s' AND '%s' => %d", a_str, b_str, ret);
+	hub_log(log_debug, "Comparing IPs '%s' AND '%s' => %d", a_str, b_str, ret);
 	hub_free(a_str);
 	hub_free(b_str);
 #endif
@@ -412,80 +413,13 @@ int ip_compare(struct ip_addr_encap* a, struct ip_addr_encap* b)
 	return ret;
 }
 
-static int check_ip_mask(const char* text_addr, int bits, struct ip_range* range)
-{
-	if (ip_is_valid_ipv4(text_addr) || ip_is_valid_ipv6(text_addr))
-	{
-		struct ip_addr_encap addr;
-		struct ip_addr_encap mask1;
-		struct ip_addr_encap mask2;
-		int af = ip_convert_to_binary(text_addr, &addr);  /* 192.168.1.2 */
-		int maxbits = (af == AF_INET6 ? 128 : 32);
-		bits = MIN(MAX(bits, 0), maxbits);
-		ip_mask_create_left(af, bits, &mask1);            /* 255.255.255.0 */
-		ip_mask_create_right(af, maxbits - bits, &mask2); /* 0.0.0.255 */
-		ip_mask_apply_AND(&addr, &mask1, &range->lo);     /* 192.168.1.0 */
-		ip_mask_apply_OR(&range->lo, &mask2, &range->hi); /* 192.168.1.255 */
-		return 1;
-	}
-	return 0;
-}
 
-static int check_ip_range(const char* lo, const char* hi, struct ip_range* range)
-{
-	int ret1, ret2;
-	if ((ip_is_valid_ipv4(lo) && ip_is_valid_ipv4(hi)) || (ip_is_valid_ipv6(lo) && ip_is_valid_ipv6(hi)))
-	{
-		ret1 = ip_convert_to_binary(lo, &range->lo);
-		ret2 = ip_convert_to_binary(hi, &range->hi);
-		if (ret1 == -1 || ret2 == -1 || ret1 != ret2)
-		{
-			return 0;
-		}
-		return 1;
-	}
-	return 0;
-}
 
-int ip_convert_address_to_range(const char* address, struct ip_range* range)
-{
-	int ret = 0;
-	char* addr = 0;
 
-	if (!address || !range)
-		return 0;
 
-	const char* split = strrchr(address, '/');
-	if (split)
-	{
-		int mask = uhub_atoi(split+1);
-		if (mask == 0 && split[1] != '0') return 0;
-		addr = hub_strndup(address, split - address);
-		ret = check_ip_mask(addr, mask, range);
-		hub_free(addr);
-		return ret;
-	}
 
-	split = strrchr(address, '-');
-	if (split)
-	{
-		addr = hub_strndup(address, split - address);
-		ret = check_ip_range(addr, split+1, range);
-		hub_free(addr);
-		return ret;
-	}
 
-	if (ip_is_valid_ipv4(address) || ip_is_valid_ipv6(address))
-	{
-		if (ip_convert_to_binary(address, &range->lo) == -1)
-			return 0;
-		memcpy(&range->hi, &range->lo, sizeof(struct ip_addr_encap));
-		return 1;
-	}
-	return 0;
-}
 
-int ip_in_range(struct ip_addr_encap* addr, struct ip_range* range)
+
-{
+
-	return (addr->af == range->lo.af && ip_compare(&range->lo, addr) <= 0 && ip_compare(addr, &range->hi) <= 0);
+
-}

src/ipcalc.h

@@ -33,57 +33,26 @@ struct ip_addr_encap {
 	} internal_ip_data;
 };
 
-struct ip_range
-{
-	struct ip_addr_encap lo;
-	struct ip_addr_encap hi;
-};
 
 extern int ip_convert_to_binary(const char* text_addr, struct ip_addr_encap* raw);
 
 extern const char* ip_convert_to_string(struct ip_addr_encap* raw);
 
-/**
- * Convert a string on the form:
- * ip-ip or ip/mask to an iprange.
- *
- * Note: both IPv4 and IPv6 addresses are valid, but if a range is given
- * both addresses must be of the same address family.
- *
- * Valid examples of address
- * IPv4:
- * 192.168.2.1
- * 192.168.0.0/16
- * 192.168.0.0-192.168.255.255
- *
- * IPv6:
- * 2001:4860:A005::68
- * 2001:4860:A005::0/80
- * 2001:4860:A005::0-2001:4860:A005:ffff:ffff:ffff:ffff:ffff
- *
- * @return 0 if invalid, 1 if OK
- */
-extern int ip_convert_address_to_range(const char* address, struct ip_range* range);
 
-/**
+/*
- * @return 1 if addr is inside range, 0 otherwise
- */
-extern int ip_in_range(struct ip_addr_encap* addr, struct ip_range* range);
-
-/**
  * @return 1 if address is a valid IPv4 address in text notation
  *         0 if invalid
  */
 extern int ip_is_valid_ipv4(const char* address);
 
-/**
+/*
  * @return 1 if address is a valid IPv6 address in text notation
  *         0 if invalid
  */
 extern int ip_is_valid_ipv6(const char* address);
 
 
-/**
+/*
  * This function converts an IP address in text_address to a binary
  * struct sockaddr.
  * This will auto-detect if the IP-address is IPv6 (and that is supported),
@@ -97,6 +66,7 @@ extern int ip_is_valid_ipv6(const char* address);
  */
 extern int ip_convert_address(const char* text_address, int port, struct sockaddr* addr, socklen_t* addr_len);
 
+
 extern int ip_mask_create_left(int af, int bits, struct ip_addr_encap* result);
 extern int ip_mask_create_right(int af, int bits, struct ip_addr_encap* result);
 

src/list.c

@@ -54,11 +54,6 @@ void list_clear(struct linked_list* list, void (*free_handle)(void* ptr))
 void list_append(struct linked_list* list, void* data_ptr)
 {
 	struct node* new_node = (struct node*) hub_malloc_zero(sizeof(struct node));
-	if (!new_node)
-	{
-		LOG_FATAL("Unable to allocate memory");
-		return;
-	}
 	new_node->ptr = data_ptr;
 	
 	if (list->last)

src/log.h

@@ -33,31 +33,6 @@ enum log_verbosity {
 	log_protocol = 9,
 };
 
-#define LOG_FATAL(format, ...)  hub_log(log_fatal,    format, ## __VA_ARGS__)
-#define LOG_ERROR(format, ...)  hub_log(log_error,    format, ## __VA_ARGS__)
-#define LOG_WARN(format, ...)   hub_log(log_warning,  format, ## __VA_ARGS__)
-#define LOG_USER(format, ...)   hub_log(log_user,     format, ## __VA_ARGS__)
-#define LOG_INFO(format, ...)   hub_log(log_info,     format, ## __VA_ARGS__)
-
-#ifdef DEBUG
-# define LOG_DEBUG(format, ...)  hub_log(log_debug,    format, ## __VA_ARGS__)
-# define LOG_TRACE(format, ...)  hub_log(log_trace,    format, ## __VA_ARGS__)
-#else
-# define LOG_DEBUG(format, ...)  do { } while(0)
-# define LOG_TRACE(format, ...)  do { } while(0)
-#endif
-
-#ifdef LOWLEVEL_DEBUG
-# define LOG_DUMP(format, ...)   hub_log(log_dump,     format, ## __VA_ARGS__)
-# define LOG_MEMORY(format, ...) hub_log(log_memory,   format, ## __VA_ARGS__)
-# define LOG_PROTO(format, ...)  hub_log(log_protocol, format, ## __VA_ARGS__)
-#else
-# define LOG_DUMP(format, ...)   do { } while(0)
-# define LOG_MEMORY(format, ...) do { } while(0)
-# define LOG_PROTO(format, ...)  do { } while(0)
-#endif
-
-
 /**
  * Specify a minimum log verbosity for what messages should
  * be printed in the log.

src/main.c

@@ -29,11 +29,10 @@ static const char* arg_uid = 0;
 static const char* arg_gid = 0;
 static const char* arg_config  = 0;
 static const char* arg_log = 0;
-static const char* arg_pid = 0;
 static int arg_log_syslog = 0;
 
 
-#if !defined(WIN32) && defined(USE_LIBEVENT)
+#ifndef WIN32
 void hub_handle_signal(int fd, short events, void* arg)
 {
 	struct hub_info* hub = (struct hub_info*) arg;
@@ -42,12 +41,12 @@ void hub_handle_signal(int fd, short events, void* arg)
 	switch (signal)
 	{
 		case SIGINT:
-			LOG_INFO("Interrupted. Shutting down...");
+			hub_log(log_info, "Interrupted. Shutting down...");
 			hub->status = hub_status_shutdown;
 			break;
 
 		case SIGTERM:
-			LOG_INFO("Terminated. Shutting down...");
+			hub_log(log_info, "Terminated. Shutting down...");
 			hub->status = hub_status_shutdown;
 			break;
 
@@ -59,7 +58,7 @@ void hub_handle_signal(int fd, short events, void* arg)
 			break;
 
 		default:
-			LOG_TRACE("hub_handle_signal(): caught unknown signal: %d", signal);
+			hub_log(log_trace, "hub_handle_signal(): caught unknown signal: %d", signal);
 			hub->status = hub_status_shutdown;
 			break;
 	}
@@ -81,11 +80,12 @@ void setup_signal_handlers(struct hub_info* hub)
 	for (i = 0; signals[i]; i++)
 	{
 		signal_set(&signal_events[i], signals[i], hub_handle_signal, hub);
+		event_base_set(hub->evbase, &signal_events[i]);
 		if (signal_add(&signal_events[i], NULL))
 		{
-			LOG_ERROR("Error setting signal handler %d", signals[i]);
+			hub_log(log_error, "Error setting signal handler %d", signals[i]);
 		}
-	}
+    }
 }
 
 void shutdown_signal_handlers(struct hub_info* hub)
@@ -94,10 +94,10 @@ void shutdown_signal_handlers(struct hub_info* hub)
 	for (i = 0; signals[i]; i++)
 	{
 		signal_del(&signal_events[i]);
-	}
+    }
 }
 
-#endif /* !WIN32 && USE_LIBEVENT*/
+#endif /* WIN32 */
 
 
 int main_loop()
@@ -113,8 +113,8 @@ int main_loop()
 	{
 		if (hub)
 		{
-			LOG_INFO("Reloading configuration files...");
+			hub_log(log_info, "Reloading configuration files...");
-			LOG_DEBUG("Hub status: %d", (int) hub->status);
+			hub_log(log_debug, "Hub status: %d", (int) hub->status);
 		}
 	
 		if (read_config(arg_config, &configuration, !arg_have_config) == -1)
@@ -133,7 +133,7 @@ int main_loop()
 			hub = hub_start_service(&configuration);
 			if (!hub)
 				return -1;
-#if !defined(WIN32) && defined(USE_LIBEVENT)
+#ifndef WIN32
 			setup_signal_handlers(hub);
 #endif
 		}
@@ -146,9 +146,9 @@ int main_loop()
 		acl_shutdown(&acl);
 		free_config(&configuration);
 
-	} while (hub->status == hub_status_restart);
+	} while(hub->status != hub_status_shutdown);
 
-#if !defined(WIN32) && defined(USE_LIBEVENT)
+#ifndef WIN32
 	shutdown_signal_handlers(hub);
 #endif
 	
@@ -157,7 +157,7 @@ int main_loop()
 		hub_shutdown_service(hub);
 	}
 
-	net_destroy();
+	net_shutdown();
 	hub_log_shutdown();
 	return 0;
 }
@@ -190,7 +190,7 @@ int check_configuration(int dump)
 
 void print_version()
 {
-	fprintf(stdout, "" PRODUCT " " VERSION "\n");
+	fprintf(stdout, "" PRODUCT " " VERSION " " PRODUCT_TITLE "\n");
 	fprintf(stdout, "Copyright (C) 2007-2009, Jan Vidar Krey <janvidar@extatic.org>\n"
 			"This is free software with ABSOLUTELY NO WARRANTY.\n\n");
 	exit(0);
@@ -215,7 +215,6 @@ void print_usage(char* program)
 #ifndef WIN32
 		"   -u <user>   Run as given user\n"
 		"   -g <group>  Run with given group permissions\n"
-		"   -p <file>   Store pid in file (process id)\n"
 #endif
 		"   -V          Show version number.\n"
 	);
@@ -227,7 +226,7 @@ void print_usage(char* program)
 void parse_command_line(int argc, char** argv)
 {
 	int opt;
-	while ((opt = getopt(argc, argv, "vqfc:l:hu:g:VCsSLp:")) != -1)
+	while ((opt = getopt(argc, argv, "vqfc:l:hu:g:VCsSL")) != -1)
 	{
 		switch (opt)
 		{
@@ -287,10 +286,6 @@ void parse_command_line(int argc, char** argv)
 				arg_gid = optarg;
 				break;
 
-			case 'p':
-				arg_pid = optarg;
-				break;
-
 			default:
 				print_usage(argv[0]);
 				break;
@@ -334,15 +329,15 @@ int drop_privileges()
 
 		if (!ret)
 		{
-			LOG_FATAL("Unable to determine group id, check group name.");
+			hub_log(log_fatal, "Unable to determine group id, check group name.");
 			return -1;
 		}
 
-		LOG_TRACE("Setting group id %d (%s)", (int) perm_gid, arg_gid);
+		hub_log(log_trace, "Setting group id %d (%s)", (int) perm_gid, arg_gid);
 		ret = setgid(perm_gid);
 		if (ret == -1)
 		{
-			LOG_FATAL("Unable to change group id, permission denied.");
+			hub_log(log_fatal, "Unable to change group id, permission denied.");
 			return -1;
 		}
 		gid_ok = 1;
@@ -367,58 +362,31 @@ int drop_privileges()
 
 		if (!ret)
 		{
-			LOG_FATAL("Unable to determine user id, check user name.");
+			hub_log(log_fatal, "Unable to determine user id, check user name.");
 			return -1;
 		}
 
 		if (!gid_ok) {
-			LOG_TRACE("Setting group id %d (%s)", (int) perm_gid, arg_gid);
+			hub_log(log_trace, "Setting group id %d (%s)", (int) perm_gid, arg_gid);
 			ret = setgid(perm_gid);
 			if (ret == -1)
 			{
-				LOG_FATAL("Unable to change group id, permission denied.");
+				hub_log(log_fatal, "Unable to change group id, permission denied.");
 				return -1;
 			}
 		}
 
-		LOG_TRACE("Setting user id %d (%s)", (int) perm_uid, arg_uid);
+		hub_log(log_trace, "Setting user id %d (%s)", (int) perm_uid, arg_uid);
 		ret = setuid(perm_uid);
 		if (ret == -1)
 		{
-			LOG_FATAL("Unable to change user id, permission denied.");
+			hub_log(log_fatal, "Unable to change user id, permission denied.");
 			return -1;
 		}
 	}
 
 	return 0;
 }
-
-int pidfile_create()
-{
-	if (arg_pid)
-	{
-		FILE* pidfile = fopen(arg_pid, "w");
-	        if (!pidfile)
-		{
-			LOG_FATAL("Unable to write pid file: %s\n", arg_pid);
-			return -1;
-		}
-
-		fprintf(pidfile, "%d", (int) getpid());
-		fclose(pidfile);
-	}
-	return 0;
-}
-
-int pidfile_destroy()
-{
-	if (arg_pid)
-	{
-		return unlink(arg_pid);
-	}
-	return 0;
-}
-
 #endif /* WIN32 */
 
 
@@ -439,40 +407,26 @@ int main(int argc, char** argv)
 		ret = fork();
 		if (ret == -1)
 		{
-			LOG_FATAL("Unable to fork to background!");
+			hub_log(log_fatal, "Unable to fork to background!");
 			return -1;
 		}
 		else if (ret == 0)
 		{
-			/* child process - detatch from TTY */
+			/* child process */
-			fclose(stdin);
-			fclose(stdout);
-			fclose(stderr);
-			close(0);
-			close(1);
-			close(2);
 		}
 		else
 		{
 			/* parent process */
-			LOG_DEBUG("Forked to background\n");
+			hub_log(log_debug, "Forked to background\n");
 			return 0;
 		}
 	}
 
-	if (pidfile_create() == -1)
-		return -1;
-
 	if (drop_privileges() == -1)
 		return -1;
 #endif /* WIN32 */
 
 	ret = main_loop();
-
-#ifndef WIN32
-	pidfile_destroy();
-#endif
-
 	return ret;
 }
 

src/memory.c

@@ -47,7 +47,7 @@ void internal_debug_print_leaks()
 	size_t n = 0;
 	size_t leak = 0;
 	size_t count = 0;
-	LOG_MEMORY("--- exit (allocs: %d, size: " PRINTF_SIZE_T ") ---", hub_alloc_count, hub_alloc_size);
+	hub_log(log_memory, "--- exit (allocs: %d, size: %zu) ---", hub_alloc_count, hub_alloc_size);
 	
 	for (; n < UHUB_MAX_ALLOCS; n++)
 	{
@@ -55,11 +55,11 @@ void internal_debug_print_leaks()
 		{
 			leak += hub_allocs[n].size;
 			count++;
-			LOG_MEMORY("leak %p size: " PRINTF_SIZE_T " (bt: %p %p)", hub_allocs[n].ptr, hub_allocs[n].size, hub_allocs[n].stack1, hub_allocs[n].stack2);
+			hub_log(log_memory, "leak %p size: %zu (bt: %p %p)", hub_allocs[n].ptr, hub_allocs[n].size, hub_allocs[n].stack1, hub_allocs[n].stack2);
 		}
 	}
 	
-	LOG_MEMORY("--- done (allocs: %d, size: " PRINTF_SIZE_T ", peak: %d/" PRINTF_SIZE_T ", oom: " PRINTF_SIZE_T ") ---", count, leak, hub_alloc_peak_count, hub_alloc_peak_size, hub_alloc_oom);
+	hub_log(log_memory, "--- done (allocs: %d, size: %zu, peak: %d/%zu, oom: %zu) ---", count, leak, hub_alloc_peak_count, hub_alloc_peak_size, hub_alloc_oom);
 }
 #endif /* REALTIME_MALLOC_TRACKING */
 
@@ -73,7 +73,7 @@ void* internal_debug_mem_malloc(size_t size, const char* where)
 	/* Make sure the malloc info struct is initialized */
 	if (!hub_alloc_count)
 	{
-		LOG_MEMORY("--- start ---");
+		hub_log(log_memory, "--- start ---");
 		for (n = 0; n < UHUB_MAX_ALLOCS; n++)
 		{
 			hub_allocs[n].ptr    = 0;
@@ -107,14 +107,14 @@ void* internal_debug_mem_malloc(size_t size, const char* where)
 				hub_alloc_peak_count = MAX(hub_alloc_count, hub_alloc_peak_count);
 				hub_alloc_peak_size  = MAX(hub_alloc_size,  hub_alloc_peak_size);
 				
-				LOG_MEMORY("%s %p (%d bytes) (bt: %p %p) {allocs: %d, size: " PRINTF_SIZE_T "}", where, ptr, (int) size, hub_allocs[n].stack1, hub_allocs[n].stack2, hub_alloc_count, hub_alloc_size);
+				hub_log(log_memory, "%s %p (%d bytes) (bt: %p %p) {allocs: %d, size: %zu}", where, ptr, (int) size, hub_allocs[n].stack1, hub_allocs[n].stack2, hub_alloc_count, hub_alloc_size);
 				break;
 			}
 		}
 	}
 	else
 	{
-		LOG_MEMORY("%s *** OOM for %d bytes", where, size);
+		hub_log(log_memory, "%s *** OOM for %d bytes", where, size);
 		hub_alloc_oom++;
 		return 0;
 	}
@@ -141,7 +141,7 @@ void internal_debug_mem_free(void* ptr)
 			hub_allocs[n].size   = 0;
 			hub_allocs[n].stack1 = 0;
 			hub_allocs[n].stack2 = 0;
-			LOG_MEMORY("free %p (bt: %p %p) {allocs: %d, size: " PRINTF_SIZE_T "}", ptr, stack1, stack2, hub_alloc_count, hub_alloc_size);
+			hub_log(log_memory, "free %p (bt: %p %p) {allocs: %d, size: %zu}", ptr, stack1, stack2, hub_alloc_count, hub_alloc_size);
 			malloc_slot = n;
 			free(ptr);
 			return;
@@ -150,7 +150,7 @@ void internal_debug_mem_free(void* ptr)
 	
 	malloc_slot = -1;
 	abort();
-	LOG_MEMORY("free %p *** NOT ALLOCATED *** (bt: %p %p)", ptr, stack1, stack2);
+	hub_log(log_memory, "free %p *** NOT ALLOCATED *** (bt: %p %p)", ptr, stack1, stack2);
 #else
 	free(ptr);
 #endif /* REALTIME_MALLOC_TRACKING */

src/message.c

@@ -26,71 +26,16 @@
 	uhub_assert(X->capacity); \
 	uhub_assert(X->length); \
 	uhub_assert(X->length <= X->capacity); \
-	uhub_assert(X->length == strlen(X->cache));
+	uhub_assert(X->length == strlen(X->cache)); \
+	uhub_assert(X->references >= 0);
 #else
 #define ADC_MSG_ASSERT(X) do { } while(0)
-#endif /* DEBUG */
+#endif
-
-#ifdef MSG_MEMORY_DEBUG
-#undef msg_malloc
-#undef msg_malloc_zero
-#undef msg_free
-
-static void* msg_malloc(size_t size)
-{
-	void* ptr = valloc(size);
-	LOG_MEMORY("msg_malloc: %p %d", ptr, (int) size);
-	return ptr;
-}
-
-static void* msg_malloc_zero(size_t size)
-{
-	void* ptr = msg_malloc(size);
-	memset(ptr, 0, size);
-	return ptr;
-}
-
-static void msg_free(void* ptr)
-{
-	LOG_MEMORY("msg_free:   %p", 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);
-#endif
 	return msg;
 #else
 	struct adc_message* copy = adc_msg_copy(msg);
@@ -116,19 +61,18 @@ static int adc_msg_grow(struct adc_message* msg, size_t size)
 	newsize += 2; /* termination */
 	newsize += (newsize % sizeof(size_t)); /* alignment padding */
 	
-	buf = msg_malloc_zero(newsize);
+	buf = hub_malloc_zero(newsize);
 	if (!buf)
 		return 0;
 	
 	if (msg->cache)
 	{
 		memcpy(buf, msg->cache, msg->length);
-		msg_free(msg->cache);
+		hub_free(msg->cache);
 	}
 	
 	msg->cache = buf;
 	msg->capacity = newsize;
-
 	return 1;
 }
 
@@ -206,20 +150,11 @@ void adc_msg_free(struct adc_message* 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
 	{
-#ifdef MSG_MEMORY_DEBUG
+		hub_free(msg->cache);
-		adc_msg_unprotect(msg);
-#endif
-		msg_free(msg->cache);
 		
 		if (msg->feature_cast_include)
 		{
@@ -235,7 +170,7 @@ void adc_msg_free(struct adc_message* msg)
 			msg->feature_cast_exclude = 0;
 		}
 		
-		msg_free(msg);
+		hub_free(msg);
 	}
 }
 
@@ -243,7 +178,7 @@ void adc_msg_free(struct adc_message* msg)
 struct adc_message* adc_msg_copy(const struct adc_message* cmd)
 {
 	char* tmp = 0;
-	struct adc_message* copy = (struct adc_message*) msg_malloc_zero(sizeof(struct adc_message));
+	struct adc_message* copy = (struct adc_message*) hub_malloc_zero(sizeof(struct adc_message));
 	if (!copy) return NULL; /* OOM */
 
 	ADC_MSG_ASSERT(cmd);
@@ -295,14 +230,11 @@ 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;
 }
 
 
-struct adc_message* adc_msg_parse_verify(struct hub_user* u, const char* line, size_t length)
+struct adc_message* adc_msg_parse_verify(struct user* u, const char* line, size_t length)
 {
 	struct adc_message* command = adc_msg_parse(line, length);
 	
@@ -311,7 +243,6 @@ struct adc_message* adc_msg_parse_verify(struct hub_user* u, const char* line, s
 	
 	if (command->source && (!u || command->source != u->id.sid))
 	{
-		LOG_DEBUG("Command does not match user's SID (command->source=%d, user->id.sid=%d)", command->source, (u ? u->id.sid : 0));
 		adc_msg_free(command);
 		return 0;
 	}
@@ -322,7 +253,7 @@ struct adc_message* adc_msg_parse_verify(struct hub_user* u, const char* line, s
 
 struct adc_message* adc_msg_parse(const char* line, size_t length)
 {
-	struct adc_message* command = (struct adc_message*) msg_malloc_zero(sizeof(struct adc_message));
+	struct adc_message* command = (struct adc_message*) hub_malloc_zero(sizeof(struct adc_message));
 	char prefix = line[0];
 	size_t n = 0;
 	char temp_sid[5];
@@ -335,8 +266,8 @@ struct adc_message* adc_msg_parse(const char* line, size_t length)
 		
 	if (!is_printable_utf8(line, length))
 	{
-		LOG_DEBUG("Dropped message with non-printable UTF-8 characters.");
+		hub_log(log_debug, "Dropped message with non-printable UTF-8 characters.");
-		msg_free(command);
+		hub_free(command);
 		return NULL;
 	}
 
@@ -347,7 +278,7 @@ struct adc_message* adc_msg_parse(const char* line, size_t length)
 
 	if (!adc_msg_grow(command, length + need_terminate))
 	{
-		msg_free(command);
+		hub_free(command);
 		return NULL; /* OOM */
 	}
 	
@@ -419,8 +350,8 @@ struct adc_message* adc_msg_parse(const char* line, size_t length)
 			{
 				list_destroy(command->feature_cast_include);
 				list_destroy(command->feature_cast_exclude);
-				msg_free(command->cache);
+				hub_free(command->cache);
-				msg_free(command);
+				hub_free(command);
 				return NULL; /* OOM */
 			}
 			
@@ -511,22 +442,19 @@ 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;
 }
 
 
 struct adc_message* adc_msg_create(const char* line)
 {
-	return adc_msg_parse(line, strlen(line));
+	return adc_msg_parse_verify(NULL, line, strlen(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));
+	struct adc_message* msg = (struct adc_message*) hub_malloc_zero(sizeof(struct adc_message));
 	
 	if (!msg)
 		return NULL; /* OOM */
@@ -535,7 +463,7 @@ struct adc_message* adc_msg_construct(fourcc_t fourcc, size_t size)
 
 	if (!adc_msg_grow(msg, size+1))
 	{
-		msg_free(msg);
+		hub_free(msg);
 		return NULL; /* OOM */
 	}
 	
@@ -555,10 +483,6 @@ 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
-
 	return msg;
 }
 
@@ -594,6 +518,7 @@ int adc_msg_remove_named_argument(struct adc_message* cmd, const char prefix_[2]
 		{
 			
 			temp_len = &end[0] - &start[0]; // strlen(start);
+			/* hub_log(log_trace, "                     length=%d", (int) (temp_len)); */
 			endlen = strlen(end);
 			
 			memmove(start, end, endlen);
@@ -698,10 +623,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 +630,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--;
@@ -736,27 +653,6 @@ int adc_msg_add_named_argument(struct adc_message* cmd, const char prefix[2], co
 	return ret;
 }
 
-int adc_msg_add_named_argument_string(struct adc_message* cmd, const char prefix[2], const char* string)
-{
-	char* escaped = adc_msg_escape(string);
-	int ret = adc_msg_add_named_argument(cmd, prefix, escaped);
-	hub_free(escaped);
-	return ret;
-}
-
-int adc_msg_add_named_argument_int(struct adc_message* cmd, const char prefix[2], int num)
-{
-	const char* s = uhub_itoa(num);
-	int ret = adc_msg_add_named_argument(cmd, prefix, s);
-	return ret;
-}
-
-int adc_msg_add_named_argument_uint64(struct adc_message* cmd, const char prefix[2], uint64_t num)
-{
-	const char* s = uhub_ulltoa(num);
-	int ret = adc_msg_add_named_argument(cmd, prefix, s);
-	return ret;
-}
 
 int adc_msg_add_argument(struct adc_message* cmd, const char* string)
 {
@@ -785,6 +681,7 @@ char* adc_msg_get_argument(struct adc_message* cmd, int offset)
 	while (start)
 	{
 		end = strchr(&start[1], ' ');
+		
 		if (count == offset)
 		{
 			if (end)
@@ -794,23 +691,17 @@ 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[strlen(argument)-1] == '\n')
 					argument[strlen(argument)-1] = 0;
 			}
 			
-			if (!argument)
-				return 0; // FIXME: OOM
-
 			if (*argument)
 			{
 				adc_msg_terminate(cmd);
 				return argument;
 			}
-			else
-			{
-				hub_free(argument);
-			}
 		}
+		
 		count++;
 		start = end;
 	}
@@ -889,7 +780,7 @@ 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);
+	char* new_string = hub_malloc(adc_msg_unescape_length(string)+1);
 	char* ptr = (char*) new_string;
 	char* str = (char*) string;
 	int escaped = 0;

src/message.h

@@ -20,7 +20,7 @@
 #ifndef HAVE_UHUB_COMMAND_H
 #define HAVE_UHUB_COMMAND_H
 
-struct hub_user;
+struct user;
 
 struct adc_message
 {
@@ -70,7 +70,7 @@ extern struct adc_message* adc_msg_copy(const struct adc_message* cmd);
  * The message is only considered valid if the user who sent it
  * is the rightful origin of the message.
  */
-extern struct adc_message* adc_msg_parse_verify(struct hub_user* u, const char* string, size_t length);
+extern struct adc_message* adc_msg_parse_verify(struct user* u, const char* string, size_t length);
 
 /**
  * This will parse 'string' and return it as a adc_message struct, or
@@ -173,22 +173,6 @@ extern int adc_msg_add_argument(struct adc_message* cmd, const char* string);
  */
 extern int adc_msg_add_named_argument(struct adc_message* cmd, const char prefix[2], const char* string);
 
-/**
- * Append a string as a named argument.
- * The string will automatcally be escaped, if you do not wish to escape th string use adc_msg_add_named_argument() instead.
- *
- * @arg prefix a 2 character argument prefix
- * @arg string must NOT be escaped
- * @return  0 if successful, or -1 if an error occured (out of memory).
- */
-extern int adc_msg_add_named_argument_string(struct adc_message* cmd, const char prefix[2], const char* string);
-
-/**
- * Append an integer as a named argument.
- */
-extern int adc_msg_add_named_argument_int(struct adc_message* cmd, const char prefix[2], int integer);
-extern int adc_msg_add_named_argument_uint64(struct adc_message* cmd, const char prefix[2], uint64_t num);
-
 /**
  * Convert a ADC command escaped string to a regular string.
  * @return string or NULL if out of memory

src/misc.c

@@ -46,13 +46,10 @@ char* strip_white_space(char* string)
 {
 	char* pos;
 	
-	if (!string)
-		return "";
-
 	while (string[0] && is_white_space(string[0])) string++;
 	
 	if (!*string)
-		return string;
+		return 0;
 	
 	/* Strip appending whitespace */
 	pos = &string[strlen(string)-1];
@@ -182,26 +179,26 @@ int file_read_lines(const char* file, void* data, file_line_handler_t handler)
 
 	memset(buf, 0, MAX_RECV_BUF);
 
-	LOG_TRACE("Opening file %s for line reading.", file);
+	hub_log(log_trace, "Opening file %s for line reading.", file);
 
 	fd = open(file, 0);
 	if (fd == -1)
 	{
-		LOG_ERROR("Unable to open file %s: %s", file, strerror(errno));
+		hub_log(log_error, "Unable to open file %s: %s", file, strerror(errno));
 		return -2;
 	}
 	
 	ret = read(fd, buf, MAX_RECV_BUF);
 	if (ret < 0)
 	{
-		LOG_ERROR("Unable to read from file %s: %s", file, strerror(errno));
+		hub_log(log_error, "Unable to read from file %s: %s", file, strerror(errno));
 		close(fd);
 		return -1;
 	}
 	else  if (ret == 0)
 	{
 		close(fd);
-		LOG_WARN("File is empty.");
+		hub_log(log_warning, "File is empty.");
 		return 0;
 	}
 	else
@@ -215,7 +212,7 @@ int file_read_lines(const char* file, void* data, file_line_handler_t handler)
 			pos[0] = '\0';
 			if (*start)
 			{
-				LOG_DUMP("Line: %s", start);
+				hub_log(log_dump, "Line: %s", start);
 				if (handler(start, line_count+1, data) < 0)
 					return -1;
 			}
@@ -226,7 +223,7 @@ int file_read_lines(const char* file, void* data, file_line_handler_t handler)
 		if (*start)
 		{
 			buf[strlen(start)] = 0;
-			LOG_DUMP("Line: %s", start);
+			hub_log(log_dump, "Line: %s", start);
 			if (handler(start, line_count+1, data) < 0)
 				return -1;
 		}
@@ -322,52 +319,4 @@ void* memmem(const void *haystack, size_t haystacklen, const void *needle, size_
 }
 #endif
 
-int split_string(const char* string, const char* split, struct linked_list* list, int allow_empty)
-{
-	char* tmp1, *tmp2;
-	int n = 0;
 
-	if (!string || !*string || !split || !*split || !list)
-		return -1;
-
-	for (;;)
-	{
-		tmp1 = strstr(string, split);
-		
-		if (tmp1) tmp2 = hub_strndup(string, tmp1 - string);
-		else      tmp2 = hub_strdup(string);
-
-		if (!tmp2)
-		{
-			list_clear(list, &hub_free);
-			return -1;
-		}
-
-		if (*tmp2 || allow_empty)
-		{
-			/* store in list */
-			list_append(list, tmp2);
-			n++;
-		}
-		else
-		{
-			/* ignore element */
-			hub_free(tmp2);
-		}
-
-		if (!tmp1) break; /* last element found */
-
-		string = tmp1;
-		string += strlen(split);
-	}
-
-	return n;
-}
-
-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);
-	return ts;
-}

src/misc.h

@@ -22,8 +22,6 @@
 
 typedef int (*file_line_handler_t)(char* line, int line_number, void* data);
 
-extern const char* get_timestamp(time_t time);
-
 extern int is_num(char c);
 extern int is_space(char c);
 extern int is_white_space(char c);
@@ -36,6 +34,7 @@ extern char* strip_white_space(char* string);
 
 extern int file_read_lines(const char* file, void* data, file_line_handler_t handler);
 
+
 extern const char* uhub_itoa(int val);
 extern const char* uhub_ulltoa(uint64_t val);
 
@@ -54,13 +53,6 @@ extern char* strndup(const char* string, size_t n);
 void* memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen);
 #endif
 
-/**
- * Split the string based on split, and place the different parts into list.
- * @return the number of items in the list after split, or -1 if an error occured.
- */
-struct linked_list;
-extern int split_string(const char* string, const char* split, struct linked_list* list, int allow_empty);
-
 
 #endif /* HAVE_UHUB_MISC_H */
 

src/netevent.c

@@ -0,0 +1,301 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2009, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+
+
+static int on_read(struct user* user)
+{
+	static char buf[MAX_RECV_BUF];
+	size_t offset;
+	size_t buflen;
+	ssize_t size;
+	int more = 1;
+	char* pos;
+
+	while (more)
+	{
+		offset = 0;
+		if (user->recv_buf)
+		{
+			memcpy(buf, user->recv_buf, user->recv_buf_offset);
+			offset = user->recv_buf_offset;
+		}
+		
+		size = net_recv(user->sd, &buf[offset], MAX_RECV_BUF - offset, 0);
+		if (size == -1)
+		{
+			if (net_error() != EWOULDBLOCK)
+				return quit_socket_error;
+			break;
+		}
+		else if (size == 0)
+		{
+			return quit_disconnected;
+		}
+		else
+		{
+			buflen = offset + size;
+			ssize_t handled = 0;
+			
+			while ((pos = memchr(&buf[handled], '\n', (buflen - handled))))
+			{
+				pos[0] = '\0';
+				size_t msglen = &pos[0] - &buf[handled];
+				
+				if (user_flag_get(user, flag_maxbuf))
+				{
+					user_flag_unset(user, flag_maxbuf);
+				}
+				else
+				{
+					if (msglen < user->hub->config->max_recv_buffer)
+					{
+						if (hub_handle_message(user, &buf[handled], msglen) == -1)
+						{
+							return quit_protocol_error;
+						}
+					}
+				}
+				handled += msglen;
+				handled++;
+			}
+			
+			if (handled == 0 && user_flag_get(user, flag_maxbuf))
+				handled = buflen;
+			
+			if (!more)
+				break;
+			
+			if (handled < buflen)
+			{
+				if ((buflen - handled) > user->hub->config->max_recv_buffer)
+				{
+					user_flag_set(user, flag_maxbuf);
+					hub_free(user->recv_buf);
+					user->recv_buf = 0;
+					user->recv_buf_offset = 0;
+				}
+				else
+				{
+					if (!user->recv_buf)
+						user->recv_buf = hub_malloc(user->hub->config->max_recv_buffer);
+				
+					if (user->recv_buf)
+					{
+						memcpy(user->recv_buf, &buf[handled], buflen - handled);
+						user->recv_buf_offset = buflen - handled;
+					}
+					else
+					{
+						return quit_memory_error;
+					}
+				}
+			}
+			else
+			{
+				if (user->recv_buf)
+				{
+					hub_free(user->recv_buf);
+					user->recv_buf = 0;
+					user->recv_buf_offset = 0;
+				}
+			}
+		}
+	}
+	return 0;
+}
+
+static int on_write(struct user* user)
+{
+	struct adc_message* msg;
+	int ret;
+	int length;
+	
+	msg = list_get_first(user->send_queue);
+	while (msg)
+	{
+		length = msg->length - user->send_queue_offset;
+		ret = net_send(user->sd, &msg->cache[user->send_queue_offset], length, UHUB_SEND_SIGNAL);
+	
+		if (ret == 0 || (ret == -1 && net_error() == EWOULDBLOCK))
+		{
+			return 0;
+		}
+		else if (ret > 0)
+		{
+			user->tm_last_write = time(NULL);
+			
+			if (ret == length)
+			{
+				user->send_queue_size -= ret;
+				user->send_queue_offset = 0;
+				list_remove(user->send_queue, msg);
+				
+				if (user_flag_get(user, flag_user_list) && (msg == user->info || user->send_queue_size == 0))
+				{
+				    user_flag_unset(user, flag_user_list);
+				}
+				
+				adc_msg_free(msg);
+				msg = 0;
+				
+				if (user->send_queue_size == 0)
+					break;
+			}
+			else
+			{
+				user->send_queue_size -= ret;
+				user->send_queue_offset += ret;
+				break;
+			}
+		}
+		else
+		{
+			return quit_socket_error;
+		}
+		msg = list_get_first(user->send_queue);
+	}
+	return 0;
+}
+
+
+void on_net_event(int fd, short ev, void *arg)
+{
+	struct user* user = (struct user*) arg;
+	int want_close = 0;
+	int want_write = 0;
+	
+	hub_log(log_debug, "on_net_event() : fd=%d, ev=%d, user=%s", fd, (int) ev, user);
+	
+	if (ev == EV_TIMEOUT)
+	{
+		
+		hub_log(log_debug, "EV_TIMEOUT");
+		
+		if (user_is_connecting(user))
+		{
+			want_close = quit_timeout;
+		}
+		else
+		{
+			hub_send_ping(user);
+		}
+	}
+	else
+	{
+		if (ev & EV_WRITE)
+		{
+			want_close = on_write(user);
+			want_write = (user->send_queue_size != 0);
+		}
+		
+		if (!want_close && ev & EV_READ)
+		{
+			want_close = on_read(user);
+		}
+	}
+		
+	if (want_close)
+	{
+		user_disconnect(user, want_close);
+		return;
+	}
+	
+	if (user_is_logged_in(user))
+	{
+		user_trigger_update(user, want_write, TIMEOUT_IDLE);
+	}
+	else if (user_is_connecting(user))
+	{
+		user_trigger_update(user, want_write, TIMEOUT_HANDSHAKE);
+	}
+}
+
+
+
+void net_on_accept(int server_fd, short ev, void *arg)
+{
+	struct hub_info* hub = (struct hub_info*) arg;
+	struct user* user = 0;
+	struct ip_addr_encap ipaddr;
+	const char* addr;
+	
+	for (;;)
+	{
+		int fd = net_accept(server_fd, &ipaddr);
+		if (fd == -1)
+		{
+			if (net_error() == EWOULDBLOCK)
+			{
+				break;
+			}
+			else
+			{
+				hub_log(log_error, "Accept error: %d %s", net_error(), strerror(net_error()));
+				break;
+			}
+		}
+		
+		addr = ip_convert_to_string(&ipaddr); 
+
+		/* FIXME: Should have a plugin log this */
+		hub_log(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))
+		{
+			hub_log(log_info, "Denied      [%s] (IP banned)", addr);
+			net_close(fd);
+			continue;
+		}
+		
+		user = user_create(hub, fd);
+		if (!user)
+		{
+			hub_log(log_error, "Unable to create user after socket accepted. Out of memory?");
+			net_close(fd);
+			break;
+		}
+		
+		/* Store IP address in user object */
+		memcpy(&user->ipaddr, &ipaddr, sizeof(ipaddr));
+
+		net_set_nonblocking(fd, 1);
+		net_set_nosigpipe(fd, 1);
+		user_trigger_init(user);
+	}
+}
+
+#ifdef ADC_UDP_OPERATION
+extern void net_on_packet(int fd, short ev, void *arg)
+{
+	static char buffer[1024] = {0,};
+	// struct hub_info* hub = (struct hub_info*) arg;
+	// struct user* user = 0;
+	ssize_t size;
+	struct sockaddr_storage from;
+	socklen_t fromlen;
+	
+	size = recvfrom(fd, buffer, 1024, 0, (struct sockaddr*) &from, &fromlen);
+	
+	// FIXME: A plugin should handle this!
+	hub_log(log_info, "Datagram    [%s] (%d bytes)", buffer, (int) size);
+}
+#endif

src/netevent.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2009, Jan Vidar Krey
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,15 +20,19 @@
 #ifndef HAVE_UHUB_NET_EVENT_H
 #define HAVE_UHUB_NET_EVENT_H
 
+struct user;
+
+extern void on_net_event(int fd, short ev, void *arg);
+
 /**
  * Network callback to accept incoming connections.
  */
-extern void net_on_accept(struct net_connection* con, int event, void *arg);
+extern void net_on_accept(int fd, short ev, void *arg);
-extern void net_event(struct net_connection* con, int event, void *arg);
-
-extern int handle_net_read(struct hub_user* user);
-extern int handle_net_write(struct hub_user* user);
 
+/**
+ *
+ */
+extern void net_update_trigger(struct user* user, int write, struct timeval timeout);
 
 #endif /* HAVE_UHUB_NET_EVENT_H */
 

src/network-epoll.c

@@ -0,0 +1,326 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007, 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 HAVE_EPOLL
+
+// #define DEBUG_EPOLL
+static struct epoll_event* events = 0;
+static int epfd = -1;
+
+#ifdef DEBUG_EPOLL
+static void dump_listeners()
+{
+	int i;
+	struct net_event_listener* listener;
+	
+	
+	hub_log(log_dump, "listeners: number=%d", num_connections);
+	
+	for (i = 0; i < num_connections; i++)
+	{
+		listener = &listeners[i];
+		
+		if (listener)
+		{
+			if (listener->fd != -1)
+			{
+				hub_log(log_dump, "epoll_dump_listeners: pos=%d/%d fd=%d, ptr=%p", i, num_connections, listeners->fd, listeners);
+			}
+			else
+			{
+				hub_log(log_dump, "epoll_dump_listeners: pos=%d/%d (unused)", i, num_connections);
+			}
+			
+			listener = 0;
+		}
+	}
+	
+	getc(stdin);
+	
+}
+
+#endif
+
+
+static void set_poll_events(struct epoll_event* handle, short trigger)
+{
+	memset(handle, 0, sizeof(struct epoll_event));
+	
+	if (trigger & evt_accept || trigger & evt_read || trigger & evt_close)
+		handle->events |= EPOLLIN;
+	
+	if (trigger & evt_write)
+		handle->events |= EPOLLOUT;
+
+	if (trigger & evt_urgent)
+		handle->events |= EPOLLPRI;
+
+#ifdef EPOLLRDHUP
+	if (triggers & evt_close)
+		handle->events |= EPOLLRDHUP;
+#endif
+}
+
+static short get_poll_events(struct epoll_event* handle)
+{
+	short trig = handle->events;
+	short evt  = 0;
+	
+	if (trig & EPOLLIN)
+		evt |= evt_read;
+		
+	if (trig & EPOLLPRI)
+		evt |= evt_urgent;
+	
+	if (trig & EPOLLOUT)
+		evt |= evt_write;
+	
+	if (trig & EPOLLHUP)
+		evt |= evt_close;
+
+	if (trig & EPOLLERR)
+		evt |= evt_error;
+
+#ifdef EPOLLRDHUP
+	if (trig & EPOLLRDHUP)
+		evt |= evt_close;
+#endif
+
+	return evt;
+}
+
+
+int net_initialize(int capacity)
+{
+	int i;
+	max_connections = capacity;
+	num_connections = 0;
+	epfd = epoll_create(max_connections);
+	if (epfd == -1)
+	{
+		hub_log(log_error, "net_initialize(): epoll_create failed");
+		return -1;
+	}
+	
+	events = hub_malloc_zero(sizeof(struct epoll_event) * max_connections);
+	if (!events)
+	{
+		hub_log(log_error, "net_initialize(): hub_malloc failed");
+		return -1;
+	}
+	
+	monitor_allocate((size_t) capacity);
+	
+
+	
+#ifdef DEBUG_EPOLL
+	dump_listeners();
+#endif
+	
+	net_stats_initialize();
+	
+	return 0;
+}
+
+
+int net_shutdown()
+{
+	hub_log(log_trace, "Shutting down network monitor");
+	if (epfd != -1)
+	{
+		close(epfd);
+	}
+	
+	hub_free(events);
+	hub_free(listeners);
+	return 0;
+}
+
+#ifdef DEBUG_EPOLL
+uint64_t get_time_difference_in_msec(struct timeval before, struct timeval after)
+{
+	uint64_t seconds = (after.tv_sec - before.tv_sec);
+	uint64_t out = seconds*1000;
+	if (seconds > 0)
+		out += ((after.tv_usec / 1000) + (1000 - (before.tv_usec / 1000)));
+	else
+		out += ((after.tv_usec - before.tv_usec) / 1000);
+	return out;
+}
+#endif
+
+int net_wait(int timeout_ms)
+{
+	int fired, n, max, ret;
+	struct net_event_listener* listener;
+	
+#ifdef DEBUG_EPOLL
+	struct timeval tm_before;
+	struct timeval tm_after;
+	gettimeofday(&tm_before, NULL);
+	dump_listeners();
+#endif
+	
+	fired = epoll_wait(epfd, events, num_connections, timeout_ms);
+	if (fired == -1) {
+		if (errno != EINTR)
+		{
+			hub_log(log_error, "net_wait(): epoll_wait failed");
+		}
+		return -1;
+	}
+	
+	for (n = 0; n < fired; n++)
+	{
+		listener = (struct net_event_listener*) events[n].data.ptr;
+		listener->revents = get_poll_events(&events[n]);
+		hub_log(log_dump, "net_wait(): epoll event detected (fd=%d, evt=%d, ptr=%p)", listener->fd, listener->revents, listener);
+	}
+	
+	max = num_connections;
+	
+	for (n = 0; n < max; n++)
+	{
+		listener = &listeners[n];
+		if (listener && listener->fd != -1 && listener->revents)
+		{
+			hub_log(log_dump, "net_wait(): epoll trigger call  (fd=%d, evt=%d, ptr=%p)", listener->fd, listener->revents, listener);
+			ret = listener->handler(listener);
+			listener->revents = 0;
+		}
+#ifdef DEBUG_EPOLL
+		else
+		{
+			if (listener)
+				hub_log(log_dump, "net_wait(): epoll trigger ignore (fd=%d, evt=%d, ptr=%p)", listener->fd, listener->revents, listener);
+		}
+#endif
+	}
+
+#ifdef DEBUG_EPOLL
+	gettimeofday(&tm_after, NULL);
+	size_t diff = (size_t) get_time_difference_in_msec(tm_before, tm_after);
+	dump_listeners();
+	hub_log(log_debug, "net_wait(): time=%dms, triggered=%d", diff, fired);
+#endif
+	
+	return 0;
+}
+
+
+int net_add(int fd, short events, void* data, net_event_handler_t handler)
+{
+	struct epoll_event ev;
+	struct net_event_listener* listener = monitor_get_free_listener();
+	
+	hub_log(log_trace, "net_add(): adding socket (fd=%d, pos=%d)", fd, pos);
+	
+	if (!listener)
+	{
+		hub_log(log_error, "net_add(): unable to poll more sockets");
+		return -1;
+	}
+	
+	net_event_listener_set(listener, fd, events, data, handler);
+	
+	set_poll_events(&ev, events);
+	ev.data.ptr = listener;
+	
+	if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) < 0)
+	{
+		hub_log(log_error, "net_add(): epoll_ctl error while adding socket (fd=%d)", fd);
+		net_event_listener_clear(listener);
+		return -1;
+	}
+	
+	num_connections++;
+	
+#ifdef DEBUG_EPOLL
+	dump_listeners();
+#endif
+	return 0;
+}
+
+int net_modify(int fd, short events)
+{
+	struct epoll_event ev;
+	struct net_event_listener* listener = monitor_get_listener(fd);
+	hub_log(log_trace, "net_modify(): modifying socket events (fd=%d)", fd);
+	
+	if (!listener)
+	{
+		hub_log(log_error, "net_modify(): unable to find socket.");
+		return -1;
+	}
+	
+	listener->events = events;
+	set_poll_events(&ev, events);
+	ev.data.ptr = listener;
+	
+	if (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) < 0)
+	{
+		hub_log(log_error, "net_add(): epoll_ctl error while modifying socket (fd=%d)", fd);
+		return -1;
+	}
+	
+#ifdef DEBUG_EPOLL
+	dump_listeners();
+#endif
+
+	return 0;
+}
+
+
+int net_remove(int fd)
+{
+	struct epoll_event ev;
+	struct net_event_listener* listener = monitor_get_listener(fd);
+	
+	hub_log(log_trace, "net_remove(): removing socket (fd=%d, pos=%d)", fd, pos);
+	
+	if (!listener)
+	{
+		/* The socket is not being monitored */
+		hub_log(log_error, "net_remove(): unable to remove socket (fd=%d)", fd);
+		return -1;
+	}
+	
+	net_event_listener_clear(listener);
+
+	if (epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev) < 0)
+	{
+		hub_log(log_error, "net_remove(): epoll_ctl error while removing socket (fd=%d)", fd);
+		return -1;
+	}
+	num_connections--;
+	
+#ifdef DEBUG_EPOLL
+	dump_listeners();
+#endif
+	
+	return 0;
+}
+
+
+#endif /* HAVE_EPOLL */
+
+
+

src/network-kqueue.c

@@ -0,0 +1,290 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2009, 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 HAVE_KQUEUE
+
+static struct kevent* events = 0;
+static struct kevent* change = 0;
+static int kfd = -1;
+
+
+static void set_poll_events(struct kevent* handle, short trigger)
+{
+	if (!handle) {
+		hub_log(log_error, "OOOPS!!");
+		return;
+	}
+
+	memset(handle, 0, sizeof(struct kevent));
+	
+	if (trigger & evt_accept || trigger & evt_read || trigger & evt_close)
+		handle->filter |= EVFILT_READ;
+	
+	if (trigger & evt_write /* || trigger & evt_accept*/)
+		handle->filter |= EVFILT_WRITE;
+}
+
+static short get_poll_events(struct kevent* handle)
+{
+	short trig = handle->flags;
+	short evt  = 0;
+	
+	if (trig & EVFILT_READ)
+		evt |= evt_read;
+		
+	if (trig & EVFILT_WRITE)
+		evt |= evt_write;
+	
+	if (trig & EV_EOF)
+	{
+		evt |= evt_close;
+		
+		if (handle->fflags)
+			evt |= evt_error;
+	}
+	
+	if (handle->filter == -1)
+	{
+		
+		evt |= evt_error;
+	}
+	
+	if (handle->data)
+	{
+		evt |= evt_accept;
+	}
+	
+	if (evt)
+	{
+		hub_log(log_error, "Evt: fd=%d, filter=%d, flags=%d, fflags=%d, data=%d evt=%#x", handle->ident, handle->filter, handle->flags, handle->fflags, (int) handle->data, evt);
+		
+		
+	}
+	
+	
+	return evt;
+}
+
+int net_initialize(int capacity)
+{
+	int i;
+	max_connections = capacity;
+	num_connections = 0;
+	kfd = kqueue();
+	if (kfd == -1)
+	{
+		hub_log(log_error, "net_initialize(): kqueue failed");
+		return -1;
+	}
+	
+	events = (void*) hub_malloc_zero(sizeof(struct kevent) * max_connections);
+	if (!events)
+	{
+		hub_log(log_error, "net_initialize(): hub_malloc failed");
+		return -1;
+	}
+	
+	change = (void*) hub_malloc_zero(sizeof(struct kevent) * max_connections);
+	if (!events)
+	{
+		hub_log(log_error, "net_initialize(): hub_malloc failed");
+		hub_free(events);
+		return -1;
+	}
+	
+	
+	listeners = (void*) hub_malloc_zero(sizeof(struct net_event_listener) * max_connections);
+	if (!listeners)
+	{
+		hub_log(log_error, "net_initialize(): hub_malloc failed");
+		hub_free(change);
+		hub_free(events);
+		return -1;
+	}
+	
+	for (i = 0; i < max_connections; i++)
+	{
+		listeners[i].fd = -1;
+	}
+	
+	net_stats_initialize();
+	
+	return 0;
+}
+
+
+int net_shutdown()
+{
+	if (kfd != -1) {
+		return close(kfd);
+	}
+	
+	hub_free(events);
+	hub_free(change);
+	hub_free(listeners);
+	return 0;
+}
+
+
+int net_wait(int timeout_ms)
+{
+	int fired, n, max, ret;
+	struct net_event_listener* listener;
+	struct timespec timeout = { (timeout_ms / 1000), (timeout_ms % 1000) * 1000 };
+	
+	fired = kevent(kfd, events, num_connections, change, num_connections, &timeout);
+	if (fired == -1) {
+		if (errno != EINTR)
+		{
+			hub_log(log_error, "net_wait(): kevent failed");
+		}
+		return -1;
+	}
+	
+	for (n = 0; n < fired; n++)
+	{
+		listener = (struct net_event_listener*) events[n].udata;
+		if (listener)
+		{
+			listener->revents = get_poll_events(&events[n]);
+			hub_log(log_dump, "net_wait(): kqueue event detected (fd=%d, evt=%d, ptr=%p)", listener->fd, listener->revents, listener);
+		}
+	}
+	
+	max = num_connections;
+	for (n = 0; n < max; n++)
+	{
+		listener = &listeners[n];
+		if (listener && listener->fd != -1 && listener->revents != 0)
+		{
+			hub_log(log_dump, "net_wait(): kqueue trigger call  (fd=%d, evt=%d, ptr=%p)", listener->fd, listener->revents, listener);
+			ret = listener->handler(listener);
+			listener->revents = 0;
+		}
+	}
+	
+	return 0;
+}
+
+
+int net_add(int fd, short events_, void* data, net_event_handler_t handler)
+{
+	struct kevent* event;
+	struct net_event_listener* listener = monitor_get_listener(fd);
+	
+	hub_log(log_trace, "net_add(): adding socket (fd=%d)", fd);
+	
+	if (listener)
+	{
+		/* Already added! */
+		return -1;
+	}
+	
+	listener = monitor_get_free_listener();
+	if (!listener)
+	{
+		hub_log(log_error, "net_add(): unable to poll more sockets");
+		return -1;
+	}
+	
+	net_event_listener_set(listener, fd, events_, data, handler);
+	
+	event = &events[pos];
+	set_poll_events(event, events_);
+	event->ident = fd;
+	
+	event->flags |= EV_ADD;
+	event->flags |= EV_ONESHOT;
+	
+#ifdef __APPLE__
+	 event->flags |= EV_ENABLE;
+#endif
+	event->udata = listener;
+
+	num_connections++;
+	return 0;
+}
+
+int net_modify(int fd, short events_)
+{
+	struct kevent* event;
+	struct net_event_listener* listener = monitor_get_listener(fd);
+	
+	hub_log(log_trace, "net_modify(): modifying socket (fd=%d)", fd);
+	
+	if (!listener)
+	{
+		/* The socket is not being monitored */
+		hub_log(log_error, "net_modify(): unable to find socket (fd=%d)", fd);
+		return -1;
+	}
+	
+	event = &events[pos];
+	// set_poll_events(event, events_);
+	
+	event->ident = fd;
+	event->flags |= EV_ADD;
+	event->flags |= EV_ONESHOT;
+#ifdef __APPLE__
+	event->flags |= EV_ENABLE;
+#endif
+	return 0;
+}
+
+
+int net_remove(int fd)
+{
+	struct kevent* event;
+	struct net_event_listener* listener = monitor_get_listener(fd);
+	
+	hub_log(log_trace, "net_remove(): removing socket (fd=%d)", fd);
+	
+	if (!listener)
+	{
+		/* The socket is not being monitored */
+		hub_log(log_error, "net_remove(): unable to remove socket (fd=%d)", fd);
+		return -1;
+	}
+
+	net_event_listener_clear(listener);
+	
+	event = &events[pos];
+	event->ident = fd;
+	event->filter = 0;
+	event->flags = EV_DELETE;
+
+#ifdef __APPLE__
+	event->flasg |= EV_DISABLE;
+#endif
+
+	event->fflags = 0;
+	event->data = 0;
+	event->udata = 0;
+
+	num_connections--;
+	return 0;
+}
+
+
+#endif /* HAVE_KQUEUE */
+
+
+

src/network.c

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2009, 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,7 +21,6 @@
 
 static int is_ipv6_supported = -1; /* -1 = CHECK, 0 = NO, 1 = YES */
 static int net_initialized = 0;
-
 static struct net_statistics stats;
 static struct net_statistics stats_total;
 
@@ -36,25 +35,21 @@ int net_initialize()
 {
 	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.");
+			hub_log(log_error, "Unable to initialize winsock.");
 			return -1;
 		}
 #endif /* WINSOCK */
 
-		net_backend_initialize();
+		hub_log(log_trace, "Initializing network monitor.");
 		net_stats_initialize();
 
 #ifdef SSL_SUPPORT
-		LOG_TRACE("Initializing OpenSSL...");
+		/* FIXME: Initialize OpenSSL here. */
-		SSL_library_init();
-		SSL_load_error_strings();
-		OpenSSL_add_all_algorithms();
 #endif /*  SSL_SUPPORT */
 
 		net_initialized = 1;
@@ -63,35 +58,12 @@ int net_initialize()
 	return -1;
 }
 
-size_t net_get_max_sockets()
-{
-#ifdef HAVE_GETRLIMIT
-	struct rlimit limits;
-	if (getrlimit(RLIMIT_NOFILE, &limits) == 0)
-	{
-		return limits.rlim_max;
-	}
-	LOG_ERROR("getrlimit() failed");
-	return 1024;
-#else
-#ifdef WIN32
-	LOG_WARN("Windows system, limited to 4096 connections.");
-	return 4096;
-#else
-	LOG_WARN("System does not have getrlimit(): constrained to 1024 sockets");
-	return 1024;
-#endif
-#endif /* HAVE_GETRLIMIT */
-}
 
-
+int net_shutdown()
-int net_destroy()
 {
 	if (net_initialized)
 	{
-		LOG_TRACE("Shutting down network monitor");
+		hub_log(log_trace, "Shutting down network monitor");
-
-		net_backend_shutdown();
 
 #ifdef SSL_SUPPORT
 		/* FIXME: Shutdown OpenSSL here. */
@@ -106,18 +78,6 @@ int net_destroy()
 	return -1;
 }
 
-#ifdef USE_LIBEVENT
-struct event_base* net_get_evbase()
-{
-	return net_evbase;
-}
-#endif
-
-static void net_error_out(int fd, const char* func)
-{
-	int err = net_error();
-	LOG_ERROR("%s, fd=%d: %s (%d)", func, fd, net_error_string(err), err);
-}
 
 int net_error()
 {
@@ -143,81 +103,60 @@ const char* net_error_string(int code)
 
 static int net_setsockopt(int fd, int level, int opt, const void* optval, socklen_t optlen)
 {
-	int ret = -1;
 #ifdef WINSOCK
-	ret = setsockopt(fd, level, opt, (const char*) optval, optlen);
+	return setsockopt(fd, level, opt, (const char*) optval, optlen);
 #else
-	ret = setsockopt(fd, level, opt, optval, optlen);
+	return setsockopt(fd, level, opt, optval, optlen);
 #endif
-
-	if (ret == -1)
-	{
-		net_error_out(fd, "net_setsockopt");
-	}
-
-	return ret;
-}
-
-static int net_getsockopt(int fd, int level, int opt, void* optval, socklen_t* optlen)
-{
-	int ret = -1;
-#ifdef WINSOCK
-	ret = getsockopt(fd, level, opt, (char*) optval, optlen);
-#else
-	ret = getsockopt(fd, level, opt, optval, optlen);
-#endif
-
-	if (ret == -1)
-	{
-		net_error_out(fd, "net_getsockopt");
-	}
-
-	return ret;
 }
 
 
 int net_set_nonblocking(int fd, int toggle)
 {
-	int ret = -1;
+	int ret;
+
+#ifdef NETAPI_DUMP
+	hub_log(log_dump, "net_set_nonblocking(): fd=%d", fd);
+#endif
+
 #ifdef WINSOCK
 	u_long on = toggle ? 1 : 0;
 	ret = ioctlsocket(fd, FIONBIO, &on);
-#else
-#ifdef __sun__
-	int flags = fcntl(fd, F_GETFL, 0);
-	if (flags != -1)
-	{
-		if (toggle) flags |= O_NONBLOCK;
-		else        flags &= ~O_NONBLOCK;
-		ret = fcntl(fd, F_SETFL, flags);
-	}
 #else
 	ret = ioctl(fd, FIONBIO, &toggle);
-#endif
 #endif
 	if (ret == -1)
 	{
-		net_error_out(fd, "net_set_nonblocking");
+		hub_log(log_error, "net_set_nonblocking(): ioctl failed (fd=%d): %s", fd, net_error_string(net_error()));
+		return -1;
 	}
-	return ret;
+	return 0;
 }
 
+
 /* NOTE: Possibly only supported on BSD and OSX? */
 int net_set_nosigpipe(int fd, int toggle)
 {
-	int ret = -1;
 #ifdef SO_NOSIGPIPE
+	int ret;
+#ifdef NETAPI_DUMP
+	hub_log(log_dump, "net_set_nosigpipe(): fd=%d", fd);
+#endif
 	ret = net_setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &toggle, sizeof(toggle));
 	if (ret == -1)
 	{
-		net_error_out(fd, "net_set_nosigpipe");
+		hub_log(log_error, "net_set_linger(): setsockopt failed (fd=%d): %s", fd, net_error_string(net_error()));
+		return -1;
 	}
 #endif
-	return ret;
+	return 0;
 }
 
 int net_set_close_on_exec(int fd, int toggle)
 {
+#ifdef NETAPI_DUMP
+	hub_log(log_dump, "net_set_close_on_exec(): fd=%d", fd);
+#endif
 #ifdef WINSOCK
 	return -1; /* FIXME: How is this done on Windows? */
 #else
@@ -225,63 +164,54 @@ int net_set_close_on_exec(int fd, int toggle)
 #endif
 }
 
+
 int net_set_linger(int fd, int toggle)
 {
 	int ret;
+#ifdef NETAPI_DUMP
+	hub_log(log_dump, "net_set_linger(): fd=%d", fd);
+#endif
 	ret = net_setsockopt(fd, SOL_SOCKET, SO_LINGER, &toggle, sizeof(toggle));
 	if (ret == -1)
 	{
-		net_error_out(fd, "net_set_linger");
+		hub_log(log_error, "net_set_linger(): setsockopt failed (fd=%d): %s", fd, net_error_string(net_error()));
+		return -1;
 	}
-	return ret;
+	return 0;
 }
 
+
 int net_set_keepalive(int fd, int toggle)
 {
 	int ret;
+#ifdef NETAPI_DUMP
+	hub_log(log_dump, "net_set_keepalive(): fd=%d", fd);
+#endif
 	ret = net_setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &toggle, sizeof(toggle));
 	if (ret == -1)
 	{
-		net_error_out(fd, "net_set_keepalive");
+		hub_log(log_error, "net_set_keepalive(): setsockopt failed (fd=%d): %s", fd, net_error_string(net_error()));
+		return -1;
 	}
-	return ret;
+	return 0;
 }
 
 
 int net_set_reuseaddress(int fd, int toggle)
 {
 	int ret;
+#ifdef NETAPI_DUMP
+	hub_log(log_dump, "net_set_reuseaddress(): fd=%d", fd);
+#endif
 	ret = net_setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &toggle, sizeof(toggle));
 	if (ret == -1)
 	{
-		net_error_out(fd, "net_set_reuseaddress");
+		hub_log(log_error, "net_set_reuseaddress(): setsockopt failed (fd=%d): %s", fd, net_error_string(net_error()));
+		return -1;
 	}
-	return ret;
+	return 0;
 }
 
-int net_set_sendbuf_size(int fd, size_t size)
-{
-	return net_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
-}
-
-int net_get_sendbuf_size(int fd, size_t* size)
-{
-	socklen_t sz = sizeof(*size);
-	return net_getsockopt(fd, SOL_SOCKET, SO_SNDBUF, size, &sz);
-}
-
-int net_set_recvbuf_size(int fd, size_t size)
-{
-	return net_setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
-}
-
-int net_get_recvbuf_size(int fd, size_t* size)
-{
-	socklen_t sz = sizeof(*size);
-	return net_getsockopt(fd, SOL_SOCKET, SO_RCVBUF, size, &sz);
-}
-
-
 
 int net_close(int fd)
 {
@@ -297,7 +227,7 @@ int net_close(int fd)
 	}
 	else
 	{
-		if (ret != -1)
+		if (fd != -1)
 		{
 			net_stats_add_error();
 		}
@@ -305,32 +235,6 @@ int net_close(int fd)
 	return ret;
 }
 
-int net_shutdown_r(int fd)
-{
-#ifdef WINSOCK
-	return shutdown(fd, SD_RECEIVE);
-#else
-	return shutdown(fd, SHUT_RD);
-#endif
-}
-
-int net_shutdown_w(int fd)
-{
-#ifdef WINSOCK
-	return shutdown(fd, SD_SEND);
-#else
-	return shutdown(fd, SHUT_WR);
-#endif
-}
-
-int net_shutdown_rw(int fd)
-{
-#ifdef WINSOCK
-	return shutdown(fd, SD_BOTH);
-#else
-	return shutdown(fd, SHUT_RDWR);
-#endif
-}
 
 int net_accept(int fd, struct ip_addr_encap* ipaddr)
 {
@@ -364,7 +268,7 @@ int net_accept(int fd, struct ip_addr_encap* ipaddr)
 			case EWOULDBLOCK:
 				break;
 			default:
-				net_error_out(fd, "net_accept");
+				hub_log(log_error, "net_accept(): accept failed (fd=%d, errno=%d, msg=%s)", fd, net_error(), net_error_string(net_error()));
 				net_stats_add_error();
 				return -1;
 		}
@@ -379,18 +283,7 @@ int net_accept(int fd, struct ip_addr_encap* ipaddr)
 			ipaddr->af = addr4->sin_family;
 			if (ipaddr->af == AF_INET6)
 			{
-				char address[INET6_ADDRSTRLEN+1] = { 0, };
+				memcpy(&ipaddr->internal_ip_data.in6, &addr6->sin6_addr, sizeof(struct in6_addr));	
-				net_address_to_string(AF_INET6, (void*) &addr6->sin6_addr, address, INET6_ADDRSTRLEN+1);
-				if (!strncmp(address, "::ffff:", 7))
-				{
-					/* Hack to convert IPv6 mapped IPv4 addresses to true IPv4 addresses */
-					net_string_to_address(AF_INET, address + 7, (void*) &ipaddr->internal_ip_data.in);
-					ipaddr->af = AF_INET;
-				}
-				else
-				{
-					memcpy(&ipaddr->internal_ip_data.in6, &addr6->sin6_addr, sizeof(struct in6_addr));
-				}
 			}
 			else
 			{
@@ -410,7 +303,7 @@ int net_connect(int fd, const struct sockaddr *serv_addr, socklen_t addrlen)
 	{
 		if (net_error() != EINPROGRESS)
 		{
-			net_error_out(fd, "net_connect");
+			hub_log(log_error, "net_connect(): connect failed (fd=%d, errno=%d, msg=%s)", fd, net_error(), net_error_string(net_error()));
 			net_stats_add_error();
 		}
 	}
@@ -432,12 +325,13 @@ int net_is_ipv6_supported()
 			if (net_error() == EAFNOSUPPORT)
 #endif
 			{
-				LOG_TRACE("net_is_ipv6_supported(): IPv6 is not supported on this system.");
+				hub_log(log_trace, "net_is_ipv6_supported(): IPv6 is not supported on this system.");
 				is_ipv6_supported = 0;
 				return 0;
 			}
 			
-			net_error_out(ret, "net_is_ipv6_supported");
+			hub_log(log_error, "net_is_ipv6_supported(): Unknown error (errno=%d, msg=%s)", net_error(), net_error_string(net_error()));
+
 		}
 		else
 		{
@@ -445,7 +339,7 @@ int net_is_ipv6_supported()
 			int off = 0;
 			if (net_setsockopt(ret, IPPROTO_IPV6, SOCK_DUAL_STACK_OPT, (char*) &off, sizeof(off)) < 0)
 			{
-				LOG_ERROR("net_socket_create(): Dual stack IPv6/IPv4 is not supported.");
+				hub_log(log_error, "net_socket_create(): Dual stack IPv6/IPv4 is not supported.");
 				is_ipv6_supported = 0;
 			}
 			else
@@ -467,8 +361,7 @@ int net_socket_create(int af, int type, int protocol)
 	int sd = socket(af, type, protocol);
 	if (sd == -1)
 	{
-		net_error_out(sd, "net_socket_create");
+		hub_log(log_error, "net_socket_create(): socket failed (errno=%d, msg=%s)", net_error(), net_error_string(net_error()));
-		return -1;
 	}
 
 #ifdef SOCK_DUAL_STACK_OPT
@@ -478,7 +371,7 @@ int net_socket_create(int af, int type, int protocol)
 		int off = 0;
 		if (net_setsockopt(sd, IPPROTO_IPV6, SOCK_DUAL_STACK_OPT, (char*) &off, sizeof(off)) < 0)
 		{
-			LOG_ERROR("net_socket_create():  Cannot set socket to dual stack mode IPv6/IPv4 (%d - %s).", net_error(), net_error_string(net_error()));
+			hub_log(log_error, "net_socket_create():  Cannot set socket to dual stack mode IPv6/IPv4 (%d - %s).", net_error(), net_error_string(net_error()));
 		}
 	}
 #endif
@@ -602,18 +495,19 @@ const char* net_get_peer_address(int fd)
 			{
 				return &address[7];
 			}
+			hub_log(log_trace, "net_get_peer_address(): address=%s", address);
 			return address;
 		}
 		else
 		{
 			net_address_to_string(af, (void*) &name4->sin_addr, address, INET6_ADDRSTRLEN);
+			hub_log(log_trace, "net_get_peer_address(): address=%s", address);
 			return address;
 		}
 	}
 	else
 	{
-		net_error_out(fd, "net_get_peer_address");
+		hub_log(log_error, "net_get_peer_address(): getsockname failed (fd=%d, errno=%d, msg=%s)", fd, net_error(), net_error_string(net_error()));
-		net_stats_add_error();
 	}
 
 	return "0.0.0.0";
@@ -631,7 +525,7 @@ ssize_t net_recv(int fd, void* buf, size_t len, int flags)
 	{
 		if (net_error() != EWOULDBLOCK)
 		{
-			/* net_error_out(fd, "net_recv"); */
+			hub_log(log_debug, "net_recv(): failed (fd=%d, errno=%d, msg=%s)", fd, net_error(), net_error_string(net_error()));
 			net_stats_add_error();
 		}
 	}
@@ -639,7 +533,7 @@ ssize_t net_recv(int fd, void* buf, size_t len, int flags)
 }
 
 
-ssize_t net_send(int fd, const void* buf, size_t len, int flags)
+ssize_t net_send(int fd, void* buf, size_t len, int flags)
 {
 	ssize_t ret = send(fd, buf, len, flags);
 	if (ret >= 0)
@@ -650,7 +544,7 @@ ssize_t net_send(int fd, const void* buf, size_t len, int flags)
 	{
 		if (net_error() != EWOULDBLOCK)
 		{
-			/* net_error_out(fd, "net_send"); */
+			hub_log(log_debug, "net_send(): failed (fd=%d, errno=%d, msg=%s)", fd, net_error(), net_error_string(net_error()));
 			net_stats_add_error();
 		}
 	}
@@ -663,7 +557,7 @@ int net_bind(int fd, const struct sockaddr *my_addr, socklen_t addrlen)
 	int ret = bind(fd, my_addr, addrlen);
 	if (ret == -1)
 	{
-		net_error_out(fd, "net_bind");
+		hub_log(log_error, "net_bind(): failed (fd=%d, errno=%d, msg=%s)", fd, net_error(), net_error_string(net_error()));
 		net_stats_add_error();
 	}
 	return ret;
@@ -675,7 +569,7 @@ int net_listen(int fd, int backlog)
 	int ret = listen(fd, backlog);
 	if (ret == -1)
 	{
-		net_error_out(fd, "net_listen");
+		hub_log(log_error, "net_listen(): failed (fd=%d, errno=%d, msg=%s)", fd, net_error(), net_error_string(net_error()));
 		net_stats_add_error();
 	}
 	return ret;
@@ -691,12 +585,14 @@ void net_stats_initialize()
 	stats.timestamp = time(NULL);
 }
 
+
 void net_stats_get(struct net_statistics** intermediate, struct net_statistics** total)
 {
 	*intermediate = &stats;
 	*total = &stats_total;
 }
 
+
 void net_stats_reset()
 {
 	stats_total.tx += stats.tx;
@@ -709,31 +605,37 @@ void net_stats_reset()
 	stats.timestamp = time(NULL);
 }
 
+
 int net_stats_timeout()
 {
 	return (difftime(time(NULL), stats.timestamp) > TIMEOUT_STATS) ? 1 : 0;
 }
 
+
 void net_stats_add_tx(size_t bytes)
 {
 	stats.tx += bytes;
 }
 
+
 void net_stats_add_rx(size_t bytes)
 {
 	stats.rx += bytes;
 }
 
+
 void net_stats_add_accept()
 {
 	stats.accept++;
 }
 
+
 void net_stats_add_error()
 {
 	stats.errors++;
 }
 
+
 void net_stats_add_close()
 {
 	stats.closed++;

src/network.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2009, 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
@@ -30,8 +30,6 @@ struct net_statistics
 	size_t errors;
 };
 
-struct net_socket_t;
-
 /**
  * Initialize the socket monitor subsystem.
  * On some operating systems this will also involve loading the TCP/IP stack
@@ -49,9 +47,7 @@ extern int net_initialize();
  *
  * @return -1 on error, 0 on success
  */
-extern int net_destroy();
+extern int net_shutdown();
-
-extern struct event_base* net_get_evbase();
 
 /**
  * @return the number of sockets currrently being monitored.
@@ -80,20 +76,11 @@ extern const char* net_error_string(int code);
  */
 extern int net_socket_create(int af, int type, int protocol);
 
-/**
- * Returns the maximum number of file/socket descriptors.
- */
-extern size_t net_get_max_sockets();
-
 /**
  * A wrapper for the close() function call.
  */
 extern int net_close(int fd);
 
-extern int net_shutdown_r(int fd);
-extern int net_shutdown_w(int fd);
-extern int net_shutdown_rw(int fd);
-
 /**
  * A wrapper for the accept() function call.
  * @param fd socket descriptor
@@ -164,38 +151,6 @@ extern int net_set_linger(int fd, int toggle);
  */
 extern int net_set_reuseaddress(int fd, int toggle);
 
-/**
- * Set the send buffer size for the socket.
- * @param fd socket descriptor
- * @param size size to set
- * @return -1 on error, 0 on success.
- */
-extern int net_set_sendbuf_size(int fd, size_t size);
-
-/**
- * Get the send buffer size for the socket.
- * @param fd socket descriptor
- * @param[out] size existing size, cannot be NULL.
- * @return -1 on error, 0 on success.
- */
-extern int net_get_sendbuf_size(int fd, size_t* size);
-
-/**
- * Set the receive buffer size for the socket.
- * @param fd socket descriptor
- * @param size size to set
- * @return -1 on error, 0 on success.
- */
-extern int net_set_recvbuf_size(int fd, size_t size);
-
-/**
- * Get the receive buffer size for the socket.
- * @param fd socket descriptor
- * @param[out] size existing size, cannot be NULL.
- * @return -1 on error, 0 on success.
- */
-extern int net_get_recvbuf_size(int fd, size_t* size);
-
 /**
  * A wrapper for the recv() function call.
  */
@@ -204,7 +159,7 @@ extern ssize_t net_recv(int fd, void* buf, size_t len, int flags);
 /**
  * A wrapper for the send() function call.
  */
-extern ssize_t net_send(int fd, const void* buf, size_t len, int flags);
+extern ssize_t net_send(int fd, void* buf, size_t len, int flags);
 
 /**
  * This tries to create a AF_INET6 socket.
@@ -255,6 +210,11 @@ extern void net_stats_get(struct net_statistics** intermediate, struct net_stati
 
 #if defined(WINSOCK) && !defined(__CYGWIN__)
 
+// #define EINTR           WSAEINTR
+// #define EACCES          WSAEACCES
+// #define EFAULT          WSAEFAULT
+// #define EINVAL          WSAEINVAL
+// #define EMFILE          WSAEMFILE
 #define EWOULDBLOCK     WSAEWOULDBLOCK
 #define EINPROGRESS     WSAEINPROGRESS
 #define EALREADY        WSAEALREADY
@@ -283,8 +243,10 @@ extern void net_stats_get(struct net_statistics** intermediate, struct net_stati
 #define ETIMEDOUT       WSAETIMEDOUT
 #define ECONNREFUSED    WSAECONNREFUSED
 #define ELOOP           WSAELOOP
+// #define ENAMETOOLONG    WSAENAMETOOLONG
 #define EHOSTDOWN       WSAEHOSTDOWN
 #define EHOSTUNREACH    WSAEHOSTUNREACH
+// #define ENOTEMPTY       WSAENOTEMPTY
 #define EPROCLIM        WSAEPROCLIM
 #define EUSERS          WSAEUSERS
 #define EDQUOT          WSAEDQUOT

src/network/backend.h

@@ -1,39 +0,0 @@
-/*
- * 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_NETWORK_BACKEND_H
-#define HAVE_UHUB_NETWORK_BACKEND_H
-
-/**
- * Initialize the network backend.
- * Returns 1 on success, or 0 on failure.
- */
-extern int net_backend_initialize();
-
-/**
- * Shutdown the network connection backend.
- */
-extern void net_backend_shutdown();
-
-/**
- * Process the network backend.
- */
-extern int net_backend_process();
-
-#endif /* HAVE_UHUB_NETWORK_BACKEND_H */

src/network/common.h

@@ -1,37 +0,0 @@
-
-#define NET_WANT_READ             NET_EVENT_READ
-#define NET_WANT_WRITE            NET_EVENT_WRITE
-#define NET_WANT_ACCEPT           0x0008
-#define NET_WANT_SSL_READ         0x0010
-#define NET_WANT_SSL_WRITE        0x0020
-#define NET_WANT_SSL_ACCEPT       0x0040
-#define NET_WANT_SSL_CONNECT      0x0080
-#define NET_WANT_SSL_X509_LOOKUP  0x0100
-
-#define NET_PROCESSING_BUSY       0x8000
-#define NET_CLEANUP               0x4000
-#define NET_INITIALIZED           0x2000
-#define NET_TIMER_ENABLED         0x1000
-
-/* FIXME: Meant for debugging */
-#define NET_EVENT_SET             0x0800
-
-#define NET_CON_STRUCT_BASIC \
-	int                  sd;        /** socket descriptor */ \
-	uint32_t             flags;     /** Connection flags */ \
-	void*                ptr;       /** data pointer */ \
-	net_connection_cb    callback;  /** Callback function */ \
-
-#define NET_CON_STRUCT_SSL \
-	SSL*                 ssl;       /** SSL handle */ \
-	size_t               write_len; /** Length of last SSL_write(), only used if flags is NET_WANT_SSL_READ. */ \
-
-#ifdef USE_SSL
-#define NET_CON_STRUCT_COMMON \
-	NET_CON_STRUCT_BASIC \
-	NET_CON_STRUCT_SSL
-#else
-#define NET_CON_STRUCT_COMMON \
-	NET_CON_STRUCT_BASIC
-#endif
-

src/network/connection.c

@@ -1,210 +0,0 @@
-/*
- * 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"
-#include "network/common.h"
-
-#ifdef SSL_SUPPORT
-static int handle_openssl_error(struct net_connection* con, int ret)
-{
-	uhub_assert(con);
-
-	int error = SSL_get_error(net_con_get_ssl(con), ret);
-	switch (error)
-	{
-		case SSL_ERROR_ZERO_RETURN:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_ZERO_RETURN", ret, error);
-			return -1;
-
-		case SSL_ERROR_WANT_READ:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_WANT_READ", ret, error);
-			net_con_update(con, NET_EVENT_READ | NET_WANT_SSL_READ);
-			return 0;
-
-		case SSL_ERROR_WANT_WRITE:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_WANT_WRITE", ret, error);
-			net_con_update(con, NET_EVENT_READ | NET_EVENT_WRITE | NET_WANT_SSL_WRITE);
-			return 0;
-
-		case SSL_ERROR_WANT_CONNECT:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_WANT_CONNECT", ret, error);
-			net_con_update(con, NET_EVENT_READ | NET_EVENT_WRITE | NET_WANT_SSL_CONNECT);
-			return 0;
-
-		case SSL_ERROR_WANT_ACCEPT:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_WANT_ACCEPT", ret, error);
-			net_con_update(con, NET_EVENT_READ | NET_EVENT_WRITE | NET_WANT_SSL_ACCEPT);
-			return 0;
-
-		case SSL_ERROR_WANT_X509_LOOKUP:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_WANT_X509_LOOKUP", ret, error);
-			return 0;
-
-		case SSL_ERROR_SYSCALL:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_SYSCALL", ret, error);
-			/* if ret == 0, connection closed, if ret == -1, check with errno */
-			if (ret == 0)
-				return -1;
-			else
-				return -net_error();
-
-		case SSL_ERROR_SSL:
-			LOG_PROTO("SSL_get_error: ret=%d, error=%d: SSL_ERROR_SSL", ret, error);
-			/* internal openssl error */
-			return -1;
-	}
-
-	return -1;
-}
-
-ssize_t net_con_ssl_accept(struct net_connection* con)
-{
-	uhub_assert(con);
-
-	ssize_t ret = SSL_accept(net_con_get_ssl(con));
-#ifdef NETWORK_DUMP_DEBUG
-	LOG_PROTO("SSL_accept() ret=%d", ret);
-#endif
-	if (ret > 0)
-	{
-		net_con_update(con, NET_EVENT_READ);
-	}
-	else
-	{
-		return handle_openssl_error(con, ret);
-	}
-	return ret;
-}
-
-ssize_t net_con_ssl_connect(struct net_connection* con)
-{
-	uhub_assert(con);
-
-	ssize_t ret = SSL_connect(net_con_get_ssl(con));
-#ifdef NETWORK_DUMP_DEBUG
-	LOG_PROTO("SSL_connect() ret=%d", ret);
-#endif
-	if (ret > 0)
-	{
-		net_con_update(con, NET_EVENT_READ);
-	}
-	else
-	{
-		return handle_openssl_error(con, ret);
-	}
-	return ret;
-}
-
-ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode ssl_mode, SSL_CTX* ssl_ctx)
-{
-	uhub_assert(con);
-	SSL* ssl = 0;
-
-	if (ssl_mode == net_con_ssl_mode_server)
-	{
-		ssl = SSL_new(ssl_ctx);
-		SSL_set_fd(ssl, net_con_get_sd(con));
-		net_con_set_ssl(con, ssl);
-		return net_con_ssl_accept(con);
-	}
-	else
-	{
-		ssl = SSL_new(SSL_CTX_new(TLSv1_method()));
-		SSL_set_fd(ssl, net_con_get_sd(con));
-		net_con_set_ssl(con, ssl);
-		return net_con_ssl_connect(con);
-	}
-}
-#endif /* SSL_SUPPORT */
-
-
-ssize_t net_con_send(struct net_connection* con, const void* buf, size_t len)
-{
-	int ret = net_send(net_con_get_sd(con), buf, len, UHUB_SEND_SIGNAL);
-	if (ret == -1)
-	{
-		if (net_error() == EWOULDBLOCK || net_error() == EINTR)
-			return 0;
-		return -1;
-	}
-	return ret;
-}
-
-ssize_t net_con_recv(struct net_connection* con, void* buf, size_t len)
-{
-	uhub_assert(con);
-
-#ifdef SSL_SUPPORT
-	if (!net_con_is_ssl(con))
-	{
-#endif
-		int ret = net_recv(net_con_get_sd(con), buf, len, 0);
-#ifdef NETWORK_DUMP_DEBUG
-		LOG_PROTO("net_recv: ret=%d", ret);
-#endif
-		if (ret == -1)
-		{
-			if (net_error() == EWOULDBLOCK || net_error() == EINTR)
-				return 0;
-			return -net_error();
-		}
-		else if (ret == 0)
-		{
-			return -1;
-		}
-
-		return ret;
-#ifdef SSL_SUPPORT
-	}
-	else
-	{
-		int ret = SSL_read(net_con_get_ssl(con), buf, len);
-#ifdef NETWORK_DUMP_DEBUG
-		LOG_PROTO("net_recv: ret=%d", ret);
-#endif
-		if (ret > 0)
-		{
-			net_con_update(con, NET_EVENT_READ);
-		}
-		else
-		{
-			return -handle_openssl_error(con, ret);
-		}
-		return ret;
-	}
-#endif
-}
-
-ssize_t net_con_peek(struct net_connection* con, void* buf, size_t len)
-{
-	int ret = net_recv(net_con_get_sd(con), buf, len, MSG_PEEK);
-	if (ret == -1)
-	{
-		if (net_error() == EWOULDBLOCK || net_error() == EINTR)
-			return 0;
-		return -net_error();
-	}
-	else if (ret == 0)
-		return -1;
-	return ret;
-}
-
-
-
-

src/network/connection.h

@@ -1,110 +0,0 @@
-/*
- * 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_NETWORK_CONNECTION_H
-#define HAVE_UHUB_NETWORK_CONNECTION_H
-
-#include "uhub.h"
-#include "network/backend.h"
-
-#define NET_EVENT_TIMEOUT         0x0001
-#define NET_EVENT_READ            0x0002
-#define NET_EVENT_WRITE           0x0004
-#define NET_EVENT_SOCKERROR       0x1000 /* Socket error, closed */
-#define NET_EVENT_CLOSED          0x2000 /* Socket closed */
-
-struct net_connection;
-typedef void (*net_connection_cb)(struct net_connection*, int event, void* ptr);
-
-extern int   net_con_get_sd(struct net_connection* con);
-extern void* net_con_get_ptr(struct net_connection* con);
-
-extern struct net_connection* net_con_create();
-extern void net_con_destroy(struct net_connection*);
-extern void net_con_initialize(struct net_connection* con, int sd, net_connection_cb callback, const void* ptr, int events);
-extern void net_con_reinitialize(struct net_connection* con, net_connection_cb callback, const void* ptr, int events);
-extern void net_con_update(struct net_connection* con, int events);
-
-/**
- * Close the connection.
- * This will ensure a connection is closed properly and will generate a NET_EVENT_DESTROYED event which indicates
- * that the con can safely be deleted (or set to NULL).
- * @returns 1 if the memory pointed to by con can be freed immediately, or 0 if it needs to go through the NET_EVENT_DESTROYED event.
- */
-extern int net_con_close(struct net_connection* con);
-
-/**
- * Send data
- *
- * @return returns the number of bytes sent.
- *         0 if no data is sent, and this function should be called again (EWOULDBLOCK/EINTR)
- *        <0 if an error occured, the negative number contains the error code.
- */
-extern ssize_t net_con_send(struct net_connection* con, const void* buf, size_t len);
-
-/**
- * Receive data
- *
- * @return returns the number of bytes sent.
- *         0 if no data is sent, and this function should be called again (EWOULDBLOCK/EINTR)
- *        <0 if an error occured, the negative number contains the error code.
- */
-extern ssize_t net_con_recv(struct net_connection* con, void* buf, size_t len);
-
-/**
- * Receive data without removing them from the recv() buffer.
- * NOTE: This does not currently work for SSL connections after the SSL handshake has been
- * performed.
- */
-extern ssize_t net_con_peek(struct net_connection* con, void* buf, size_t len);
-
-/**
- * Set timeout for connetion.
- *
- * @param seconds the number of seconds into the future.
- */
-extern void net_con_set_timeout(struct net_connection* con, int seconds);
-extern void net_con_clear_timeout(struct net_connection* con);
-
-#ifdef SSL_SUPPORT
-/**
- * Start SSL_accept()
- */
-extern ssize_t net_con_ssl_accept(struct net_connection*);
-
-/**
- * Start SSL_connect()
- */
-extern ssize_t net_con_ssl_connect(struct net_connection*);
-
-enum net_con_ssl_mode
-{
-	net_con_ssl_mode_server,
-	net_con_ssl_mode_client,
-};
-
-extern ssize_t net_con_ssl_handshake(struct net_connection* con, enum net_con_ssl_mode, SSL_CTX* ssl_ctx);
-
-extern int   net_con_is_ssl(struct net_connection* con);
-extern SSL* net_con_get_ssl(struct net_connection* con);
-extern void net_con_set_ssl(struct net_connection* con, SSL*);
-#endif /* SSL_SUPPORT */
-
-#endif /* HAVE_UHUB_NETWORK_CONNECTION_H */
-

src/network/epoll.c

@@ -1,306 +0,0 @@
-/*
- * 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"
-
-#ifdef USE_EPOLL
-
-#include "network/connection.h"
-#include "network/common.h"
-#include "network/backend.h"
-
-#define EPOLL_EVBUFFER 512
-
-struct net_connection
-{
-	int                  sd;
-	uint32_t             flags;
-	net_connection_cb    callback;
-	void*                ptr;
-	struct epoll_event   ev;
-	struct timeout_evt*  timeout;
-#ifdef SSL_SUPPORT
-	SSL*                 ssl;
-	size_t               write_len; /** Length of last SSL_write(), only used if flags is NET_WANT_SSL_READ. */
-#endif
-};
-
-struct net_backend
-{
-	int epfd;
-	size_t num;
-	size_t max;
-	struct net_connection** conns;
-	struct epoll_event events[EPOLL_EVBUFFER];
-	time_t now;
-	struct timeout_queue timeout_queue;
-};
-
-static struct net_backend* g_backend = 0;
-
-static void net_con_print(const char* prefix, struct net_connection* con)
-{
-	char buf[512];
-	int off = snprintf(buf, 512, "%s: net_connection={ sd=%d, flags=%u, callback=%p, ptr=%p, ev={ events=%s%s, data.ptr=%p }",
-		prefix, con->sd, con->flags, con->callback, con->ptr, (con->ev.events & EPOLLIN ? "R" : ""),(con->ev.events & EPOLLOUT ? "W" : "") , con->ev.data.ptr);
-	if (con->timeout)
-	{
-		sprintf(buf + off, ", timeout={ %d seconds left }", (int) (con->timeout->timestamp - g_backend->now));
-	}
-	else
-	{
-		sprintf(buf + off, ", timeout=NULL");
-	}
-	LOG_TRACE(buf);
-}
-
-/**
- * Initialize the network backend.
- * Returns 1 on success, or 0 on failure.
- */
-int net_backend_initialize()
-{
-	size_t max = net_get_max_sockets();
-	g_backend = hub_malloc(sizeof(struct net_backend));
-	g_backend->epfd = epoll_create(max);
-	if (g_backend->epfd == -1)
-	{
-		LOG_WARN("Unable to create epoll socket.");
-		return 0;
-	}
-	
-	g_backend->num = 0;
-	g_backend->max = max;
-	g_backend->conns = hub_malloc_zero(sizeof(struct net_connection*) * max);
-	memset(g_backend->events, 0, sizeof(g_backend->events));
-
-	g_backend->now = time(0);
-	timeout_queue_initialize(&g_backend->timeout_queue, g_backend->now, 600); /* look max 10 minutes into the future. */
-	return 1;
-}
-
-/**
- * Shutdown the network connection backend.
- */
-void net_backend_shutdown()
-{
-	close(g_backend->epfd);
-	hub_free(g_backend->conns);
-	hub_free(g_backend);
-}
-
-/**
- * Process the network backend.
- */
-int net_backend_process()
-{
-	int n;
-	LOG_TRACE("epoll_wait: fd=%d, events=%x, max=%zu", g_backend->epfd, g_backend->events, MIN(g_backend->num, EPOLL_EVBUFFER));
-	int res = epoll_wait(g_backend->epfd, g_backend->events, MIN(g_backend->num, EPOLL_EVBUFFER), 1000);
-	if (res == -1)
-	{
-		LOG_WARN("epoll_wait returned -1");
-		return 0;
-	}
-
-	for (n = 0; n < res; n++)
-	{
-		struct net_connection* con = (struct net_connection*) g_backend->events[n].data.ptr;
-		int ev = 0;
-		if (g_backend->events[n].events & EPOLLIN)  ev |= NET_EVENT_READ;
-		if (g_backend->events[n].events & EPOLLOUT) ev |= NET_EVENT_WRITE;
-		con->callback(con, ev, con->ptr);
-	}
-	return 1;
-}
-
-
-struct net_connection* net_con_create()
-{
-	struct net_connection* con = (struct net_connection*) hub_malloc_zero(sizeof(struct net_connection));
-	con->sd = -1;
-	return con;
-}
-
-void net_con_destroy(struct net_connection* con)
-{
-	hub_free(con);
-}
-
-void net_con_initialize(struct net_connection* con, int sd, net_connection_cb callback, const void* ptr, int events)
-{
-	con->sd = sd;
-	con->flags = NET_INITIALIZED;
-	con->callback = callback;
-	con->ev.events = 0;
-	con->ptr = (void*) ptr;
-	con->ev.data.ptr = (void*) con;
-
-	net_set_nonblocking(con->sd, 1);
-	net_set_nosigpipe(con->sd, 1);
-
-	if (events & NET_EVENT_READ) con->ev.events |= EPOLLIN;
-	if (events & NET_EVENT_WRITE) con->ev.events |= EPOLLOUT;
-
-	g_backend->conns[sd] = con;
-	g_backend->num++;
-
-	if (epoll_ctl(g_backend->epfd, EPOLL_CTL_ADD, con->sd, &con->ev) == -1)
-	{
-		LOG_TRACE("epoll_ctl() add failed.");
-	}
-
-	net_con_print("ADD", con);
-}
-
-void net_con_reinitialize(struct net_connection* con, net_connection_cb callback, const void* ptr, int events)
-{
-	con->callback = callback;
-	con->ptr = (void*) ptr;
-	net_con_update(con, events);
-}
-
-void net_con_update(struct net_connection* con, int events)
-{
-	con->ev.events = 0;
-	if (events & NET_EVENT_READ) con->ev.events |= EPOLLIN;
-	if (events & NET_EVENT_WRITE) con->ev.events |= EPOLLOUT;
-
-#ifdef SSL_SUPPORT
-	if (events & NET_WANT_SSL_WRITE)
-		con->flags |= NET_WANT_SSL_WRITE;
-	else
-		con->flags &= ~NET_WANT_SSL_WRITE;
-
-	if (events & NET_WANT_SSL_READ)
-		con->flags |= NET_WANT_SSL_READ;
-	else
-		con->flags &= ~NET_WANT_SSL_READ;
-
-	if (events & NET_WANT_SSL_ACCEPT)
-		con->flags |= NET_WANT_SSL_ACCEPT;
-	else
-		con->flags &= ~NET_WANT_SSL_ACCEPT;
-
-	if (events & NET_WANT_SSL_CONNECT)
-		con->flags |= NET_WANT_SSL_CONNECT;
-	else
-		con->flags &= ~NET_WANT_SSL_CONNECT;
-#endif /* SSL_SUPPORT */
-
-	if (epoll_ctl(g_backend->epfd, EPOLL_CTL_MOD, con->sd, &con->ev) == -1)
-	{
-		LOG_TRACE("epoll_ctl() modify failed.");
-	}
-	net_con_print("MOD", con);
-}
-
-int net_con_close(struct net_connection* con)
-{
-	if (!(con->flags & NET_INITIALIZED))
-		return 0;
-
-	con->flags &= ~NET_INITIALIZED;
-
-	if (con->sd != -1)
-	{
-		g_backend->conns[con->sd] = 0;
-		g_backend->num--;
-	}
-
-	if (timeout_evt_is_scheduled(con->timeout))
-	{
-		timeout_queue_remove(&g_backend->timeout_queue, con->timeout);
-		hub_free(con->timeout);
-		con->timeout = 0;
-	}
-
-	if (epoll_ctl(g_backend->epfd, EPOLL_CTL_DEL, con->sd, &con->ev) == -1)
-	{
-		LOG_WARN("epoll_ctl() delete failed.");
-	}
-	net_con_print("DEL", con);
-	return 0;
-}
-
-#ifdef SSL_SUPPORT
-int net_con_is_ssl(struct net_connection* con)
-{
-
-	return con->ssl != 0;
-}
-
-SSL* net_con_get_ssl(struct net_connection* con)
-{
-	return con->ssl;
-}
-
-void net_con_set_ssl(struct net_connection* con, SSL* ssl)
-{
-	con->ssl = ssl;
-}
-#endif
-
-int net_con_get_sd(struct net_connection* con)
-{
-	return con->sd;
-}
-
-void* net_con_get_ptr(struct net_connection* con)
-{
-	return con->ptr;
-}
-
-
-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*);
-
-static void timeout_callback(struct timeout_evt* evt)
-{
-	struct net_connection* con = (struct net_connection*) evt->ptr;
-	con->callback(con, NET_EVENT_TIMEOUT, con->ptr);
-}
-
-
-void net_con_set_timeout(struct net_connection* con, int seconds)
-{
-	if (!con->timeout)
-	{
-		con->timeout = hub_malloc_zero(sizeof(struct timeout_evt));
-		timeout_evt_initialize(con->timeout, timeout_callback, con);
-		timeout_queue_insert(&g_backend->timeout_queue, con->timeout, seconds);
-	}
-	else
-	{
-		timeout_queue_reschedule(&g_backend->timeout_queue, con->timeout, seconds);
-	}
-}
-
-void net_con_clear_timeout(struct net_connection* con)
-{
-	if (con->timeout && timeout_evt_is_scheduled(con->timeout))
-	{
-		timeout_queue_remove(&g_backend->timeout_queue, con->timeout);
-		hub_free(con->timeout);
-		con->timeout = 0;
-	}
-}
-
-#endif /* USE_EPOLL */

src/network/libevent.c

@@ -1,399 +0,0 @@
-/*
- * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, 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/>.
- *
- */
-
-#ifdef USE_LIBEVENT
-
-struct net_connection
-{
-	NET_CON_STRUCT_COMMON
-	struct event         event;     /** libevent struct for read/write events */
-	struct event         timeout;   /** Used for internal timeout handling */
-};
-
-struct net_timer
-{
-	unsigned int         initialized;
-	struct event         timeout;
-	net_timeout_cb       callback;
-	void*                ptr;
-};
-
-int net_con_get_sd(struct net_connection* con)
-{
-	return con->sd;
-}
-
-void* net_con_get_ptr(struct net_connection* con)
-{
-	return con->ptr;
-}
-
-struct net_connection* net_con_create()
-{
-	struct net_connection* con = (struct net_connection*) hub_malloc(sizeof(struct net_connection));
-	return con;
-}
-
-static inline int net_con_flag_get(struct net_connection* con, unsigned int flag)
-{
-    return con->flags & flag;
-}
-
-static inline void net_con_flag_set(struct net_connection* con, unsigned int flag)
-{
-    con->flags |= flag;
-}
-
-static inline void net_con_flag_unset(struct net_connection* con, unsigned int flag)
-{
-    con->flags &= ~flag;
-}
-
-void net_con_destroy(struct net_connection* con)
-{
-	hub_free(con);
-}
-
-static inline int net_con_convert_to_libevent_mask(int ev)
-{
-	int events = 0;
-	if (ev & NET_EVENT_READ)  events |= EV_READ;
-	if (ev & NET_EVENT_WRITE) events |= EV_WRITE;
-	return events;
-}
-
-static inline int net_con_convert_from_libevent_mask(int ev)
-{
-	int events = 0;
-	if (ev & EV_TIMEOUT)    events |= NET_EVENT_TIMEOUT;
-	if (ev & EV_READ)       events |= NET_EVENT_READ;
-	if (ev & EV_WRITE)      events |= NET_EVENT_WRITE;
-	return events;
-}
-
-static void net_con_event(int fd, short ev, void *arg);
-
-
-int net_con_close(struct net_connection* con)
-{
-	uhub_assert(con);
-
-	con->ptr = 0;
-
-	if (net_con_flag_get(con, NET_CLEANUP))
-		return 0;
-
-	if (net_con_flag_get(con, NET_PROCESSING_BUSY))
-	{
-		net_con_flag_set(con, NET_CLEANUP);
-		return 0;
-	}
-
-	net_con_after_close(con);
-	return 1;
-}
-
-static void net_con_set(struct net_connection* con)
-{
-	uhub_assert(con);
-
-	int ev = 0;
-	if (net_con_flag_get(con, NET_WANT_READ | NET_WANT_SSL_READ))   ev |= EV_READ;
-	if (net_con_flag_get(con, NET_WANT_WRITE | NET_WANT_SSL_WRITE)) ev |= EV_WRITE;
-
-	if (net_con_flag_get(con, NET_EVENT_SET) != 0)
-	{
-		event_del(&con->event);
-	}
-	net_con_flag_set(con, NET_EVENT_SET);
-
-	LOG_MEMORY("SET: set+add: CON={ %p, %p, %d, %d}", con, &con->event, con->sd, ev);
-	event_set(&con->event, con->sd, ev, net_con_event, con);
-	event_add(&con->event, 0);
-
-	net_con_flag_set(con, NET_INITIALIZED);
-}
-
-static void net_con_after_close(struct net_connection* con)
-{
-	if (net_con_flag_get(con, NET_INITIALIZED))
-	{
-		LOG_MEMORY("DEL:   close: CON={ %p, %p, %d, %d}", con, &con->event, con->sd, -1);
-		net_con_flag_unset(con, NET_EVENT_SET);
-
-		event_del(&con->event);
-		net_con_flag_unset(con, NET_INITIALIZED);
-	}
-
-	net_con_clear_timeout(con);
-	net_close(con->sd);
-	con->sd = -1;
-
-	hub_free(con);
-}
-
-void net_con_initialize(struct net_connection* con, int sd, net_connection_cb callback, const void* ptr, int ev)
-{
-	uhub_assert(con);
-
-	int events = net_con_convert_to_libevent_mask(ev);
-	if (ev & NET_EVENT_READ)  net_con_flag_set(con, NET_WANT_READ);
-	if (ev & NET_EVENT_WRITE) net_con_flag_set(con, NET_WANT_WRITE);
-
-	con->sd = sd;
-	con->flags = 0;
-	con->ptr = (void*) ptr;
-	con->callback = callback;
-	con->last_send = time(0);
-	con->last_recv = con->last_send;
-
-	if (ev)
-	{
-		uhub_assert(net_con_flag_get(con, NET_EVENT_SET) == 0);
-		net_con_flag_set(con, NET_EVENT_SET);
-
-		LOG_MEMORY("SET:    init: CON={ %p, %p, %d, %d}", con, &con->event, con->sd, ev);
-		event_set(&con->event, con->sd, events, net_con_event, con);
-		event_add(&con->event, 0);
-		net_con_flag_set(con, NET_INITIALIZED);
-	}
-
-	net_set_nonblocking(sd, 1);
-	net_set_nosigpipe(sd, 1);
-
-#ifdef SSL_SUPPORT
-	con->ssl = NULL;
-	con->write_len = 0;
-#endif
-}
-
-void net_con_reinitialize(struct net_connection* con, net_connection_cb callback, const void* ptr, int events)
-{
-	uhub_assert(con);
-	con->callback = callback;
-	con->ptr = (void*) ptr;
-	net_con_update(con, events);
-}
-
-void net_con_update(struct net_connection* con, int ev)
-{
-	uhub_assert(con);
-
-	if (ev & NET_EVENT_READ)
-		net_con_flag_set(con, NET_EVENT_READ);
-	else
-		net_con_flag_unset(con, NET_EVENT_READ);
-
-	if (ev & NET_EVENT_WRITE)
-		net_con_flag_set(con, NET_EVENT_WRITE);
-	else
-		net_con_flag_unset(con, NET_EVENT_WRITE);
-
-	if (!net_con_flag_get(con, NET_PROCESSING_BUSY))
-	{
-		net_con_set(con);
-	}
-}
-
-#define CALLBACK(CON, EVENTS) \
-	if (CON->callback) \
-		CON->callback(con, EVENTS, CON->ptr);
-
-static void net_con_event(int fd, short ev, void *arg)
-{
-	struct net_connection* con = (struct net_connection*) arg;
-	int events = net_con_convert_from_libevent_mask(ev);
-
-	if (!net_con_flag_get(con, NET_INITIALIZED))
-	{
-		return;
-	}
-
-	if (net_con_flag_get(con, NET_CLEANUP))
-	{
-		net_con_after_close(con);
-		return;
-	}
-
-	net_con_flag_set(con, NET_PROCESSING_BUSY);
-
-// 	uhub_assert(net_con_flag_get(con, NET_EVENT_SET) != 0);
-	net_con_flag_unset(con, NET_EVENT_SET);
-
-	LOG_MEMORY("EVT: process: CON={ %p, %p, %d, %d}", con, &con->event, con->sd, (int) ev);
-
-#ifdef SSL_SUPPORT
-	if (!con->ssl)
-	{
-#endif
-		CALLBACK(con, events);
-#ifdef SSL_SUPPORT
-	}
-	else
-	{
-#ifdef NETWORK_DUMP_DEBUG
-		LOG_PROTO("net_con_event: events=%d, con=%p", ev, con);
-#endif
-		if (ev & (EV_READ | EV_WRITE))
-		{
-			if (net_con_flag_get(con, NET_WANT_SSL_ACCEPT))
-			{
-				if (net_con_ssl_accept(con) < 0)
-					CALLBACK(con, NET_EVENT_SOCKERROR);
-			}
-			else if (net_con_flag_get(con, NET_WANT_SSL_CONNECT))
-			{
-				if (net_con_ssl_connect(con) < 0)
-					CALLBACK(con, NET_EVENT_SOCKERROR);
-			}
-			else if (ev == EV_READ && net_con_flag_get(con, NET_WANT_SSL_READ))
-			{
-				CALLBACK(con, NET_EVENT_WRITE);
-			}
-			else if (ev == EV_WRITE && net_con_flag_get(con, NET_WANT_SSL_WRITE))
-			{
-				CALLBACK(con, events & NET_EVENT_READ);
-			}
-			else
-			{
-				CALLBACK(con, events);
-			}
-		}
-		else
-		{
-			CALLBACK(con, events);
-		}
-	}
-#endif
-	net_con_flag_unset(con, NET_PROCESSING_BUSY);
-
-	if (net_con_flag_get(con, NET_CLEANUP))
-	{
-		net_con_after_close(con);
-	}
-	else
-	{
-		net_con_set(con);
-	}
-}
-
-
-static void net_timer_event(int fd, short ev, void *arg)
-{
-	struct net_timer* timer = (struct net_timer*) arg;
-	timer->callback(timer, timer->ptr);
-}
-
-void net_timer_initialize(struct net_timer* timer, net_timeout_cb callback, void* ptr)
-{
-	timer->initialized = 0;
-	timer->callback = callback;
-	timer->ptr = ptr;
-}
-
-void net_timer_reset(struct net_timer* timer, int seconds)
-{
-	struct timeval timeout = { seconds, 0 };
-	if (timer->initialized)
-	{
-		evtimer_del(&timer->timeout);
-		timer->initialized = 0;
-	}
-	evtimer_set(&timer->timeout, net_timer_event, timer);
-	evtimer_add(&timer->timeout, &timeout);
-}
-
-void net_timer_shutdown(struct net_timer* timer)
-{
-	if (timer->initialized)
-	{
-		evtimer_del(&timer->timeout);
-		timer->initialized = 0;
-	}
-	timer->callback = 0;
-	timer->ptr = 0;
-}
-
-
-void net_con_set_timeout(struct net_connection* con, int seconds)
-{
-	uhub_assert(con);
-
-	struct timeval timeout = { seconds, 0 };
-	net_con_clear_timeout(con);
-
-	evtimer_set(&con->timeout, net_con_event, con);
-	evtimer_add(&con->timeout, &timeout);
-	net_con_flag_set(con, NET_TIMER_ENABLED);
-}
-
-void net_con_clear_timeout(struct net_connection* con)
-{
-	uhub_assert(con);
-
-	if (net_con_flag_get(con, NET_TIMER_ENABLED))
-	{
-		evtimer_del(&con->timeout);
-		net_con_flag_unset(con, NET_TIMER_ENABLED);
-	}
-}
-
-static struct event_base g_evbase = 0;
-
-/**
- * Initialize the network backend.
- * Returns 1 on success, or 0 on failure.
- */
-int net_backend_initialize()
-{
-	g_evbase = event_init();
-	if (!g_evbase)
-	{
-		LOG_ERROR("Unable to initialize libevent.");
-		return 0;
-	}
-	LOG_DEBUG("Using libevent %s, backend: %s", event_get_version(), event_get_method());
-	return 1;
-}
-
-/**
- * Shutdown the network connection backend.
- */
-void net_backend_shutdown()
-{
-	event_base_free(g_evbase);
-}
-
-/**
- * Process the network backend.
- */
-int net_backend_process()
-{
-	int ret = event_base_loop(g_evbase, EVLOOP_ONCE);
-	if (ret != 0)
-	{
-		LOG_DEBUG("event_base_loop returned: %d", (int) ret);
-	}
-	if (ret < 0)
-		return 0;
-	return 1;
-}
-
-
-#endif /* USE_LIBEVENT */

src/plugin.h

@@ -0,0 +1,52 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2009, 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/>.
+ *
+ */
+
+typedef void (*plugin_event_startup)(struct hub*);
+typedef void (*plugin_event_shutdown)(struct hub*);
+typedef void (*plugin_event_user_login)(struct hub*, struct user*);
+typedef void (*plugin_event_user_logout)(struct hub*, struct user*);
+typedef int  (*plugin_event_connect)(struct hub*, struct ip_addr_encap);
+typedef void (*plugin_event_disconnect)(struct hub*, struct user*);
+typedef int  (*plugin_event_message)(struct hub*, struct user*, struct adc_message*);
+typedef void (*plugin_event_support)(struct hub*, struct user*, int);
+
+struct uhub_plugin
+{
+	/** Starting the hub */
+	plugin_event_startup     evt_startup;
+
+	/** Shutting down the hub */
+	plugin_event_shutdown    evt_shutdown;
+
+	/** Someone connected to the hub (we only have IP at this point). */
+	plugin_event_connect     evt_connect;
+
+	/** Someone disconnected from the hub (but was not successfully logged in). */
+	plugin_event_disconnect  evt_disconnect;
+
+	/** A client sent a message about which protocol extensions it supports */
+	plugin_event_support     evt_support;
+
+	/** A client was successfully logged in to the hub */
+	plugin_event_user_login  evt_login;
+
+	/** A client (previously logged in) has disconnected. */
+	plugin_event_user_logout evt_logout;
+};
+

src/route.c

@@ -0,0 +1,266 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2009, 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 route_message(struct user* u, struct adc_message* msg)
+{
+	struct user* target = NULL;
+
+	switch (msg->cache[0])
+	{
+		case 'B': /* Broadcast to all logged in clients */
+			route_to_all(u->hub, msg);
+			break;
+			
+		case 'D':
+			target = get_user_by_sid(u->hub, msg->target);
+			if (target)
+			{
+				route_to_user(target, msg);
+			}
+			break;
+			
+		case 'E':
+			target = get_user_by_sid(u->hub, msg->target);
+			if (target)
+			{
+				route_to_user(target, msg);
+				route_to_user(u, msg);
+			}
+			break;
+			
+		case 'F':
+			route_to_subscribers(u->hub, msg);
+			break;	
+		
+		default:
+			/* Ignore the message */
+			break;
+	}
+	return 0;
+}
+
+
+static void queue_command(struct user* user, struct adc_message* msg__, int offset)
+{
+	struct adc_message* msg = adc_msg_incref(msg__);
+	list_append(user->send_queue, msg);
+
+#ifdef DEBUG_SENDQ
+	hub_log(log_trace, "SENDQ: user=%p, msg=%p (%zu), offset=%d, length=%d, total_length=%d", user, msg, msg->references, offset, msg->length, user->send_queue_size);
+#endif
+
+	user->send_queue_size += msg->length - offset;
+	if (list_size(user->send_queue) == 1)
+	{
+		user->send_queue_offset = offset;
+		user->tm_last_write = time(NULL);
+	}
+}
+
+// #define ALWAYS_QUEUE_MESSAGES
+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)));
+	 */
+	return hub->config->max_send_buffer;
+}
+
+static size_t get_max_send_queue_soft(struct hub_info* hub)
+{
+	return hub->config->max_send_buffer_soft;
+}
+
+
+
+/*
+ * @return 1 if send queue is OK.
+ *         -1 if send queue is overflowed
+ *         0 if soft send queue is overflowed (not implemented at the moment)
+ */
+static int check_send_queue(struct user* user, struct adc_message* msg)
+{
+	if (user_flag_get(user, flag_user_list))
+		return 1;
+
+	if ((user->send_queue_size + msg->length) > get_max_send_queue(user->hub))      
+		return -1;
+
+	if (user->send_queue_size > get_max_send_queue_soft(user->hub) && msg->priority < 0)
+		return 0;
+
+	return 1;
+}
+
+int route_to_user(struct user* user, struct adc_message* msg)
+{
+	int ret;
+	
+#if LOG_SEND_MESSAGES_WHEN_ROUTED
+	char* data = strndup(msg->cache, msg->length-1);
+	hub_log(log_protocol, "send %s: %s", sid_to_string(user->sid), data);
+	free(data);
+#endif
+
+#ifndef ALWAYS_QUEUE_MESSAGES
+	if (user->send_queue_size == 0 && !user_is_disconnecting(user))
+	{
+		ret = net_send(user->sd, msg->cache, msg->length, UHUB_SEND_SIGNAL);
+		
+		if (ret == msg->length)
+		{
+			return 1;
+		}
+		
+		if (ret >= 0 || (ret == -1 && net_error() == EWOULDBLOCK))
+		{
+			queue_command(user, msg, ret);
+			
+			if (user->send_queue_size && user->ev_handle)
+				event_add(user->ev_handle, NULL);
+		}
+		else
+		{
+			/* A socket error occured */
+			user_disconnect(user, quit_socket_error);
+			return 0;
+		}
+	}
+	else
+#endif
+	{
+		ret = check_send_queue(user, msg);
+		if (ret == -1)
+		{
+			/* User is not able to swallow the data, let's cut our losses and disconnect. */
+			user_disconnect(user, quit_send_queue);
+		}
+		else if (ret == 1)
+		{
+			/* queue command */
+			queue_command(user, msg, 0);
+                        if (user->ev_handle)
+				event_add(user->ev_handle, NULL);
+
+		}
+		else
+		{
+			/* do not queue command as our soft-limits are exceeded */
+		}
+	}
+	
+	return 1;
+}
+
+
+int route_to_all(struct hub_info* hub, struct adc_message* command) /* iterate users */
+{
+	struct user* user = (struct user*) list_get_first(hub->users->list);
+	while (user)
+	{
+		route_to_user(user, command);
+		user = (struct user*) list_get_next(hub->users->list);
+	}
+	
+	return 0;
+}
+
+
+int route_to_subscribers(struct hub_info* hub, struct adc_message* command) /* iterate users */
+{
+	int do_send;
+	char* tmp;
+	
+	struct user* user = (struct user*) list_get_first(hub->users->list);
+	while (user)
+	{
+		if (user->feature_cast)
+		{
+			do_send = 1;
+			
+			tmp = list_get_first(command->feature_cast_include);
+			while (tmp)
+			{
+				if (!user_have_feature_cast_support(user, tmp))
+				{
+					do_send = 0;
+					break;
+				}
+				tmp = list_get_next(command->feature_cast_include);;
+			}
+			
+			if (!do_send) {
+				user = (struct user*) list_get_next(hub->users->list);
+				continue;
+			}
+			
+			tmp = list_get_first(command->feature_cast_exclude);
+			while (tmp)
+			{
+				if (user_have_feature_cast_support(user, tmp))
+				{
+					do_send = 0;
+					break;
+				}
+				tmp = list_get_next(command->feature_cast_exclude);
+			}
+			
+			if (do_send)
+			{
+				route_to_user(user, command);
+			}
+		}
+		user = (struct user*) list_get_next(hub->users->list);
+	}
+	
+	return 0;
+}
+
+int route_info_message(struct user* u)
+{
+	if (!user_is_nat_override(u))
+	{
+		return route_to_all(u->hub, u->info);
+	}
+	else
+	{
+		struct adc_message* cmd = adc_msg_copy(u->info);
+		const char* address = ip_convert_to_string(&u->ipaddr);
+		struct user* user = 0;
+		
+		adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_IPV4_ADDR);
+		adc_msg_add_named_argument(cmd, ADC_INF_FLAG_IPV4_ADDR, address);
+	
+		user = (struct user*) list_get_first(u->hub->users->list);
+		while (user)
+		{
+			if (user_is_nat_override(user))
+				route_to_user(user, cmd);
+			else
+				route_to_user(user, u->info);
+			
+			user = (struct user*) list_get_next(u->hub->users->list);
+		}
+		adc_msg_free(cmd);
+	}
+	return 0;
+}

src/route.h

@@ -23,17 +23,12 @@
 /**
  * Route a message by sending it to it's final destination.
  */
-extern int route_message(struct hub_info* hub, struct hub_user* u, struct adc_message* msg);
+extern int route_message(struct user* u, struct adc_message* msg);
-
-/**
- * Send queued messages.
- */
-extern int route_flush_pipeline(struct hub_info* hub, struct hub_user* u);
 
 /**
  * Transmit message directly to one user.
  */
-extern int route_to_user(struct hub_info* hub, struct hub_user*, struct adc_message* command);
+extern int route_to_user(struct user*, struct adc_message* command);
 
 /**
  * Broadcast message to all users.
@@ -50,7 +45,7 @@ extern int route_to_subscribers(struct hub_info* hub, struct adc_message* comman
  * This will ensure the correct IP is seen by other users
  * in case nat override is in use.
  */
-extern int route_info_message(struct hub_info* hub, struct hub_user* user);
+extern int route_info_message(struct user* user);
 
 
 #endif /* HAVE_UHUB_ROUTE_H */

src/sid.c

@@ -0,0 +1,61 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2009, 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"
+
+const char* BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
+char* sid_to_string(sid_t sid_)
+{
+	static char t_sid[5];
+	sid_t sid = (sid_ & 0xFFFFF); /*  20 bits only */
+	sid_t A, B, C, D = 0;
+	D     = (sid % 32);
+	sid   = (sid - D) / 32;
+	C     = (sid % 32);
+	sid   = (sid - C) / 32;
+	B     = (sid % 32);
+	sid   = (sid - B) / 32;
+	A     = (sid % 32);
+	t_sid[0] = BASE32_ALPHABET[A];
+	t_sid[1] = BASE32_ALPHABET[B];
+	t_sid[2] = BASE32_ALPHABET[C];
+	t_sid[3] = BASE32_ALPHABET[D];
+	t_sid[4] = 0;
+	return t_sid;
+}
+
+
+sid_t string_to_sid(const char* sid)
+{
+	sid_t nsid = 0;
+	sid_t n, x;
+	sid_t factors[] = { 32768, 1024, 32, 1};
+	
+	if (!sid || strlen(sid) != 4) return 0;
+
+	for (n = 0; n < 4; n++) {
+		for (x = 0; x < strlen(BASE32_ALPHABET); x++)
+			if (sid[n] == BASE32_ALPHABET[x]) break;
+		if (x == 32) return 0;
+		nsid += x * factors[n];
+	}
+	return nsid;
+}
+

src/sid.h

@@ -22,19 +22,44 @@
 
 #define SID_MAX 1048576
 
-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);
 
-extern struct sid_pool* sid_pool_create(sid_t max);
+struct sid_map
-extern void sid_pool_destroy(struct sid_pool*);
+{
+	struct user* ptr;
+	struct sid_map* next;
+};
 
-extern sid_t sid_alloc(struct sid_pool*, struct hub_user*);
+/**
+ * Session IDs are heavily reused, since they are a fairly scarce
+ * resource. Only one (2^10)-1 exist, since it is a four byte base32-encoded
+ * value and 'AAAA' (0) is reserved for the hub.
+ *
+ * Initialize with sid_initialize(), which sets min and max to one, and count to 0.
+ *
+ * When allocating a session ID:
+ * - If 'count' is less than the pool size (max-min), then allocate within the pool
+ * - Increase the pool size (see below)
+ * - If unable to do that, hub is really full - don't let anyone in!
+ *
+ * When freeing a session ID:
+ * - If the session ID being freed is 'max', then decrease the pool size by one.
+ *
+ */
+struct sid_pool
+{
+	sid_t min;
+	sid_t max;
+	sid_t count;
+	struct sid_map* map;
+};
+
+
+extern void sid_initialize(struct sid_pool*);
+extern sid_t sid_alloc(struct sid_pool*, struct user*);
 extern void sid_free(struct sid_pool*, sid_t);
-extern struct hub_user* sid_lookup(struct sid_pool*, sid_t);
 
 
 

src/system.h

@@ -1,137 +0,0 @@
-/*
- * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, 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_SYSTEM_H
-#define HAVE_UHUB_SYSTEM_H
-
-#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(__CYGWIN__) || defined(__MINGW32__)
-#ifndef WINSOCK
-#define WINSOCK
-#endif
-#endif
-
-#ifdef WINSOCK
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <sys/types.h>
-#include <sys/time.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#endif
-
-#include <assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <getopt.h>
-#include <signal.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <unistd.h>
-
-#if !defined(WIN32)
-#include <grp.h>
-#include <pwd.h>
-#include <sys/resource.h>
-#define HAVE_STRNDUP
-#define HAVE_MEMMEM
-#define HAVE_GETRLIMIT
-#endif
-
-/* printf and size_t support */
-#if defined(WIN32)
-/* Windows uses %Iu for size_t */
-#define PRINTF_SIZE_T "%Iu"
-#else
-#define PRINTF_SIZE_T "%zu"
-#endif
-
-#ifdef SSL_SUPPORT
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#endif
-
-#include "../version.h"
-
-#define uhub_assert assert
-
-#ifdef USE_LIBEVENT
-#include <event.h>
-#else
-#ifdef __linux__
-#define USE_EPOLL
-#include <sys/epoll.h>
-#endif
-#endif
-
-#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__sun__)
-#undef HAVE_STRNDUP
-#undef HAVE_MEMMEM
-#endif
-
-#ifdef MSG_NOSIGNAL
-#define UHUB_SEND_SIGNAL MSG_NOSIGNAL
-#else
-#ifdef MSG_NOPIPE
-#define UHUB_SEND_SIGNAL MSG_NOPIPE
-#else
-#define UHUB_SEND_SIGNAL 0
-#endif
-#endif
-
-#ifndef INET6_ADDRSTRLEN
-#define INET6_ADDRSTRLEN 46
-#endif
-
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-
-
-#endif /* HAVE_UHUB_SYSTEM_H */

src/tiger.c

@@ -47,13 +47,10 @@ extern uint64_t tiger_sboxes[4*256];
 	ROUND(b, c, a, x7, mul)
 
 void tiger_compress(uint64_t* str, uint64_t state[3]) {
-	uint64_t a, b, c;
+	uint64_t a, b, c, swap;
 	uint64_t x0, x1, x2, x3, x4, x5, x6, x7;
 	uint64_t aa, bb, cc;
-#if PASSES > 3
-	uint64_t swap;
 	size_t pass_no;
-#endif
 	a = state[0];
 	b = state[1];
 	c = state[2];
@@ -111,7 +108,6 @@ void tiger_compress(uint64_t* str, uint64_t state[3]) {
 
 	PASS(b, c, a, 9);
 	
-#if PASSES > 3
 	for (pass_no = 3; pass_no < PASSES; pass_no++)
 	{
 		x0 -= x7 ^ 0xA5A5A5A5A5A5A5A5ULL;
@@ -138,7 +134,6 @@ void tiger_compress(uint64_t* str, uint64_t state[3]) {
 		c = b;
 		b = swap;
 	}
-#endif
 	
 	a ^= aa;
 	b -= bb;

src/tools/adcclient.c

@@ -1,491 +0,0 @@
-/*
- * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, 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 "tools/adcclient.h"
-
-#define ADC_HANDSHAKE "HSUP ADBASE ADTIGR ADPING\n"
-#define ADC_CID_SIZE 39
-#define BIG_BUFSIZE 32768
-#define TIGERSIZE 24
-
-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);
-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);
-static void ADC_client_on_recv_line(struct ADC_client* client, const char* line, size_t length);
-
-static void ADC_client_debug(struct ADC_client* client, const char* format, ...)
-{
-	char logmsg[1024];
-	va_list args;
-	va_start(args, format);
-	vsnprintf(logmsg, 1024, format, args);
-	va_end(args);
-	fprintf(stdout, "* [%p] %s\n", client, logmsg);
-}
-
-static void ADC_client_set_state(struct ADC_client* client, enum ADC_client_state state)
-{
-	client->state = state;
-}
-
-
-static void adc_cid_pid(struct ADC_client* client)
-{
-	char seed[64];
-	char pid[64];
-	char cid[64];
-	uint64_t tiger_res1[3];
-	uint64_t tiger_res2[3];
-
-	/* create cid+pid pair */
-	memset(seed, 0, 64);
-	snprintf(seed, 64, VERSION "%p", client);
-
-	tiger((uint64_t*) seed, strlen(seed), tiger_res1);
-	base32_encode((unsigned char*) tiger_res1, TIGERSIZE, pid);
-	tiger((uint64_t*) tiger_res1, TIGERSIZE, tiger_res2);
-	base32_encode((unsigned char*) tiger_res2, TIGERSIZE, cid);
-	cid[ADC_CID_SIZE] = 0;
-	pid[ADC_CID_SIZE] = 0;
-
-	adc_msg_add_named_argument(client->info, ADC_INF_FLAG_PRIVATE_ID, pid);
-	adc_msg_add_named_argument(client->info, ADC_INF_FLAG_CLIENT_ID, cid);
-}
-
-static void event_callback(struct net_connection* con, int events, void *arg)
-{
-	struct ADC_client* client = (struct ADC_client*) net_con_get_ptr(con);
-
-	if (events == NET_EVENT_SOCKERROR || events == NET_EVENT_CLOSED)
-	{
-		printf("NET_EVENT_SOCKERROR || NET_EVENT_CLOSED\n");
-		client->callback(client, ADC_CLIENT_DISCONNECTED, 0);
-		return;
-	}
-
-	if (events == NET_EVENT_TIMEOUT)
-	{
-		if (client->state == ps_conn)
-		{
-			client->callback(client, ADC_CLIENT_DISCONNECTED, 0);
-		}
-	}
-
-	if (events & NET_EVENT_READ)
-	{
-		if (ADC_client_recv(client) == -1)
-		{
-			ADC_client_on_disconnected(client);
-		}
-	}
-
-	if (events & NET_EVENT_WRITE)
-	{
-		if (client->state == ps_conn)
-		{
-			ADC_client_connect(client, 0);
-		}
-		else
-		{
-			/* FIXME: Call send again */
-		}
-	}
-}
-
-#define UNESCAPE_ARG(TMP, TARGET) \
-		if (TMP) \
-			TARGET = adc_msg_unescape(TMP); \
-		else \
-			TARGET = NULL; \
-		hub_free(TMP);
-
-#define EXTRACT_NAMED_ARG(MSG, NAME, TARGET) \
-		do { \
-			char* tmp = adc_msg_get_named_argument(MSG, NAME); \
-			UNESCAPE_ARG(tmp, TARGET); \
-		} while (0)
-
-#define EXTRACT_POS_ARG(MSG, POS, TARGET) \
-		do { \
-			char* tmp = adc_msg_get_argument(MSG, POS); \
-			UNESCAPE_ARG(tmp, TARGET); \
-		} while (0)
-
-
-static void ADC_client_on_recv_line(struct ADC_client* client, const char* line, size_t length)
-{
-#ifdef ADC_CLIENT_DEBUG_PROTO
-	ADC_client_debug(client, "- LINE: '%s'", start);
-#endif
-
-	/* Parse message */
-	struct adc_message* msg = adc_msg_parse(line, length);
-	if (!msg)
-	{
-		ADC_client_debug(client, "WARNING: Message cannot be decoded: \"%s\"", line);
-		return;
-	}
-
-	if (length < 4)
-	{
-		ADC_client_debug(client, "Unexpected response from hub: '%s'", line);
-		return;
-	}
-
-	switch (msg->cmd)
-	{
-		case ADC_CMD_ISUP:
-			break;
-
-		case ADC_CMD_ISID:
-			if (client->state == ps_protocol)
-			{
-				client->sid = string_to_sid(&line[5]);
-				client->callback(client, ADC_CLIENT_LOGGING_IN, 0);
-				ADC_client_set_state(client, ps_identify);
-				ADC_client_send_info(client);
-			}
-			break;
-
-		case ADC_CMD_BMSG:
-		case ADC_CMD_EMSG:
-		case ADC_CMD_DMSG:
-		case ADC_CMD_IMSG:
-		{
-			struct ADC_chat_message chat;
-			struct ADC_client_callback_data data;
-			chat.from_sid       = msg->source;
-			chat.to_sid         = msg->target;
-			data.chat = &chat;
-			EXTRACT_POS_ARG(msg, 0, chat.message);
-			client->callback(client, ADC_CLIENT_MESSAGE, &data);
-			hub_free(chat.message);
-			break;
-		}
-
-		case ADC_CMD_IINF:
-		{
-			struct ADC_hub_info hubinfo;
-			EXTRACT_NAMED_ARG(msg, "NI", hubinfo.name);
-			EXTRACT_NAMED_ARG(msg, "DE", hubinfo.description);
-			EXTRACT_NAMED_ARG(msg, "VE", hubinfo.version);
-
-			struct ADC_client_callback_data data;
-			data.hubinfo = &hubinfo;
-			client->callback(client, ADC_CLIENT_HUB_INFO, &data);
-			hub_free(hubinfo.name);
-			hub_free(hubinfo.description);
-			hub_free(hubinfo.version);
-			break;
-		}
-
-		case ADC_CMD_BSCH:
-		case ADC_CMD_FSCH:
-		{
-			client->callback(client, ADC_CLIENT_SEARCH_REQ, 0);
-			break;
-		}
-
-		case ADC_CMD_BINF:
-		{
-			if (msg->source == client->sid)
-			{
-				if (client->state == ps_verify || client->state == ps_identify)
-				{
-					ADC_client_on_login(client);
-				}
-			}
-			else
-			{
-				if (adc_msg_has_named_argument(msg, "ID"))
-				{
-					struct ADC_user user;
-					EXTRACT_NAMED_ARG(msg, "NI", user.name);
-					EXTRACT_NAMED_ARG(msg, "DE", user.description);
-					EXTRACT_NAMED_ARG(msg, "VE", user.version);
-					EXTRACT_NAMED_ARG(msg, "ID", user.cid);
-					EXTRACT_NAMED_ARG(msg, "I4", user.address);
-
-					struct ADC_client_callback_data data;
-					data.user = &user;
-					client->callback(client, ADC_CLIENT_USER_JOIN, &data);
-
-					hub_free(user.name);
-					hub_free(user.description);
-					hub_free(user.version);
-					hub_free(user.cid);
-					hub_free(user.address);
-				}
-			}
-		}
-
-		case ADC_CMD_ISTA:
-			/*
-			if (strncmp(line, "ISTA 000", 8))
-			{
-				ADC_client_debug(client, "status: '%s'\n", (start + 9));
-			}
-			*/
-			break;
-			
-		default:
-			break;
-	}
-
-	adc_msg_free(msg);
-}
-
-static ssize_t ADC_client_recv(struct ADC_client* client)
-{
-	ssize_t size = net_con_recv(client->con, &client->recvbuf[client->r_offset], ADC_BUFSIZE - client->r_offset);
-	if (size <= 0)
-		return size;
-
-	client->r_offset += size;
-	client->recvbuf[client->r_offset] = 0;
-
-	char* start = client->recvbuf;
-	char* pos;
-	char* lastPos = 0;
-	size_t remaining = client->r_offset;
-
-	while ((pos = memchr(start, '\n', remaining)))
-	{
-		pos[0] = 0;
-
-		ADC_client_on_recv_line(client, start, pos - start);
-
-		pos++;
-		remaining -= (pos - start);
-		start = pos;
-		lastPos = pos;
-	}
-
-	if (lastPos)
-	{
-		memmove(client->recvbuf, lastPos, remaining);
-		client->r_offset = remaining;
-	}
-	return 0;
-}
-
-
-void ADC_client_send(struct ADC_client* client, char* msg)
-{
-	int ret = net_con_send(client->con, msg, strlen(msg));
-
-#ifdef ADC_CLIENT_DEBUG_PROTO
-	char* dump = strdup(msg);
-	dump[strlen(msg) - 1] = 0;
-	ADC_client_debug(client, "- SEND: '%s'", dump);
-	free(dump);
-#endif
-
-	if (ret != strlen(msg))
-	{
-		if (ret == -1)
-		{
-			if (net_error() != EWOULDBLOCK)
-				ADC_client_on_disconnected(client);
-		}
-		else
-		{
-			/* FIXME: Not all data sent! */
-			printf("ret (%d) != msg->length (%d)\n", ret, (int) strlen(msg));
-		}
-	}
-}
-
-void ADC_client_send_info(struct ADC_client* client)
-{
-	char binf[11];
-	snprintf(binf, 11, "BINF %s\n", sid_to_string(client->sid));
-	client->info = adc_msg_create(binf);
-
-	adc_msg_add_named_argument_string(client->info, ADC_INF_FLAG_NICK, client->nick);
-
-	if (client->desc)
-	{
-		adc_msg_add_named_argument_string(client->info, ADC_INF_FLAG_DESCRIPTION, client->desc);
-	}
-
-	adc_msg_add_named_argument_string(client->info, ADC_INF_FLAG_USER_AGENT, PRODUCT "/" VERSION);
-
-	adc_cid_pid(client);
-	ADC_client_send(client, client->info->cache);
-}
-
-int ADC_client_create(struct ADC_client* client, const char* nickname, const char* description)
-{
-	memset(client, 0, sizeof(struct ADC_client));
-
-	int sd = net_socket_create(PF_INET, SOCK_STREAM, IPPROTO_TCP);
-	if (sd == -1) return -1;
-
-	client->con = net_con_create();
-#if 0
-	/* FIXME */
-	client->timer = 0; /* FIXME: hub_malloc(sizeof(struct net_timer)); */
-#endif
-	net_con_initialize(client->con, sd, event_callback, client, 0);
-#if 0
-	/* FIXME */
-	net_timer_initialize(client->timer, timer_callback, client);
-#endif
-	ADC_client_set_state(client, ps_none);
-
-	client->nick = hub_strdup(nickname);
-	client->desc = hub_strdup(description);
-
-	return 0;
-}
-
-void ADC_client_destroy(struct ADC_client* client)
-{
-	ADC_client_disconnect(client);
-#if 0
-	/* FIXME */
-	net_timer_shutdown(client->timer);
-#endif
-	hub_free(client->timer);
-	adc_msg_free(client->info);
-	hub_free(client->nick);
-	hub_free(client->desc);
-	hub_free(client->hub_address);
-}
-
-int ADC_client_connect(struct ADC_client* client, const char* address)
-{
-	if (!client->hub_address)
-	{
-		if (!ADC_client_parse_address(client, address))
-			return 0;
-	
-		client->callback(client, ADC_CLIENT_CONNECTING, 0);
-	}
-
-	int ret = net_connect(net_con_get_sd(client->con), (struct sockaddr*) &client->addr, sizeof(struct sockaddr_in));
-	if (ret == 0 || (ret == -1 && net_error() == EISCONN))
-	{
-		ADC_client_on_connected(client);
-	}
-	else if (ret == -1 && (net_error() == EALREADY || net_error() == EINPROGRESS || net_error() == EWOULDBLOCK || net_error() == EINTR))
-	{
-		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);
-		return 0;
-	}
-	return 1;
-}
-
-static void ADC_client_on_connected(struct ADC_client* client)
-{
-	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);
-}
-
-static void ADC_client_on_disconnected(struct ADC_client* client)
-{
-	net_con_close(client->con);
-	client->con = 0;
-	ADC_client_set_state(client, ps_none);
-}
-
-static void ADC_client_on_login(struct ADC_client* client)
-{
-	ADC_client_set_state(client, ps_normal);
-	client->callback(client, ADC_CLIENT_LOGGED_IN, 0);
-}
-
-void ADC_client_disconnect(struct ADC_client* client)
-{
-	if (client->con && net_con_get_sd(client->con) != -1)
-	{
-		net_con_close(client->con);
-		client->con = 0;
-	}
-}
-
-static int ADC_client_parse_address(struct ADC_client* client, const char* arg)
-{
-	char* split;
-	int ssl = 0;
-	struct hostent* dns;
-	struct in_addr* addr;
-
-	if (!arg)
-		return 0;
-
-	client->hub_address = hub_strdup(arg);
-
-	/* Minimum length of a valid address */
-	if (strlen(arg) < 9)
-		return 0;
-
-	/* Check for ADC or ADCS */
-	if (!strncmp(arg, "adc://", 6))
-		ssl = 0;
-	else if (!strncmp(arg, "adcs://", 7))
-		ssl = 1;
-	else
-		return 0;
-
-	/* Split hostname and port (if possible) */
-	split = strrchr(client->hub_address + 6 + ssl, ':');
-	if (split == 0 || strlen(split) < 2 || strlen(split) > 6)
-		return 0;
-
-	/* Ensure port number is valid */
-	int port = strtol(split+1, NULL, 10);
-	if (port <= 0 || port > 65535)
-		return 0;
-
-	split[0] = 0;
-
-	/* Resolve IP address (FIXME: blocking call) */
-	dns = gethostbyname(client->hub_address + 6 + ssl);
-	if (dns)
-	{
-		addr = (struct in_addr*) dns->h_addr_list[0];
-	}
-
-	// Initialize the sockaddr struct.
-	memset(&client->addr, 0, sizeof(client->addr));
-	client->addr.sin_family = AF_INET;
-	client->addr.sin_port   = htons(port);
-	memcpy(&client->addr.sin_addr, addr, sizeof(struct in_addr));
-	return 1;
-}
-
-void ADC_client_set_callback(struct ADC_client* client, adc_client_cb cb)
-{
-	client->callback = cb;
-}

src/tools/adcclient.h

@@ -1,129 +0,0 @@
-/*
- * 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_ADC_CLIENT_H
-#define HAVE_UHUB_ADC_CLIENT_H
-
-#include "uhub.h"
-
-#define ADC_BUFSIZE 16384
-
-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 */
-};
-
-struct ADC_client;
-
-enum ADC_client_callback_type
-{
-	ADC_CLIENT_CONNECTING       = 1001,
-	ADC_CLIENT_CONNECTED        = 1002,
-	ADC_CLIENT_DISCONNECTED     = 1003,
-
-	ADC_CLIENT_LOGGING_IN       = 2001,
-	ADC_CLIENT_PASSWORD_REQ     = 2002,
-	ADC_CLIENT_LOGGED_IN        = 2003,
-	ADC_CLIENT_LOGIN_ERROR      = 2004,
-
-	ADC_CLIENT_PROTOCOL_STATUS  = 3001,
-	ADC_CLIENT_MESSAGE          = 3002,
-	ADC_CLIENT_CONNECT_REQ      = 3003,
-	ADC_CLIENT_REVCONNECT_REQ   = 3004,
-	ADC_CLIENT_SEARCH_REQ       = 3005,
-	ADC_CLIENT_SEARCH_REP       = 3006,
-
-	ADC_CLIENT_USER_JOIN        = 4001,
-	ADC_CLIENT_USER_QUIT        = 4002,
-	ADC_CLIENT_USER_UPDATE      = 4003,
-
-	ADC_CLIENT_HUB_INFO         = 5001,
-};
-
-struct ADC_hub_info
-{
-	char* name;
-	char* description;
-	char* version;
-};
-
-struct ADC_chat_message
-{
-	sid_t from_sid;
-	sid_t to_sid;
-	char* message;
-	int flags;
-};
-
-struct ADC_user
-{
-	sid_t sid;
-	char* cid;
-	char* name;
-	char* description;
-	char* address;
-	char* version;
-};
-
-
-struct ADC_client_callback_data
-{
-	union {
-		struct ADC_hub_info* hubinfo;
-		struct ADC_chat_message* chat;
-		struct ADC_user* user;
-	};
-};
-
-typedef int (*adc_client_cb)(struct ADC_client*, enum ADC_client_callback_type, struct ADC_client_callback_data* data);
-
-struct ADC_client
-{
-	sid_t sid;
-	enum ADC_client_state state;
-	struct adc_message* info;
-	char recvbuf[ADC_BUFSIZE];
-	char sendbuf[ADC_BUFSIZE];
-	adc_client_cb callback;
-	size_t s_offset;
-	size_t r_offset;
-	size_t timeout;
-	struct net_connection* con;
-	struct net_timer* timer;
-	struct sockaddr_in addr;
-	char* hub_address;
-	char* nick;
-	char* desc;
-};
-
-int ADC_client_create(struct ADC_client* client, const char* nickname, const char* description);
-void ADC_client_set_callback(struct ADC_client* client, adc_client_cb);
-void ADC_client_destroy(struct ADC_client* client);
-int ADC_client_connect(struct ADC_client* client, const char* address);
-void ADC_client_disconnect(struct ADC_client* client);
-void ADC_client_send(struct ADC_client* client, char* msg);
-
-#endif /* HAVE_UHUB_ADC_CLIENT_H */
-
-

src/tools/adcrush.c

@@ -1,475 +0,0 @@
-/**
- * An ADC client emulator.
- */
-
-#include "adcclient.h"
-
-#define ADC_CLIENTS_DEFAULT 100
-#define ADC_MAX_CLIENTS 25000
-#define ADC_CID_SIZE 39
-#define BIG_BUFSIZE 32768
-#define TIGERSIZE 24
-#define ADCRUSH "adcrush/0.3"
-#define ADC_NICK "[BOT]adcrush"
-#define ADC_DESC "crash\\stest\\sdummy"
-
-#define LVL_INFO 1
-#define LVL_DEBUG 2
-#define LVL_VERBOSE 3
-
-static const char* cfg_uri = 0; /* address */
-static int cfg_debug       = 0; /* debug level */
-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] = {
-	"hello",
-	"I'm an annoying robot, configured to chat in order to measure performance of the hub.",
-	"I apologize for the inconvenience.",
-	".",
-	":)",
-	"can anyone help me, pls?",
-	"wtf?",
-	"bullshit",
-	"resistance is futile.", 
-	"You crossed the line first, sir. You squeezed them, you hammered them to the point of desperation. And in their desperation they turned to a man they didn't fully understand.",
-	"beam me up, scotty",
-	"morning",
-	"You know where Harvey is? You know who he is?",
-	"gtg",
-	"thanks",
-	"*punt*",
-	"*nudge*",
-	"that's ok",
-	"...anyway", 
-	"hola",
-	"hey",
-	"hi", 
-	"nevermind",
-	"i think so",
-	"dunno",
-	"debian ftw",
-	"oops",
-	"how do I search?",
-	"how do I enable active mode?",
-	"home, sweet home...",
-	"later",
-	"Good evening, ladies and gentlemen. We are tonight's entertainment! I only have one question. Where is Harvey Dent?",
-	"You know where I can find Harvey? I need to talk to him about something. Just something, a little.",
-	"We really should stop fighting, we'll miss the fireworks!",
-	"Wanna know how I got these scars?",
-};
-
-#define MAX_SEARCH_MSGS 10
-const char* search_messages[MAX_SEARCH_MSGS] = {
-	"ANmp3 TOauto",
-	"ANxxx TOauto",
-	"ANdivx TOauto",
-	"ANtest ANfoo TOauto",
-	"ANwmv TO1289718",
-	"ANbabe TO8981884",
-	"ANpr0n TOauto",
-	"ANmusic TOauto",
-	"ANvideo TOauto",
-	"ANburnout ANps3 TOauto",
-};
-
-
-
-static void bot_output(struct ADC_client* client, int level, const char* format, ...)
-{
-	char logmsg[1024];
-	va_list args;
-	va_start(args, format);
-	vsnprintf(logmsg, 1024, format, args);
-	va_end(args);
-
-	if (cfg_debug >= level)
-	fprintf(stdout, "* [%p] %s\n", client, logmsg);
-}
-
-#if 0
-static size_t get_wait_rand(size_t max)
-{
-	static size_t next = 0;
-	if (next == 0) next = (size_t) time(0);
-	next = (next * 1103515245) + 12345;
-	return ((size_t )(next / 65536) % max);
-}
-
-
-static void perf_result(struct ADC_client* client, sid_t target, const char* what, const char* token);
-
-static void perf_chat(struct ADC_client* client, int priv)
-{
-	char buf[1024] = { 0, };
-	size_t r = get_wait_rand(MAX_CHAT_MSGS-1);
-	char* msg = adc_msg_escape(chat_messages[r]);
-
-	if (priv)
-	{
-		strcat(buf, "EMSG ");
-		strcat(buf, sid_to_string(client->sid));
-		strcat(buf, " ");
-		strcat(buf, sid_to_string(client->sid));
-	}
-	else
-	{
-		strcat(buf, "BMSG ");
-		strcat(buf, sid_to_string(client->sid));
-	}
-	strcat(buf, " ");
-
-	strcat(buf, msg);
-	hub_free(msg);
-	
-	strcat(buf, "\n");
-	ADC_client_send(client, buf);
-}
-
-static void perf_search(struct ADC_client* client)
-{
-	char buf[1024] = { 0, };
-	size_t r = get_wait_rand(MAX_SEARCH_MSGS-1);
-	size_t pst = get_wait_rand(100);
-	
-	if (pst > 80)
-	{
-		strcat(buf, "FSCH ");
-		strcat(buf, sid_to_string(client->sid));
-		strcat(buf, " +TCP4 ");
-	}
-	else
-	{
-		strcat(buf, "BSCH ");
-		strcat(buf, sid_to_string(client->sid));
-		strcat(buf, " ");
-	}
-	strcat(buf, search_messages[r]);
-	strcat(buf, "\n");
-	ADC_client_send(client, buf);
-}
-
-static void perf_result(struct ADC_client* client, sid_t target, const char* what, const char* token)
-{
-	char buf[1024] = { 0, };
-	strcat(buf, "DRES ");
-	strcat(buf, sid_to_string(client->sid));
-	strcat(buf, " ");
-	strcat(buf, sid_to_string(target));
-	strcat(buf, " FN" "test/");
-	strcat(buf, what);
-	strcat(buf, ".dat");
-	strcat(buf, " SL" "0");
-	strcat(buf, " SI" "908987128912");
-	strcat(buf, " TR" "5T6YJYKO3WECS52BKWVSOP5VUG4IKNSZBZ5YHBA");
-	strcat(buf, " TO");
-	strcat(buf, token);
-	strcat(buf, "\n");
-	ADC_client_send(client, buf);
-}
-
-static void perf_ctm(struct ADC_client* client)
-{
-	char buf[1024] = { 0, };
-	strcat(buf, "DCTM ");
-	strcat(buf, sid_to_string(client->sid));
-	strcat(buf, " ");
-	strcat(buf, sid_to_string(client->sid));
-	strcat(buf, " ");
-	strcat(buf, "ADC/1.0");
-	strcat(buf, " TOKEN111");
-	strcat(buf, sid_to_string(client->sid));
-	strcat(buf, "\n");
-	ADC_client_send(client, buf);
-}
-
-
-static void perf_update(struct ADC_client* client)
-{
-	char buf[1024] = { 0, };
-	int n = (int) get_wait_rand(10)+1;
-	
-	strcat(buf, "BINF ");
-	strcat(buf, sid_to_string(client->sid));
-	strcat(buf, " HN");
-	strcat(buf, uhub_itoa(n));
-
-	strcat(buf, "\n");
-	ADC_client_send(client, buf);
-}
-
-static void perf_normal_action(struct ADC_client* client)
-{
-	size_t r = get_wait_rand(5);
-	size_t p = get_wait_rand(100);
-
-	switch (r)
-	{
-		case 0:
-			if (p > (90 - (10 * cfg_level)))
-			{
-				bot_output(client, LVL_VERBOSE, "timeout -> disconnect");
-				ADC_client_disconnect(client);
-			}
-			break;
-
-		case 1:
-			if (cfg_chat)
-			{
-				bot_output(client, LVL_VERBOSE, "timeout -> chat");
-				perf_chat(client, 0);
-				
-			}
-			break;
-
-		case 2:
-			bot_output(client, LVL_VERBOSE, "timeout -> search");
-			perf_search(client);
-			break;
-
-		case 3:
-			bot_output(client, LVL_VERBOSE, "timeout -> update");
-			perf_update(client);
-			break;
-
-		case 4:
-			bot_output(client, LVL_VERBOSE, "timeout -> privmsg");
-			perf_chat(client, 1);
-			break;
-
-		case 5:
-			bot_output(client, LVL_VERBOSE, "timeout -> ctm/rcm");
-			perf_ctm(client);
-			break;
-
-	}
-}
-#endif
-
-static int handle(struct ADC_client* client, enum ADC_client_callback_type type, struct ADC_client_callback_data* data)
-{
-	switch (type)
-	{
-		case ADC_CLIENT_CONNECTING:
-			bot_output(client, LVL_DEBUG, "*** Connecting...");
-			break;
-
-		case ADC_CLIENT_CONNECTED:
-			bot_output(client, LVL_DEBUG, "*** Connected.");
-			break;
-
-		case ADC_CLIENT_DISCONNECTED:
-			bot_output(client, LVL_DEBUG, "*** Disconnected.");
-			break;
-
-		case ADC_CLIENT_LOGGING_IN:
-			bot_output(client, LVL_DEBUG, "*** Logging in...");
-			break;
-
-		case ADC_CLIENT_PASSWORD_REQ:
-			bot_output(client, LVL_DEBUG, "*** Requesting password.");
-
-		case ADC_CLIENT_LOGGED_IN:
-			bot_output(client, LVL_DEBUG, "*** Logged in.");
-			break;
-
-		case ADC_CLIENT_LOGIN_ERROR:
-			bot_output(client, LVL_DEBUG, "*** Login error");
-			break;
-
-		case ADC_CLIENT_MESSAGE:
-			bot_output(client, LVL_DEBUG, "    <%s> %s", sid_to_string(data->chat->from_sid), data->chat->message);
-			break;
-
-		case ADC_CLIENT_USER_JOIN:
-			bot_output(client, LVL_VERBOSE, "    JOIN: %s", data->user->name);
-			break;
-
-		case ADC_CLIENT_USER_QUIT:
-			bot_output(client, LVL_VERBOSE, "    QUIT");
-			break;
-
-		case ADC_CLIENT_SEARCH_REQ:
-			break;
-
-		case ADC_CLIENT_HUB_INFO:
-			bot_output(client, LVL_DEBUG, "    Hub: \"%s\" [%s]\n"
-				   "         \"%s\"\n", data->hubinfo->name, data->hubinfo->version, data->hubinfo->description);
-			break;
-
-		default:
-			bot_output(client, LVL_DEBUG, "Not handled event=%d\n", (int) type);
-			return 0;
-			break;
-	}
-	return 1;
-}
-
-void runloop(size_t clients)
-{
-	size_t n = 0;
-	struct ADC_client* client[ADC_MAX_CLIENTS];
-
-	for (n = 0; n < clients; n++)
-	{
-		struct ADC_client* c = malloc(sizeof(struct ADC_client));
-		client[n] = c;
-
-		char nick[20];
-		snprintf(nick, 20, "adcrush_%d", (int) n);
-
-		ADC_client_create(c, nick, "stresstester");
-		ADC_client_set_callback(c, handle);
-		ADC_client_connect(c, cfg_uri);
-	}
-
-	while (running)
-	{
-		event_base_loop(net_get_evbase(), EVLOOP_ONCE);
-	}
-
-	for (n = 0; n < clients; n++)
-	{
-		ADC_client_destroy(client[n]);
-		free(client[n]);
-		client[n] = 0;
-	}
-}
-
-static void print_version()
-{
-	printf(ADCRUSH "\n");
-	printf("Copyright (C) 2008-2009, Jan Vidar Krey\n");
-	printf("\n");
-}
-
-static void print_usage(const char* program)
-{
-	print_version();
-
-	printf("Usage: %s [adc[s]://<host>:<port>] [options]\n", program);
-
-	printf("\n");
-	printf("  OPTIONS\n");
-	printf("    -l <0-3>    Level: 0=polite, 1=normal (default), 2=aggressive, 3=excessive.\n");
-	printf("    -n <num>    Number of concurrent connections\n");
-	printf("    -c          Allow broadcasting chat messages.\n");
-	printf("    -d          Enable debug output.\n");
-	printf("    -q          Quiet mode (no output).\n");
-	printf("\n");
-
-	exit(0);
-}
-
-int parse_address(const char* arg)
-{
-	if (!arg || strlen(arg) < 9)
-		return 0;
-	
-	if (strncmp(arg, "adc://", 6) && strncmp(arg, "adcs://", 7))
-		return 0;
-
-	cfg_uri = arg;
-	return 1;
-}
-
-int parse_arguments(int argc, char** argv)
-{
-	int ok = 1;
-	int opt;
-	for (opt = 2; opt < argc; opt++)
-	{
-		if      (!strcmp(argv[opt], "-c"))
-			cfg_chat = 1;
-		else if (!strncmp(argv[opt], "-d", 2))
-			cfg_debug += strlen(argv[opt]) - 1;
-		else if (!strcmp(argv[opt], "-q"))
-			cfg_quiet = 1;
-		else if (!strcmp(argv[opt], "-l") && (++opt) < argc)
-		{
-			cfg_level = MIN(MAX(uhub_atoi(argv[opt]), 0), 3);
-		}
-		else if (!strcmp(argv[opt], "-n") && (++opt) < argc)
-		{
-			cfg_clients = MIN(MAX(uhub_atoi(argv[opt]), 1), ADC_MAX_CLIENTS);
-		}
-	}
-	return ok;
-}
-
-
-void parse_command_line(int argc, char** argv)
-{
-	if (argc < 2 ||
-		!parse_address(argv[1]) ||
-		!parse_arguments(argc, argv))
-	{
-		print_usage(argv[0]);
-	}
-}
-
-#ifndef WIN32
-static void handle_signal(int signal, short events, void* arg)
-{
-	switch (signal)
-	{
-		case SIGINT:
-		case SIGTERM:
-			running = 0;
-			break;
-		default:
-			break;
-	}
-}
-
-static struct event signal_events[10];
-static int signals[] =
-{
-	SIGINT,  /* Interrupt the application */
-	SIGTERM, /* Terminate the application */
-	0
-};
-
-void setup_signal_handlers()
-{
-	int i = 0;
-	for (i = 0; signals[i]; i++)
-	{
-		signal_set(&signal_events[i], signals[i], handle_signal, NULL);
-		signal_add(&signal_events[i], NULL);
-	}
-}
-
-void shutdown_signal_handlers()
-{
-	int i = 0;
-	for (i = 0; signals[i]; i++)
-	{
-		signal_del(&signal_events[i]);
-	}
-}
-#endif /* WIN32 */
-
-
-int main(int argc, char** argv)
-{
-	parse_command_line(argc, argv);
-	
-	net_initialize();
-	setup_signal_handlers();
-
-	hub_log_initialize(NULL, 0);
-	hub_set_log_verbosity(1000);
-
-	runloop(cfg_clients);
-
-	shutdown_signal_handlers();
-	net_destroy();
-
-	return 0;
-}

src/tools/admin.c

@@ -1,89 +0,0 @@
-/**
- * A remote uhub admin client.
- */
-
-#include "adcclient.h"
-
-static int handle(struct ADC_client* client, enum ADC_client_callback_type type, struct ADC_client_callback_data* data)
-{
-	switch (type)
-	{
-		case ADC_CLIENT_CONNECTING:
-			puts("*** Connecting...");
-			break;
-
-		case ADC_CLIENT_CONNECTED:
-			puts("*** Connected.");
-			break;
-
-		case ADC_CLIENT_DISCONNECTED:
-			puts("*** Disconnected.");
-			break;
-
-		case ADC_CLIENT_LOGGING_IN:
-			puts("*** Logging in...");
-			break;
-
-		case ADC_CLIENT_PASSWORD_REQ:
-			puts("*** Requesting password.");
-
-		case ADC_CLIENT_LOGGED_IN:
-			puts("*** Logged in.");
-			break;
-
-		case ADC_CLIENT_LOGIN_ERROR:
-			puts("*** Login error");
-			break;
-
-		case ADC_CLIENT_MESSAGE:
-			printf("    <%s> %s\n", sid_to_string(data->chat->from_sid), data->chat->message);
-			break;
-
-		case ADC_CLIENT_USER_JOIN:
-			printf("    JOIN: %s\n", data->user->name);
-			break;
-
-		case ADC_CLIENT_USER_QUIT:
-			printf("    QUIT\n");
-			break;
-
-		case ADC_CLIENT_SEARCH_REQ:
-			break;
-
-		case ADC_CLIENT_HUB_INFO:
-			printf("    Hub: \"%s\" [%s]\n"
-				   "         \"%s\"\n", data->hubinfo->name, data->hubinfo->version, data->hubinfo->description);
-			break;
-
-		default:
-			printf("Not handled event=%d\n", (int) type);
-			return 0;
-			break;
-	}
-	return 1;
-}
-
-
-int main(int argc, char** argv)
-{
-	if (argc < 2)
-	{
-		printf("Usage: %s adc[s]://host:port\n", argv[0]);
-		return 1;
-	}
-
-	struct ADC_client client;
-	net_initialize();
-
-	ADC_client_create(&client, "uhub-admin", "stresstester");
-	ADC_client_set_callback(&client, handle);
-	ADC_client_connect(&client, argv[1]);
-
-	event_dispatch();
-
-	ADC_client_destroy(&client);
-	net_destroy();
-	return 0;
-}
-
-

src/tools/fuzzer.h

@@ -1,35 +0,0 @@
-enum commandMode
-{
-	cm_bcast    = 0x01, /* B - broadcast */
-	cm_dir      = 0x02, /* D - direct message */
-	cm_echo     = 0x04, /* E - echo message */
-	cm_fcast    = 0x08, /* F - feature cast message */
-	cm_c2h      = 0x10, /* H - client to hub message */
-	cm_h2c      = 0x20, /* I - hub to client message */
-	cm_c2c      = 0x40, /* C - client to client message */
-	cm_udp      = 0x80, /* U - udp message (client to client) */
-};
-
-enum commandValidity
-{
-	cv_protocol = 0x01,
-	cv_identify = 0x02,
-	cv_verify   = 0x04,
- 	cv_normal   = 0x08,
-};
-
-const struct commandPattern patterns[] =
-{
-	{ cm_c2h | cm_c2c | cm_h2c,                     "SUP", cv_protocol | cv_normal }, /* protocol support */
-	{ cm_bcast | cm_h2c | cm_c2c,                   "INF", cv_identify | cv_verify | cv_normal }, /* info message */
-	{ cm_bcast | cm_h2c | cm_c2c | cm_c2h | cm_udp, "STA", cv_protocol | cv_identify | cv_verify | cv_normal }, /* status message */
-	{ cm_bcast | cm_dir | cm_echo | cm_h2c,         "MSG", cv_normal },   /* chat message */
-	{ cm_bcast | cm_dir | cm_echo | cm_fcast,       "SCH", cv_normal },   /* search */
-	{ cm_dir | cm_udp,                              "RES", cv_normal },   /* search result */
-	{ cm_dir | cm_echo,                             "CTM", cv_normal },   /* connect to me */
-	{ cm_dir | cm_echo,                             "RCM", cv_normal },   /* reversed, connect to me */
-	{ cm_h2c,                                       "QUI", cv_normal },   /* quit message */
-	{ cm_h2c,                                       "GPA", cv_identify }, /* password request */
-	{ cm_c2h,                                       "PAS", cv_verify }    /* password response */
-};
-

src/uhub.h

@@ -1,6 +1,6 @@
 /*
  * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2010, Jan Vidar Krey
+ * Copyright (C) 2007-2009, 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,9 +23,80 @@
 /* Debugging */
 /* #define NETWORK_DUMP_DEBUG */
 /* #define MEMORY_DEBUG */
-/* #define DEBUG_SENDQ 1 */
 
-#include "system.h"
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#if defined(__CYGWIN__) || defined(__MINGW32__)
+#ifndef WINSOCK
+#define WINSOCK
+#endif
+#endif
+
+#ifdef WINSOCK
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#else
+#include <sys/types.h>
+#include <sys/time.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#ifndef WIN32
+#include <grp.h>
+#include <pwd.h>
+#define HAVE_STRNDUP
+#define HAVE_MEMMEM
+#endif
+
+#ifdef SSL_SUPPORT
+#include <openssl/ssl.h>
+#endif
+
+#include "../version.h"
+
+#define uhub_assert assert
+
+#include <event.h>
+
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
+#undef HAVE_STRNDUP
+#undef HAVE_MEMMEM
+#endif
+
+#ifdef MSG_NOSIGNAL
+#define UHUB_SEND_SIGNAL MSG_NOSIGNAL
+#else
+#ifdef MSG_NOPIPE
+#define UHUB_SEND_SIGNAL MSG_NOPIPE
+#else
+#define UHUB_SEND_SIGNAL 0
+#endif
+#endif
+
+
+#define SERVER_PORT      1511
+#define SERVER_ADDR_IPV6 "::"
+#define SERVER_ADDR_IPV4 "0.0.0.0"
+#define SERVER_BACKLOG   50
 
 #ifndef WIN32
 #define SERVER_CONFIG    "/etc/uhub/uhub.conf"
@@ -41,48 +112,51 @@
 #define TIMEOUT_CONNECTED 15
 #define TIMEOUT_HANDSHAKE 30
 #define TIMEOUT_SENDQ     120
+#define TIMEOUT_IDLE      7200
 #define TIMEOUT_STATS     60
 
+#define MAX_CLIENTS  512
 #define MAX_CID_LEN  39
 #define MAX_NICK_LEN 64
 #define MAX_UA_LEN   32
 #define TIGERSIZE    24
 
 #define MAX_RECV_BUF 65535
-#define MAX_SEND_BUF 65535
+
+#ifndef INET6_ADDRSTRLEN
+#define INET6_ADDRSTRLEN 46
+#endif
+
+#include "adcconst.h"
+
+#define MIN(a, b) (a < b ? a : b)
+#define MAX(a, b) (a > b ? a : b)
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include "adc/adcconst.h"
+#include "memory.h"
-
+#include "misc.h"
-#include "util/ipcalc.h"
+#include "eventid.h"
-#include "util/list.h"
+#include "eventqueue.h"
-#include "util/log.h"
+#include "ipcalc.h"
-#include "util/memory.h"
+#include "list.h"
-#include "util/misc.h"
+#include "sid.h"
-#include "util/timeout.h"
+#include "network.h"
-#include "util/tiger.h"
+#include "netevent.h"
-
+#include "auth.h"
-#include "adc/sid.h"
+#include "tiger.h"
-#include "adc/message.h"
+#include "config.h"
-#include "network/network.h"
+#include "log.h"
-#include "network/connection.h"
+#include "user.h"
-
+#include "usermanager.h"
-#include "core/auth.h"
+#include "message.h"
-#include "core/config.h"
+#include "route.h"
-#include "core/eventid.h"
+#include "hub.h"
-#include "core/eventqueue.h"
+#include "commands.h"
-#include "core/netevent.h"
+#include "inf.h"
-#include "core/hubio.h"
+#include "hubevent.h"
-#include "core/user.h"
-#include "core/usermanager.h"
-#include "core/route.h"
-#include "core/hub.h"
-#include "core/commands.h"
-#include "core/inf.h"
-#include "core/hubevent.h"
 
 #ifdef __cplusplus
 }

src/user.c

@@ -0,0 +1,317 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2009, Jan Vidar Krey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "uhub.h"
+
+struct user* user_create(struct hub_info* hub, int sd)
+{
+	struct user* user = NULL;
+	
+	hub_log(log_trace, "user_create(), hub=%p, sd=%d", hub, sd);
+
+	user = (struct user*) hub_malloc_zero(sizeof(struct user));
+
+	if (user == NULL)
+		return NULL; /* OOM */
+
+	user->ev_handle = hub_malloc_zero(sizeof(struct event));
+
+	if (!user->ev_handle)
+	{
+	    hub_free(user->ev_handle);
+	    hub_free(user);
+	    return NULL;
+	}
+	
+	user->sd = sd;
+	user->tm_connected = time(NULL);
+	user->hub = hub;
+	user->feature_cast = 0;
+	
+	user->send_queue = list_create();
+	user->send_queue_offset = 0;
+	user->send_queue_size = 0;
+	user->recv_buf_offset = 0;
+	user->recv_buf = 0;
+	
+	user_set_state(user, state_protocol);
+	return user;
+}
+
+static void clear_send_queue_callback(void* ptr)
+{
+	adc_msg_free((struct adc_message*) ptr);
+}
+
+void user_destroy(struct user* user)
+{
+	hub_log(log_trace, "user_destroy(), user=%p", user);
+
+	user_trigger_shutdown(user);
+	net_close(user->sd);
+	adc_msg_free(user->info);
+	user_clear_feature_cast_support(user);
+	
+	if (user->recv_buf)
+	{
+		hub_free(user->recv_buf);
+	}
+	
+	if (user->send_queue)
+	{
+		list_clear(user->send_queue, &clear_send_queue_callback);
+		list_destroy(user->send_queue);
+	}
+	
+	hub_free(user);
+}
+
+void user_set_state(struct user* user, enum user_state state)
+{
+	if ((user->state == state_cleanup && state != state_disconnected) || (user->state == state_disconnected))
+	{
+		puts("PANIC - Ignoring new state");
+		return;
+	}
+	
+	user->state = state;
+}
+
+void user_set_info(struct user* user, struct adc_message* cmd)
+{
+	adc_msg_free(user->info);
+	user->info = adc_msg_incref(cmd);
+}
+
+
+static int convert_support_fourcc(int fourcc)
+{
+	switch (fourcc)
+	{
+		case FOURCC('B','A','S','0'): /* Obsolete */
+		case FOURCC('B','A','S','E'):
+			return feature_base;
+			
+		case FOURCC('A','U','T','0'):
+			return  feature_auto;
+		
+		case FOURCC('U','C','M','0'):
+		case FOURCC('U','C','M','D'):
+			return feature_ucmd;
+			
+		case FOURCC('Z','L','I','F'):
+			return feature_zlif;
+			
+		case FOURCC('B','B','S','0'):
+			return feature_bbs;
+			
+		case FOURCC('T','I','G','R'):
+			return feature_tiger;
+			
+		case FOURCC('B','L','O','M'):
+		case FOURCC('B','L','O','0'):
+			return feature_bloom;
+		
+		case FOURCC('P','I','N','G'):
+			return feature_ping;
+		
+		case FOURCC('L','I','N','K'):
+			return feature_link;
+		
+		default:
+			hub_log(log_debug, "Unknown extension: %x", fourcc);
+			return 0;
+	}
+}
+
+void user_support_add(struct user* user, int fourcc)
+{
+	int feature_mask = convert_support_fourcc(fourcc);
+	user->flags |= feature_mask;
+}
+
+int user_flag_get(struct user* user, enum user_flags flag)
+{
+    return user->flags & flag;
+}
+
+void user_flag_set(struct user* user, enum user_flags flag)
+{
+    user->flags |= flag;
+}
+
+void user_flag_unset(struct user* user, enum user_flags flag)
+{
+    user->flags &= ~flag;
+}
+
+void user_set_nat_override(struct user* user)
+{
+	user_flag_set(user, flag_nat);
+}
+
+int user_is_nat_override(struct user* user)
+{
+	return user_flag_get(user, flag_nat);
+}
+
+void user_support_remove(struct user* user, int fourcc)
+{
+	int feature_mask = convert_support_fourcc(fourcc);
+	user->flags &= ~feature_mask;
+}
+
+void user_schedule_destroy(struct user* user)
+{
+	struct event_data post;
+	memset(&post, 0, sizeof(post));
+	post.id     = UHUB_EVENT_USER_DESTROY;
+	post.ptr    = user;
+	event_queue_post(user->hub->queue, &post);
+}
+
+void user_disconnect(struct user* user, int reason)
+{
+	struct event_data post;
+	int need_notify = 0;
+	
+	if (user_is_disconnecting(user))
+	{
+		return;
+	}
+	
+	/* dont read more data from this user */
+	user_flag_set(user, flag_ignore);
+	
+	hub_log(log_trace, "user_disconnect(), user=%p, reason=%d, state=%d", user, reason, user->state);
+	
+	need_notify = user_is_logged_in(user);
+	user->quit_reason = reason;
+	user_set_state(user, state_cleanup);
+	
+	if (need_notify)
+	{
+		memset(&post, 0, sizeof(post));
+		post.id     = UHUB_EVENT_USER_QUIT;
+		post.ptr    = user;
+		event_queue_post(user->hub->queue, &post);
+	}
+	else
+	{
+		user->quit_reason = quit_unknown;
+		user_schedule_destroy(user);
+	}
+
+
+}
+
+int user_have_feature_cast_support(struct user* user, char feature[4])
+{
+	char* tmp = list_get_first(user->feature_cast);
+	while (tmp)
+	{
+		if (strncmp(tmp, feature, 4) == 0)
+			return 1;
+	
+		tmp = list_get_next(user->feature_cast);
+	}
+	
+	return 0;
+}
+
+int user_set_feature_cast_support(struct user* u, char feature[4])
+{
+	if (!u->feature_cast)
+	{
+		u->feature_cast = list_create();
+	}
+
+	if (!u->feature_cast)
+	{
+		return 0; /* OOM! */
+	}
+
+	list_append(u->feature_cast, hub_strndup(feature, 4));
+	return 1;
+}
+
+void user_clear_feature_cast_support(struct user* u)
+{
+	if (u->feature_cast)
+	{
+		list_clear(u->feature_cast, &hub_free);
+		list_destroy(u->feature_cast);
+		u->feature_cast = 0;
+	}
+}
+
+int user_is_logged_in(struct user* user)
+{
+	if (user->state == state_normal)
+		return 1;
+	return 0;
+}
+
+int user_is_connecting(struct user* user)
+{
+	if (user->state == state_protocol || user->state == state_identify || user->state == state_verify)
+		return 1;
+	return 0;
+}
+
+int user_is_disconnecting(struct user* user)
+{
+	if (user->state == state_cleanup || user->state == state_disconnected)
+		return 1;
+	return 0;
+}
+
+void user_trigger_init(struct user* user)
+{
+	if (user->ev_handle)
+	{
+		struct timeval timeout = { TIMEOUT_CONNECTED, 0 };
+		event_set(user->ev_handle, user->sd, EV_READ | EV_PERSIST, on_net_event, user);
+		event_base_set(user->hub->evbase, user->ev_handle);
+		event_add(user->ev_handle, &timeout);
+	}
+}
+
+void user_trigger_update(struct user* user, int w, int timeout_sec)
+{
+	if (user->ev_handle)
+	{
+		struct timeval timeout = { timeout_sec, 0 };
+		int f = w ? EV_WRITE | EV_READ | EV_PERSIST : EV_READ | EV_PERSIST;
+		event_del(user->ev_handle);
+		event_set(user->ev_handle, user->sd, f, on_net_event, user);
+		event_base_set(user->hub->evbase, user->ev_handle);
+		event_add(user->ev_handle, &timeout);
+	}
+}
+
+void user_trigger_shutdown(struct user* user)
+{
+	if (user->ev_handle)
+	{
+		event_del(user->ev_handle);
+		hub_free(user->ev_handle);
+		user->ev_handle = 0;
+	}
+}

src/user.h

@@ -20,8 +20,9 @@
 #ifndef HAVE_UHUB_USER_H
 #define HAVE_UHUB_USER_H
 
+
 struct hub_info;
-struct hub_iobuf;
+
 
 enum user_state
 {
@@ -33,6 +34,7 @@ enum user_state
 	state_disconnected = 5,      /**<< "User is disconnected" */
 };
 
+
 enum user_flags
 {
 	feature_base    = 0x00000001, /** BASE: Basic configuration (required by all clients) */
@@ -44,17 +46,16 @@ enum user_flags
 	feature_bloom   = 0x00000040, /** BLO0: Bloom filter (not supported) */
 	feature_ping    = 0x00000080, /** PING: Hub pinger information extension */
 	feature_link    = 0x00000100, /** LINK: Hub link (not supported) */
-	feature_adcs    = 0x00000200, /** ADCS: ADC over TLS/SSL */
 	flag_ignore     = 0x01000000, /** Ignore further reads */
 	flag_maxbuf     = 0x02000000, /** Hit max buf read, ignore msg */
 	flag_choke      = 0x04000000, /** Choked: Cannot send, waiting for write event */ 
 	flag_want_read  = 0x08000000, /** Need to read (SSL) */
 	flag_want_write = 0x10000000, /** Need to write (SSL) */
 	flag_user_list  = 0x20000000, /** Send queue bypass (when receiving the send queue) */
-	flag_pipeline   = 0x40000000, /** Hub message pipelining */
+	flag_nat        = 0x40000000, /** nat override enabled */
-	flag_nat        = 0x80000000, /** nat override enabled */
 };
 
+
 enum user_quit_reason
 {
 	quit_unknown        = 0,
@@ -71,15 +72,12 @@ enum user_quit_reason
 	quit_ghost_timeout  = 11,    /** The user is a ghost, and trying to login from another connection */
 };
 
-/** Returns an apropriate string for the given quit reason */
-extern const char* user_get_quit_reason_string(enum user_quit_reason);
 
-struct hub_user_info
+struct 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 */
-	struct ip_addr_encap addr;    /** User's IP address */
 };
 
 /**
@@ -87,33 +85,44 @@ struct hub_user_info
  * as the number of bytes and files shared, and the number of hubs the
  * user is connected to, etc.
  */
-struct hub_user_limits
+struct user_counts
 {
-	uint64_t            shared_size;           /** Shared size in bytes */
+	uint64_t             shared_size;             /** Shared size in bytes */
-	size_t              shared_files;          /** The number of shared files */
+	size_t               shared_files;            /** The number of shared files */
-	size_t              upload_slots;          /** The number of upload slots */
+	size_t               upload_slots;            /** The number of upload slots */
-	size_t              hub_count_user;        /** The number of hubs connected as user */
+	size_t               hub_count_user;          /** The number of hubs connected as user */
-	size_t              hub_count_registered;  /** The number of hubs connected as registered user */
+	size_t               hub_count_registered;    /** The number of hubs connected as registered user */
-	size_t              hub_count_operator;    /** The number of hubs connected as operator */
+	size_t               hub_count_operator;      /** The number of hubs connected as operator */
-	size_t              hub_count_total;       /** The number of hubs connected to in total */
+	size_t               hub_count_total;         /** The number of hubs connected to in total */
 };
 
-struct hub_user
+struct user
 {
-	enum user_state         state;              /** see enum user_state */
+	int                  sd;                      /** socket descriptor */
-	enum user_credentials   credentials;        /** see enum user_credentials */
+	struct event*        ev_handle;
-	struct hub_user_info    id;                 /** Contains nick name and CID */
+	enum user_state      state;                   /** see enum user_state */
-	uint32_t                flags;              /** see enum user_features */
+	enum user_credentials credentials;            /** see enum user_credentials */
-	char                    user_agent[MAX_UA_LEN+1];/** User agent string */
+	struct user_info     id;                      /** Contains nick name and CID */
-	struct linked_list*     feature_cast;       /** Features supported by feature cast */
+	int                  flags;                   /** see enum user_features */
-	struct adc_message*     info;               /** ADC 'INF' message (broadcasted to everyone joining the hub) */
+	char                 user_agent[MAX_UA_LEN+1];/** User agent string */
-	struct hub_info*        hub;                /** The hub instance this user belong to */
+	time_t               tm_connected;            /** time when user connected */
-	struct hub_recvq*       recv_queue;
+	time_t               tm_last_read;            /** time the user last received something from the hub */
-	struct hub_sendq*       send_queue;
+	time_t               tm_last_write;           /** time the user last sent something to the hub */
-	struct net_connection*  connection;         /** Connection data */
+	struct linked_list*  feature_cast;            /** Features supported by feature cast */
-	struct hub_user_limits  limits;             /** Data used for limitation */
+	struct adc_message*  info;                    /** ADC 'INF' message (broadcasted to everyone joining the hub) */
-	enum user_quit_reason   quit_reason;        /** Quit reason (see user_quit_reason) */
+	size_t               send_queue_offset;       /** Send queue byte offset */
-
+	struct linked_list*  send_queue;              /** Send queue */
+	int                  send_queue_size;         /** Size of send queue (in bytes, not messages) */
+	int                  send_queue_esize;        /** Effective send queue size */
+	char*                recv_buf;                /** Recv buffer */
+	size_t               recv_buf_offset;         /** Recv buffer offset */
+	struct hub_info*     hub;                     /** The hub instance this user belong to */
+	int                  quit_reason;             /** Quit reason (see user_quit_reason) */
+	struct ip_addr_encap ipaddr;                  /** IP address of connected user */
+	struct user_counts   limits;                  /** Data used for limitation */
+#ifdef SSL_SUPPORT
+	SSL*                 ssl;                     /** SSL handle */
+#endif /*  SSL_SUPPORT */
 };
 
 
@@ -127,69 +136,64 @@ struct hub_user
  * @param sd socket descriptor associated with the user
  * @return User object or NULL if not enough memory is available.
  */
-extern struct hub_user* user_create(struct hub_info* hub, struct net_connection* con, struct ip_addr_encap* addr);
+extern struct user* user_create(struct hub_info* hub, int sd);
 
 /**
  * Delete a user.
  *
  * !WRONG! If the user is logged in a quit message is issued.
  */
-extern void user_destroy(struct hub_user* user);
+extern void user_destroy(struct user* user);
+
+/**
+ * Will post a message that will delete the user later.
+ */
+extern void user_schedule_destroy(struct user* user);
+
+/**
+ * Disconnect a user.
+ * This will mark the user connection ready for being terminated.
+ * A reason can be given using the enum user_quit_reason.
+ *
+ * Things to be done when calling this:
+ * - Mark the user with state_cleanup
+ *
+ * If the user is logged in to the hub:
+ * - post message: UHUB_EVENT_USER_QUIT
+ *
+ * @param user User to disconnect
+ * @param reason See enum user_quit_reason
+ */
+extern void user_disconnect(struct user* user, int reason);
 
 /**
  * This associates a INF message to the user.
  * If the user already has a INF message associated, then this is
  * released before setting the new one.
- * 
- * @param info new inf message (can be NULL)
  */
-extern void user_set_info(struct hub_user* user, struct adc_message* info);
+extern void user_set_info(struct user* user, struct adc_message* info);
-
-/**
- * Update a user's INF message.
- * Will parse replace all ellements in the user's inf message with
- * the parameters from the cmd (merge operation).
- */
-extern void user_update_info(struct hub_user* user, struct adc_message* cmd);
 
 /**
  * Specify a user's state.
  * NOTE: DON'T, unless you know what you are doing.
  */
-extern void user_set_state(struct hub_user* user, enum user_state);
+extern void user_set_state(struct user* user, enum user_state);
 
 /**
  * Returns 1 if the user is in state state_normal, or 0 otherwise.
  */
-extern int user_is_logged_in(struct hub_user* user);
+extern int user_is_logged_in(struct user* user);
-
-/**
- * Returns 1 if the user is in state_protocol.
- * Returns 0 otherwise.
- */
-extern int user_is_protocol_negotiating(struct hub_user* user);
 
 /**
  * Returns 1 if the user is in state_protocol, state_identify or state_verify.
  * Returns 0 otherwise.
  */
-extern int user_is_connecting(struct hub_user* user);
+extern int user_is_connecting(struct user* user);
 
 /**
  * Returns 1 only if the user is in state_cleanup or state_disconnected.
  */
-extern int user_is_disconnecting(struct hub_user* user);
+extern int user_is_disconnecting(struct user* user);
-
-/**
- * Returns 1 if a user is protected, which includes users
- * having any form of elevated privileges.
- */
-extern int user_is_protected(struct hub_user* user);
-
-/**
- * Returns 1 if a user is registered, with or without privileges.
- */
-extern int user_is_registered(struct hub_user* user);
 
 /**
  * User supports the protocol extension as given in fourcc.
@@ -199,7 +203,7 @@ extern int user_is_registered(struct hub_user* user);
  *
  * @see enum user_flags
  */
-extern void user_support_add(struct hub_user* user, int fourcc);
+extern void user_support_add(struct user* user, int fourcc);
 
 /**
  * User no longer supports the protocol extension as given in fourcc.
@@ -207,28 +211,26 @@ extern void user_support_add(struct hub_user* user, int fourcc);
  * the hub.
  * @see enum user_flags
  */
-extern void user_support_remove(struct hub_user* user, int fourcc);
+extern void user_support_remove(struct user* user, int fourcc);
-
-extern const char* user_get_address(struct hub_user* user);
 
 /**
  * Sets the nat override flag for a user, this allows users on the same
  * subnet as a natted hub to spoof their IP in order to use active mode
  * on a natted hub.
  */
-extern void user_set_nat_override(struct hub_user* user);
+extern void user_set_nat_override(struct user* user);
-extern int user_is_nat_override(struct hub_user* user);
+extern int user_is_nat_override(struct user* user);
 
 /**
  * Set a flag. @see enum user_flags
  */
-extern void user_flag_set(struct hub_user* user, enum user_flags flag);
+extern void user_flag_set(struct user* user, enum user_flags flag);
-extern void user_flag_unset(struct hub_user* user, enum user_flags flag);
+extern void user_flag_unset(struct user* user, enum user_flags flag);
 
 /**
  * Get a flag. @see enum user_flags
  */
-extern int user_flag_get(struct hub_user* user, enum user_flags flag);
+extern int user_flag_get(struct user* user, enum user_flags flag);
 
 /**
  * Check if a user supports 'feature' for feature casting (basis for 'Fxxx' messages)
@@ -238,7 +240,7 @@ extern int user_flag_get(struct hub_user* user, enum user_flags flag);
  * @param feature a feature to lookup (example: 'TCP4' or 'UDP4')
  * @return 1 if 'feature' supported, or 0 otherwise
  */
-extern int user_have_feature_cast_support(struct hub_user* user, char feature[4]);
+extern int user_have_feature_cast_support(struct user* user, char feature[4]);
 
 /**
  * Set feature cast support for feature.
@@ -246,22 +248,16 @@ extern int user_have_feature_cast_support(struct hub_user* user, char feature[4]
  * @param feature a feature to lookup (example: 'TCP4' or 'UDP4')
  * @return 1 if 'feature' supported, or 0 otherwise
  */
-extern int user_set_feature_cast_support(struct hub_user* u, char feature[4]);
+extern int user_set_feature_cast_support(struct user* u, char feature[4]);
 
 /**
  * Remove all feature cast support features.
  */
-extern void user_clear_feature_cast_support(struct hub_user* u);
+extern void user_clear_feature_cast_support(struct user* u);
 
-/**
+extern void user_trigger_init(struct user* user);
- * Mark the user with a want-write flag, meaning it should poll for writability.
+extern void user_trigger_update(struct user* user, int w, int timeout_sec);
- */
+extern void user_trigger_shutdown(struct user* user);
-extern void user_net_io_want_write(struct hub_user* user);
-
-/**
- * Mark the user with a want read flag, meaning it should poll for readability.
- */
-extern void user_net_io_want_read(struct hub_user* user);
 
 #endif /* HAVE_UHUB_USER_H */
 

src/usermanager.c

@@ -0,0 +1,234 @@
+/*
+ * uhub - A tiny ADC p2p connection hub
+ * Copyright (C) 2007-2009, 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"
+
+/*
+ * This callback function is used to clear user objects from the userlist.
+ * Should only be used in user_manager_shutdown().
+ */
+static void clear_user_list_callback(void* ptr)
+{
+	if (ptr)
+	{
+		struct user* u = (struct user*) ptr;
+		
+		/* Mark the user as already being disconnected.
+		 * This prevents the hub from trying to send
+		 * quit messages to other users.
+		 */
+		u->credentials = cred_none;
+		user_destroy(u);
+	}
+}
+
+
+void user_manager_update_stats(struct hub_info* hub)
+{
+	const int factor = TIMEOUT_STATS;
+	struct net_statistics* total;
+	struct net_statistics* intermediate;
+	net_stats_get(&intermediate, &total);
+
+	hub->stats.net_tx = (intermediate->tx / factor);
+	hub->stats.net_rx = (intermediate->rx / factor);
+	hub->stats.net_tx_peak = MAX(hub->stats.net_tx, hub->stats.net_tx_peak);
+	hub->stats.net_rx_peak = MAX(hub->stats.net_rx, hub->stats.net_rx_peak);
+	hub->stats.net_tx_total = total->tx;
+	hub->stats.net_rx_total = total->rx;
+	
+	net_stats_reset();
+}
+
+
+void user_manager_print_stats(struct hub_info* hub)
+{
+	hub_log(log_info, "Statistics  users=%zu (peak_users=%zu), net_tx=%d KB/s, net_rx=%d KB/s (peak_tx=%d KB/s, peak_rx=%d KB/s)",
+		hub->users->count,
+		hub->users->count_peak,
+		(int) hub->stats.net_tx / 1024,
+		(int) hub->stats.net_rx / 1024,
+		(int) hub->stats.net_tx_peak / 1024,
+		(int) hub->stats.net_rx_peak / 1024);
+}
+
+static void timer_statistics(int fd, short ev, void *arg)
+{
+	struct hub_info* hub = (struct hub_info*) arg;
+	struct timeval timeout = { TIMEOUT_STATS, 0 };
+	user_manager_update_stats(hub);
+	evtimer_set(&hub->ev_timer, timer_statistics, hub);
+	event_base_set(hub->evbase, &hub->ev_timer);
+	evtimer_add(&hub->ev_timer, &timeout);
+}
+
+
+int user_manager_init(struct hub_info* hub)
+{
+	struct user_manager* users = NULL;
+	struct timeval timeout = { TIMEOUT_STATS, 0 };
+
+	users = (struct user_manager*) hub_malloc_zero(sizeof(struct user_manager));
+
+	users->list = list_create();
+	users->free_sid = 1;
+	
+	if (!users->list)
+	{
+		list_destroy(users->list);
+		return -1;
+	}
+	
+	hub->users = users;
+	
+	evtimer_set(&hub->ev_timer, timer_statistics, hub);
+	event_base_set(hub->evbase, &hub->ev_timer);
+	evtimer_add(&hub->ev_timer, &timeout);
+	return 0;
+}
+
+
+void user_manager_shutdown(struct hub_info* hub)
+{
+	struct user_manager* users = hub->users;
+	event_del(&hub->ev_timer);
+
+	list_clear(users->list, &clear_user_list_callback);
+	list_destroy(users->list);
+	hub_free(hub->users);
+}
+
+
+void user_manager_add(struct user* user)
+{
+	list_append(user->hub->users->list, user);
+	user->hub->users->count++;
+	user->hub->users->count_peak = MAX(user->hub->users->count, user->hub->users->count_peak);
+
+	user->hub->users->shared_size  += user->limits.shared_size;
+	user->hub->users->shared_files += user->limits.shared_files;
+}
+
+void user_manager_remove(struct user* user)
+{
+	list_remove(user->hub->users->list, user);
+	user->hub->users->count--;
+	
+	user->hub->users->shared_size  -= user->limits.shared_size;
+	user->hub->users->shared_files -= user->limits.shared_files;
+}
+
+
+struct user* get_user_by_sid(struct hub_info* hub, sid_t sid)
+{
+	struct user* user = (struct user*) list_get_first(hub->users->list); /* iterate users */
+	while (user)
+	{
+		if (user->id.sid == sid)
+			return user;
+		user = (struct user*) list_get_next(hub->users->list);
+	}
+	return NULL;
+}
+
+
+struct user* get_user_by_cid(struct hub_info* hub, const char* cid)
+{
+	struct user* user = (struct user*) list_get_first(hub->users->list); /* iterate users - only on incoming INF msg */
+	while (user)
+	{
+		if (strcmp(user->id.cid, cid) == 0)
+			return user;
+		user = (struct user*) list_get_next(hub->users->list);
+	}
+	return NULL;
+}
+
+
+struct user* get_user_by_nick(struct hub_info* hub, const char* nick)
+{
+	struct user* user = (struct user*) list_get_first(hub->users->list); /* iterate users - only on incoming INF msg */
+	while (user)
+	{
+		if (strcmp(user->id.nick, nick) == 0)
+			return user;
+		user = (struct user*) list_get_next(hub->users->list);
+	}
+	return NULL;
+}
+
+
+int send_user_list(struct user* target)
+{
+	int ret = 1;
+	user_flag_set(target, flag_user_list);
+	struct user* user = (struct user*) list_get_first(target->hub->users->list); /* iterate users - only on INF or PAS msg */
+	while (user)
+	{
+		if (user_is_logged_in(user))
+		{
+			ret = route_to_user(target, user->info);
+			if (!ret)
+				break;
+		}
+		user = (struct user*) list_get_next(user->hub->users->list);
+	}
+	
+	if (!target->send_queue_size)
+	{
+	    user_flag_unset(target, flag_user_list);
+	}
+	return ret;
+}
+
+
+void send_quit_message(struct user* leaving)
+{
+	struct adc_message* command = adc_msg_construct(ADC_CMD_IQUI, 6);
+	adc_msg_add_argument(command, (const char*) sid_to_string(leaving->id.sid));
+	
+	if (leaving->quit_reason == quit_banned || leaving->quit_reason == quit_kicked)
+	{
+		adc_msg_add_argument(command, ADC_QUI_FLAG_DISCONNECT);
+	}
+	
+	route_to_all(leaving->hub, command);
+	adc_msg_free(command);
+}
+
+
+sid_t user_manager_get_free_sid(struct hub_info* hub)
+{
+#if 0
+	struct user* user;
+	user = (struct user*) list_get_first(hub->users->list); /* iterate normal users */
+	while (user)
+	{
+		if (user->sid == hub->users->free_sid)
+		{
+			hub->users->free_sid++;
+			if (hub->users->free_sid >= SID_MAX) hub->users->free_sid = 1;
+			break;
+		}
+		user = (struct user*) list_get_next(hub->users->list);
+	}
+#endif
+	return hub->users->free_sid++;
+}
+

src/usermanager.h

@@ -20,91 +20,69 @@
 #ifndef HAVE_UHUB_USER_MANAGER_H
 #define HAVE_UHUB_USER_MANAGER_H
 
-struct hub_user_manager
+struct user_manager
 {
 	size_t count;                   /**<< "Number of all fully connected and logged in users" */
 	size_t count_peak;              /**<< "Peak number of users" */
-	struct sid_pool* sids;
+	sid_t free_sid;                 /**<< "The next available SID." */
 	uint64_t shared_size;           /**<< "The total number of shared bytes among fully connected users." */
 	uint64_t shared_files;          /**<< "The total number of shared files among fully connected users." */
-	struct linked_list* list;       /**<< "Contains all logged in users" */
+	struct linked_list* list;       /**<< "Contains all users" */
 };
 
 /**
  * Initializes the user manager.
  * @return 0 on success, or -1 if error (out of memory).
  */
-extern int uman_init(struct hub_info* hub);
+extern int user_manager_init(struct hub_info* hub);
 
 /**
  * Shuts down the user manager.
  * All users will be disconnected and deleted as part of this.
- *
- * @return 0 on success, or -1 in an error occured (hub is invalid).
  */
-extern int uman_shutdown(struct hub_info* hub);
+extern void user_manager_shutdown(struct hub_info* hub);
 
 /**
  * Generate statistics for logfiles.
  */
-extern void uman_update_stats(struct hub_info* hub);
+extern void user_manager_update_stats(struct hub_info* hub);
-extern void uman_print_stats(struct hub_info* hub);
+extern void user_manager_print_stats(struct hub_info* hub);
 
 /**
- * Add a user to the user manager.
+ * Add a new user to the user manager.
- *
- * @param hub The hub to add the user to
- * @param user The user to be added to the hub.
  */
-extern int uman_add(struct hub_info* hub, struct hub_user* user);
+extern void user_manager_add(struct user* user);
 
 /**
  * Remove a user from the user manager.
  * This user is connected, and will be moved to the leaving queue, pending
  * all messages in the message queue, and resource cleanup.
- *
- * @return 0 if successfully removed, -1 if error.
  */
-extern int uman_remove(struct hub_info* hub, struct hub_user* user);
+extern void user_manager_remove(struct user* user);
 
 /**
- * Returns and allocates an unused session ID (SID).
+ * Returns a free sid for a new user.
  */
-extern sid_t uman_get_free_sid(struct hub_info* hub, struct hub_user* user);
+extern sid_t user_manager_get_free_sid(struct hub_info* hub);
 
 /**
- * Lookup a user based on the session ID (SID).
+ * Lookup a user based on the session ID (sid).
- *
+ * NOTE: This will only search connected users.
- * NOTE: This function will only search connected users, which means
- * that SIDs assigned to users who are not yet completely logged in,
- * or are in the process of being disconnected will result in this 
- * function returning NULL even though the sid is not freely available.
- *
- * FIXME: Is that really safe / sensible ?
- * - Makes sense from a message routing point of view.
- *
  * @return a user if found, or NULL if not found
  */
-extern struct hub_user* uman_get_user_by_sid(struct hub_info* hub, sid_t sid);
+extern struct user* get_user_by_sid(struct hub_info* hub, sid_t sid);
 
 /**
- * Lookup a user based on the client ID (CID).
+ * Lookup a user based on the client ID (cid).
  * @return a user if found, or NULL if not found
  */
-extern struct hub_user* uman_get_user_by_cid(struct hub_info* hub, const char* cid);
+extern struct user* get_user_by_cid(struct hub_info* hub, const char* cid);
 
 /**
  * Lookup a user based on the nick name.
  * @return a user if found, or NULL if not found
  */
-extern struct hub_user* uman_get_user_by_nick(struct hub_info* hub, const char* nick);
+extern struct user* get_user_by_nick(struct hub_info* hub, const char* nick);
-
-/**
- * Lookup users based on an ip address range.
- *
- * @return The number of users matching the addressess, or -1 on error (mask is wrong).
- */
-extern size_t uman_get_user_by_addr(struct hub_info* hub, struct linked_list* users, struct ip_range* range);
 
 /**
  * Send the user list of connected clients to 'user'.
@@ -112,13 +90,13 @@ extern size_t uman_get_user_by_addr(struct hub_info* hub, struct linked_list* us
  *
  * @return 1 if sending the user list succeeded, 0 otherwise.
  */
-extern int uman_send_user_list(struct hub_info* hub, struct hub_user* user);
+extern int send_user_list(struct user* user);
 
 /**
  * Send a quit message to all connected users when 'user' is
  * leaving the hub (for whatever reason).
  */
-extern void uman_send_quit_message(struct hub_info* hub, struct hub_user* user);
+extern void send_quit_message(struct user* user);
 
 
 #endif /* HAVE_UHUB_USER_MANAGER_H */

src/util/rbtree.c

@@ -1,137 +0,0 @@
-/*
- * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, 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/>.
- *
- */
-
-#if 0
-
-#include <sys/types.h>
-#include "rbtree.h"
-
-#define RED   0
-#define BLACK 1
-
-struct rb_node
-{
-	const void* key;
-	const void* value; /* data */
-	int color;
-	struct rb_node* parent;
-	struct rb_node* left;
-	struct rb_node* right;
-};
-
-struct rb_tree
-{
-	struct rb_node* root;
-	size_t elements;
-	rb_tree_alloc alloc;
-	rb_tree_free free;
-	rb_tree_compare compare;
-};
-
-/* returns the grandparent of a node, if it exits */
-static inline struct rb_node* get_grandparent(struct rb_node* n)
-{
-	if (n->parent)
-		return n->parent->parent;
-	return 0;
-}
-
-static struct rb_node* get_uncle(struct rb_node* n)
-{
-	struct rb_node* gparent = n->parent ? n->parent->parent : 0;
-	if (gparent)
-		return (n->parent == gparent->left) ? gparent->right : gparent->left;
-	return 0;
-}
-
-static struct rb_node* tree_search(struct rb_tree* tree, const void* key)
-{
-	struct rb_node* node = tree->root;
-	while (node)
-	{
-		int res = tree->compare(key, node->key);
-		if (res < 0)      node = node->left;
-		else if (res > 0) node = node->right;
-		else              return node;
-	}
-	return 0;
-}
-
-static struct rb_node* tree_insert(struct rb_tree* tree, const void* key, const void* value)
-{
-	struct rb_node* node = tree->root;
-	struct rb_node* newnode = tree->alloc(sizeof(struct rb_node));
-	newnode->key = key;
-	newnode->value = value;
-	newnode->color = RED;
-	
-
-	while (node)
-	{
-		int res = tree->compare(key, node->key);
-		if (res < 0)      node = node->left;
-		else if (res > 0) node = node->right;
-		else
-		{
-			/* key already exists in tree */
-			return node;
-		}
-	}
-
-	return newnode;
-}
-
-
-struct rb_tree* rb_tree_create(rb_tree_compare compare, rb_tree_alloc a, rb_tree_free f)
-{
-	struct rb_tree* tree = a(sizeof(struct rb_tree));
-	tree->compare = compare;
-	tree->alloc = a;
-	tree->free = f;
-	return tree;
-}
-
-void rb_tree_destroy(struct rb_tree* tree)
-{
-	rb_tree_free f = tree->free;
-	f(tree);
-}
-
-void* rb_tree_insert(struct rb_tree* tree, const void* key, const void* value)
-{
-	struct rb_node* node = tree_insert(tree, key, value);
-	if (node)
-		return (void*) node->value;
-	return 0;
-}
-
-void* rb_tree_remove(struct rb_tree* tree, const void* key)
-{
-
-}
-
-void* rb_tree_get(struct rb_tree* tree, const void* key)
-{
-	struct rb_node* node = tree_search(tree, key);
-	if (node)
-		return node->value;
-	return 0;
-}
-
-#endif

src/util/rbtree.h

@@ -1,38 +0,0 @@
-/*
- * uhub - A tiny ADC p2p connection hub
- * Copyright (C) 2007-2009, 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_RED_BLACK_TREE_H
-#define HAVE_UHUB_RED_BLACK_TREE_H
-
-struct rb_tree;
-typedef int (*rb_tree_compare)(const void* a, const void* b);
-typedef void* (*rb_tree_alloc)(size_t);
-typedef void (*rb_tree_free)(void*);
-
-
-extern struct rb_tree* rb_tree_create(rb_tree_compare, rb_tree_alloc, rb_tree_free);
-extern void rb_tree_destroy(struct rb_tree*);
-
-extern void* rb_tree_insert(struct rb_tree* tree, const void* key, const void* data);
-extern void* rb_tree_remove(struct rb_tree* tree, const void* key);
-extern void* rb_tree_get(struct rb_tree* tree, const void* key); 
-
-
-#endif /* HAVE_UHUB_RED_BLACK_TREE_H */
-

src/util/timeout.c

@@ -1,126 +0,0 @@
-/*
- * 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 wtimeout_evtith this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#include "uhub.h"
-#include "util/timeout.h"
-
-void timeout_evt_initialize(struct timeout_evt* t, timeout_evt_cb cb, void* ptr)
-{
-	t->callback = cb;
-	t->ptr = ptr;
-	t->prev = 0;
-	t->next = 0;
-}
-
-void timeout_evt_reset(struct timeout_evt* t)
-{
-	t->prev = 0;
-	t->next = 0;
-}
-
-int timeout_evt_is_scheduled(struct timeout_evt* t)
-{
-	if (!t) return 0;
-	return !!t->prev;
-}
-
-void timeout_queue_initialize(struct timeout_queue* t, time_t now, size_t max)
-{
-	t->last = now;
-	t->max = max;
-	t->events = hub_malloc_zero(max * sizeof(struct timeout_evt*));
-}
-
-void timeout_queue_shutdown(struct timeout_queue* t)
-{
-	hub_free(t->events);
-	t->events = 0;
-	t->max = 0;
-}
-
-size_t timeout_queue_process(struct timeout_queue* t, time_t now)
-{
-	size_t pos;
-	size_t events = 0;
-	struct timeout_evt* evt = 0;
-	for (pos = t->last; pos < now; pos++)
-	{
-		while ((evt = t->events[pos % t->max]))
-		{
-			timeout_queue_remove(t, evt);
-			timeout_evt_reset(evt);
-			evt->callback(evt);
-			events++;
-		}
-	}
-	t->last = now;
-	return events;
-}
-
-void timeout_queue_insert(struct timeout_queue* t, struct timeout_evt* evt, size_t seconds)
-{
-	struct timeout_evt* first;
-	size_t pos = ((t->last + seconds) % t->max);
-	evt->timestamp = t->last + seconds;
-	evt->next = 0;
-	
-	first = t->events[pos];
-	
-	if (!first)
-	{
-		t->events[pos] = evt;
-		evt->prev = evt;
-	}
-	else
-	{
-		evt->prev = first->prev;
-		first->prev = evt;
-	}
-}
-
-void timeout_queue_remove(struct timeout_queue* t, struct timeout_evt* evt)
-{
-	size_t pos = (evt->timestamp % t->max);
-	struct timeout_evt* first = t->events[pos];
-
-	if (!first)
-		return;
-
-	if (first == evt)
-	{
-		if (first->next)
-			first->next->prev = first->prev;
-		t->events[pos] = first->next;
-	}
-	else
-	{
-		evt->prev->next = evt->next;
-		if (evt->next)
-				evt->next->prev = evt->prev;
-		else
-				first->prev = evt->prev;
-	}
-}
-
-void timeout_queue_reschedule(struct timeout_queue* t, struct timeout_evt* evt, size_t seconds)
-{
-	if (timeout_evt_is_scheduled(evt))
-		timeout_queue_remove(t, evt);
-	timeout_queue_insert(t, evt, seconds);
-}

src/util/timeout.h

@@ -1,56 +0,0 @@
-/*
- * 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_TIMEOUT_HANDLER_H
-#define HAVE_UHUB_TIMEOUT_HANDLER_H
-
-struct timeout_evt;
-struct timeout_queue;
-
-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);
-
-#endif /* HAVE_UHUB_TIMEOUT_HANDLER_H */

tools/adc-redirector

@@ -1,48 +0,0 @@
-#!/usr/bin/perl -w
-
-# Setup using inetd/xinetd or similar.
-# In /etc/inetd.conf add:
-# 1511  stream  tcp nowait nobody  /usr/bin/adc-redirector adc://target:port
-#
-# Change port to whatever you want.
-# Make sure the path and the target:port is correct, then you should be good 
-# to go!
-
-use strict;
-use IO::Handle;
-autoflush STDIN;
-autoflush STDOUT;
-
-my $target = $ARGV[0];
-
-eval
-{
-	local %SIG;
-	$SIG{ALRM}= sub { exit 0; };
-        alarm 30;
-};
-
-while (my $line = <STDIN>)
-{
-	chomp($line);
-
-	if ($line =~ /^HSUP /)
-	{
-		print "ISUP ADBASE ADPING ADTIGR\n";
-		print "ISID AAAX\n";
-		print "IINF CT32 NIRedirector VEadc-redirector/0.1\n";
-		next;
-	}
-
-	if ($line =~ /^BINF /)
-	{
-		print "$line\n";
-		print "IMSG This\\sserver\\shas\\smoved\\sto:\\s" . $target . "\n";
-		print "IMSG You\\sare\\sbeing\\sredirected...\n";
-		print "IQUI AAAX RD" . $target . "\n";
-		alarm 5;
-	}
-}
-
-alarm 0;
-

version.h

@@ -2,14 +2,12 @@
 #define PRODUCT "uHub"
 #endif
 
-#ifndef GIT_REVISION
+#ifndef PRODUCT_TITLE
-#define REVISION ""
+#define PRODUCT_TITLE "(micro-Hub)"
-#else
-#define REVISION " (git: " GIT_REVISION ")"
 #endif
 
 #ifndef VERSION
-#define VERSION "0.3.0-rc4" REVISION
+#define VERSION "0.2.8"
 #endif
 
 #ifndef COPYRIGHT