Work in progress: libevent use one event per fd.

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

GNUmakefile

@@ -144,7 +144,6 @@ libuhub_SOURCES := \
 		src/misc.c \
 		src/netevent.c \
 		src/network.c \
-		src/rbtree.c \
 		src/route.c \
 		src/sid.c \
 		src/tiger.c \
@@ -172,7 +171,6 @@ uhub_HEADERS := \
 		src/misc.h \
 		src/netevent.h \
 		src/network.h \
-		src/rbtree.h \
 		src/route.h \
 		src/sid.h \
 		src/tiger.h \
@@ -189,7 +187,6 @@ 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

autotest/test_inf.tcc

@@ -8,7 +8,7 @@
 static struct user* inf_user       = 0;
 static struct hub_info* inf_hub    = 0;
 
-extern int hub_handle_info_login(struct hub_info* hub, struct user* user, struct adc_message* cmd);
+extern int hub_handle_info_login(struct user* user, struct adc_message* cmd);
 
 static void inf_create_hub()
 {
@@ -27,13 +27,6 @@ static void inf_create_hub()
 static void inf_destroy_hub()
 {
 	/* FIXME */
-	list_destroy(inf_hub->users->list);
-	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);
 }
 
 
@@ -43,6 +36,7 @@ static void inf_create_user()
 	inf_user = (struct user*) hub_malloc_zero(sizeof(struct user));
 	inf_user->id.sid = 1;
 	inf_user->sd  = -1;
+	inf_user->hub = inf_hub;
 	inf_user->limits.upload_slots = 1;
 }
 
@@ -61,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;
 	
 
@@ -112,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_message.tcc

@@ -17,11 +17,6 @@ static void create_test_user()
 	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;
@@ -35,6 +30,7 @@ EXO_TEST(adc_message_parse_2, {
 });
 
 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);
@@ -512,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;
@@ -549,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;
-});
-
-

src/commands.c

@@ -19,7 +19,7 @@
 
 #include "uhub.h"
 
-typedef int (*command_handler)(struct hub_info* hub, struct user* user, const char* message);
+typedef int (*command_handler)(struct user* user, const char* message);
 
 struct commands_handler
 {
@@ -32,7 +32,7 @@ struct commands_handler
 
 static struct commands_handler command_handlers[];
 
-static void send_message(struct hub_info* hub, struct user* user, const char* message)
+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);
@@ -42,73 +42,60 @@ static void send_message(struct hub_info* hub, struct user* user, const char* me
 	hub_free(buffer);
 }
 
-static int command_access_denied(struct hub_info* hub, struct user* user, const char* command)
+static int command_access_denied(struct user* user, const char* command)
 {
-	char temp[128];
+	char temp[64];
-	snprintf(temp, 128, "*** Access denied: \"%s\"", command);
+	snprintf(temp, 64, "*** Access denied: \"%s\"", command);
-	send_message(hub, user, temp);
+	send_message(user, temp);
 	return 0;
 }
 
-static int command_not_found(struct hub_info* hub, struct user* user, const char* command)
+
+static int command_stats(struct user* user, const char* message)
 {
 	char temp[128];
-	snprintf(temp, 128, "*** Command not found: \"%s\"", command);
+	snprintf(temp, 128, "*** Stats: %zu users, peak: %zu. Network (up/down): %d/%d KB/s, peak: %d/%d KB/s",
-	send_message(hub, user, temp);
+	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_status(struct hub_info* hub, struct user* user, const char* command, const char* message)
-{
-	char temp[1024];
-	snprintf(temp, 1024, "*** %s: %s", command, message);
-	send_message(hub, user, temp);
-	return 0;
-}
 
-static int command_stats(struct hub_info* hub, struct user* user, const char* message)
+static int command_help(struct user* user, const char* message)
-{
-	char temp[128];
-	snprintf(temp, 128, "%zu users, peak: %zu. 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, "stats", message);
-}
-
-static int command_help(struct hub_info* hub, struct user* user, const char* message)
 {
 #define MAX_HELP_MSG 1024
 	size_t n;
 	char msg[MAX_HELP_MSG];
 	msg[0] = 0;
-	strcat(msg, "Available commands:\n");
+	strcat(msg, "\n*** 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, "help", msg);
+	send_message(user, msg);
+    return 0;
 }
 
-static int command_uptime(struct hub_info* hub, struct user* user, const char* message)
+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), hub->tm_started);
+	size_t D = (size_t) difftime(time(0), user->hub->tm_started);
 
 	d = D / (24 * 3600);
 	D = D % (24 * 3600);
@@ -117,6 +104,8 @@ static int command_uptime(struct hub_info* hub, struct user* user, const char* m
 	m = D / 60;
 
 	tmp[0] = 0;
+	strcat(tmp, "*** Uptime: ");
+
 	if (d)
 	{
 		strcat(tmp, uhub_itoa((int) d));
@@ -131,58 +120,46 @@ static int command_uptime(struct hub_info* hub, struct user* user, const char* m
 	if (m < 10) strcat(tmp, "0");
 		strcat(tmp, uhub_itoa((int) m));
 
-	return command_status(hub, user, "uptime", tmp);
+	send_message(user, tmp);
+	return 0;
 }
 
-static int command_kick(struct hub_info* hub, struct user* user, const char* message)
+static int command_kick(struct user* user, const char* message)
 {
-	if (strlen(message) < 7)
+	send_message(user, "*** Kick not implemented!");
+	return 0;
+}
+
+static int command_reload(struct user* user, const char* message)
 {
-		return command_status(hub, user, "kick", "No nickname given");
+	send_message(user, "*** Reloading configuration");
+	user->hub->status = hub_status_restart;
+	return 0;
 }
 
-	const char* nick = &message[7];
+static int command_shutdown(struct user* user, const char* message)
-	struct user* target = uman_get_user_by_nick(hub, nick);
-	
-	if (!target)
 {
-		return command_status(hub, user, "kick", "No such user");
+	send_message(user, "*** Hub shuting down...");
+	user->hub->status = hub_status_shutdown;
+	return 0;
 }
 
-	if (target == user)
+
+static int command_version(struct user* user, const char* message)
 {
-		return command_status(hub, user, "kick", "Cannot kick yourself");
+    send_message(user, "*** Powered by " PRODUCT "/" VERSION);
+    return 0;
 }
 
-	user_disconnect(target, quit_kicked);
+static int command_myip(struct user* user, const char* message)
-	return command_status(hub, user, "kick", nick);
-}
-
-static int command_reload(struct hub_info* hub, struct user* user, const char* message)
-{
-	hub->status = hub_status_restart;
-	return command_status(hub, user, "reload", "Reloading configuration...");
-}
-
-static int command_shutdown(struct hub_info* hub, struct user* user, const char* message)
-{
-	hub->status = hub_status_shutdown;
-	return command_status(hub, user, "shutdown", "Hub shutting down...");
-}
-
-static int command_version(struct hub_info* hub, struct user* user, const char* message)
-{
-    return command_status(hub, user, "version", "Powered by " PRODUCT "/" VERSION);
-}
-
-static int command_myip(struct hub_info* hub, struct user* user, const char* message)
 {
     char tmp[128];
-    snprintf(tmp, 128, "Your IP is \"%s\"", ip_convert_to_string(&user->ipaddr));
+    snprintf(tmp, 128, "*** Your IP: %s", ip_convert_to_string(&user->ipaddr));
-    return command_status(hub, user, "myip", tmp);
+    send_message(user, tmp);
+    return 0;
 }
 
-int command_dipatcher(struct hub_info* hub, struct user* user, const char* message)
+int command_dipatcher(struct user* user, const char* message)
 {
 	size_t n = 0;
 	for (n = 0; command_handlers[n].prefix; n++)
@@ -191,28 +168,26 @@ int command_dipatcher(struct hub_info* hub, struct user* user, const char* messa
 		{
 			if (command_handlers[n].cred <= user->credentials)
 			{
-				return command_handlers[n].handler(hub, user, message);
+				return command_handlers[n].handler(user, message);
 			}
 			else
 			{
-				return command_access_denied(hub, user, command_handlers[n].prefix);
+				return command_access_denied(user, &command_handlers[n].prefix[1]);
 			}
 		}
 	}
-
-	command_not_found(hub, user, message);
 	return 1;
 }
 
 static struct commands_handler command_handlers[] = {
-	{ "help",       4, cred_guest,     command_help,     "Show this help message."      },
+	{ "!help",       5, cred_guest,     command_help,     "Show this help message." },
-	{ "stats",      5, cred_super,     command_stats,    "Show hub statistics."         },
+	{ "!stats",      6, cred_super,     command_stats,    "Show hub statistics." },
-	{ "version",    7, cred_guest,     command_version,  "Show hub version info."       },
+	{ "!version",    8, cred_guest,     command_version,  "Show hub version info."  },
-	{ "uptime",     6, cred_guest,     command_uptime,   "Display hub uptime info."     },
+	{ "!uptime",     7, cred_guest,     command_uptime,   "Display hub uptime info." },
-	{ "kick",       4, cred_operator,  command_kick,     "Kick a user"                  },
+	{ "!kick",       5, cred_operator,  command_kick,     "Kick a user" },
-	{ "reload",     6, cred_admin,     command_reload,   "Reload configuration files."  },
+	{ "!reload",     7, cred_admin,     command_reload,   "Reload configuration files." },
-	{ "shutdown",   8, cred_admin,     command_shutdown, "Shutdown hub."                },
+	{ "!shutdown",   9, cred_admin,     command_shutdown, "Shutdown hub." },
-	{ "myip",       4, cred_guest,     command_myip,     "Show your own IP."            },
+	{ "+myip",       5, cred_guest,     command_myip,     "Show your own IP." },
-	{ 0,            0, cred_none,      command_help,     ""                             }
+	{ 0,             0, cred_none,      command_help,     "{ Last dummy option }" }
 };
 

src/commands.h

@@ -32,4 +32,4 @@ struct command_info
 	plugin_event_chat_message function;
 };
 
-int command_dipatcher(struct hub_info* hub, struct user* user, const char* message);
+int command_dipatcher(struct user* user, const char* message);

src/config.c

@@ -464,11 +464,6 @@ static int config_parse_line(char* line, int line_count, void* ptr_data)
 	hub_log(log_trace, "config_parse_line(): '%s'", line);
 #endif
 
-	if (!is_valid_utf8(line))
-	{
-		hub_log(log_warning, "Invalid utf-8 characters on line %d", line_count);
-	}
-
 	if ((pos = strchr(line, '=')) != NULL)
 	{
 		pos[0] = 0;

src/hub.c

@@ -19,7 +19,7 @@
 
 #include "uhub.h"
 
-int hub_handle_message(struct hub_info* hub, struct user* u, const char* line, size_t length)
+int hub_handle_message(struct user* u, const char* line, size_t length)
 {
 	int ret = 0;
 	struct adc_message* cmd = 0;
@@ -36,9 +36,13 @@ int hub_handle_message(struct hub_info* hub, struct user* u, const char* line, s
 	{
 		switch (cmd->cmd)
 		{
-			case ADC_CMD_HSUP: ret = hub_handle_support(hub, u, cmd); break;
+			case ADC_CMD_HSUP: ret = hub_handle_support(u, cmd); break;
-			case ADC_CMD_HPAS: ret = hub_handle_password(hub, u, cmd); break;
+			case ADC_CMD_HPAS: ret = hub_handle_password(u, cmd); break;
-			case ADC_CMD_BINF: ret = hub_handle_info(hub, u, cmd); break;
+			case ADC_CMD_BINF: ret = hub_handle_info(u, cmd); break;
+
+#ifdef ADC_UDP_OPERATION
+			case ADC_CMD_HCHK: ret = hub_handle_autocheck(u, cmd); break;
+#endif
 			case ADC_CMD_DINF:
 			case ADC_CMD_EINF:
 			case ADC_CMD_FINF:
@@ -50,7 +54,7 @@ int hub_handle_message(struct hub_info* hub, struct user* u, const char* line, s
 			case ADC_CMD_DMSG:
 			case ADC_CMD_BMSG:
 			case ADC_CMD_FMSG:
-				ret = hub_handle_chat_message(hub, u, cmd);
+				ret = hub_handle_chat_message(u, cmd);
 				break;
 
 			case ADC_CMD_BSCH:
@@ -61,7 +65,7 @@ int hub_handle_message(struct hub_info* hub, struct user* u, const char* line, s
 			case ADC_CMD_DRCM:
 			case ADC_CMD_DCTM:
 				cmd->priority = -1;
-				if (hub->config->chat_only && u->credentials < cred_operator)
+				if (u->hub->config->chat_only && u->credentials < cred_operator)
 				{
 					/* These below aren't allowed in chat only hubs */
 					break;
@@ -92,7 +96,7 @@ int hub_handle_message(struct hub_info* hub, struct user* u, const char* line, s
 }
 
 
-int hub_handle_support(struct hub_info* hub, struct user* u, struct adc_message* cmd)
+int hub_handle_support(struct user* u, struct adc_message* cmd)
 {
 	int ret = 0;
 	int index = 0;
@@ -100,9 +104,9 @@ int hub_handle_support(struct hub_info* hub, struct user* u, struct adc_message*
 	char* arg = adc_msg_get_argument(cmd, index);
 	struct timeval timeout = { TIMEOUT_HANDSHAKE, 0 };
 
-	if (hub->status == hub_status_disabled && u->state == state_protocol)
+	if (u->hub->status == hub_status_disabled && u->state == state_protocol)
 	{
-		on_login_failure(hub, u, status_msg_hub_disabled);
+		on_login_failure(u, status_msg_hub_disabled);
 		return -1;
 	}
 	
@@ -141,9 +145,9 @@ int hub_handle_support(struct hub_info* hub, struct user* u, struct adc_message*
 	
 		if (ok)
 		{
-			hub_send_handshake(hub, u);
+			hub_send_handshake(u);
-			if (u->ev_read)
+			if (u->ev_handle)
-				event_add(u->ev_read, &timeout);
+				event_add(u->ev_handle, &timeout);
 		}
 		else
 		{
@@ -157,7 +161,7 @@ int hub_handle_support(struct hub_info* hub, struct user* u, struct adc_message*
 }
 
 
-int hub_handle_password(struct hub_info* hub, struct user* u, struct adc_message* cmd)
+int hub_handle_password(struct user* u, struct adc_message* cmd)
 {
 	char* password = adc_msg_get_argument(cmd, 0);
 	int ret = 0;
@@ -166,11 +170,11 @@ int hub_handle_password(struct hub_info* hub, struct user* u, struct adc_message
 	{
 		if (password_verify(u, password))
 		{
-			on_login_success(hub, u);
+			on_login_success(u);
 		}
 		else
 		{
-			on_login_failure(hub, u, status_msg_auth_invalid_password);
+			on_login_failure(u, status_msg_auth_invalid_password);
 			ret = -1;
 		}
 	}
@@ -180,7 +184,7 @@ int hub_handle_password(struct hub_info* hub, struct user* u, struct adc_message
 }
 
 
-int hub_handle_chat_message(struct hub_info* hub, struct user* u, struct adc_message* cmd)
+int hub_handle_chat_message(struct user* u, struct adc_message* cmd)
 {
 	char* message = adc_msg_get_argument(cmd, 0);
 	int ret = 0;
@@ -189,7 +193,7 @@ int hub_handle_chat_message(struct hub_info* hub, struct user* u, struct adc_mes
 	/* TODO: Check for hub-commands here. Set relay to 0 and the message will not be sent to other users. */
 	if (message[0] == '!' || message[0] == '+')
 	{
-	    relay = command_dipatcher(hub, u, message);
+	    relay = command_dipatcher(u, message);
 	}
 
 	if (relay && user_is_logged_in(u))
@@ -202,22 +206,67 @@ int hub_handle_chat_message(struct hub_info* hub, struct user* u, struct adc_mes
 	return ret;
 }
 
-void hub_send_support(struct hub_info* hub, struct user* u)
+int on_kick(struct user* u, struct adc_message* cmd)
+{
+	hub_log(log_error, "on_kick() not implemented");
+	return -1;
+}
+
+#ifdef ADC_UDP_OPERATION
+int hub_handle_autocheck(struct user* u, struct adc_message* cmd)
+{
+	char* port_str = adc_msg_get_argument(cmd, 0);
+	char* token    = adc_msg_get_argument(cmd, 1);
+	int port = 0;
+	
+	if (!port_str || !token || strlen(token) != 4)
+	{
+		hub_free(port_str);
+		hub_free(token);
+		return -1;
+	}
+	
+	port = uhub_atoi(port_str);
+	
+	if (port == 0 || port > 65535)
+	{
+		hub_free(port_str);
+		hub_free(token);
+		return -1;
+	}
+	
+	hub_send_autocheck(u, port, token);
+	
+	hub_free(port_str);
+	hub_free(token);
+	
+	return 0;
+}
+#endif
+
+
+void hub_send_autocheck(struct user* u, uint16_t port, const char* token)
+{
+	
+}
+
+
+void hub_send_support(struct user* u)
 {
 	if (user_is_connecting(u) || user_is_logged_in(u))
 	{
-		route_to_user(u, hub->command_support);
+		route_to_user(u, u->hub->command_support);
 	}
 }
 
 
-void hub_send_sid(struct hub_info* hub, struct user* u)
+void hub_send_sid(struct user* u)
 {
 	struct adc_message* command;
 	if (user_is_connecting(u))
 	{
 		command = adc_msg_construct(ADC_CMD_ISID, 10);
-		u->id.sid = uman_get_free_sid(hub);
+		u->id.sid = user_manager_get_free_sid(u->hub);
 		adc_msg_add_argument(command, (const char*) sid_to_string(u->id.sid));
 		route_to_user(u, command);
 		adc_msg_free(command);
@@ -225,7 +274,7 @@ void hub_send_sid(struct hub_info* hub, struct user* u)
 }
 
 
-void hub_send_ping(struct hub_info* hub, struct user* user)
+void hub_send_ping(struct user* user)
 {
 	/* This will just send a newline, despite appearing to do more below. */
 	struct adc_message* ping = adc_msg_construct(0, 0);
@@ -238,9 +287,9 @@ void hub_send_ping(struct hub_info* hub, struct user* user)
 }
 
 
-void hub_send_hubinfo(struct hub_info* hub, struct user* u)
+void hub_send_hubinfo(struct user* u)
 {
-	struct adc_message* info = adc_msg_copy(hub->command_info);
+	struct adc_message* info = adc_msg_copy(u->hub->command_info);
 	int value = 0;
 	
 	if (user_flag_get(u, feature_ping))
@@ -252,43 +301,43 @@ void hub_send_hubinfo(struct hub_info* hub, struct user* u)
 		NE - Hub Network
 		OW - Hub Owner name
 */
-		adc_msg_add_named_argument(info, "UC", uhub_itoa(hub_get_user_count(hub)));
+		adc_msg_add_named_argument(info, "UC", uhub_itoa(hub_get_user_count(u->hub)));
-		adc_msg_add_named_argument(info, "MC", uhub_itoa(hub_get_max_user_count(hub)));
+		adc_msg_add_named_argument(info, "MC", uhub_itoa(hub_get_max_user_count(u->hub)));
-		adc_msg_add_named_argument(info, "SS", uhub_ulltoa(hub_get_shared_size(hub)));
+		adc_msg_add_named_argument(info, "SS", uhub_ulltoa(hub_get_shared_size(u->hub)));
-		adc_msg_add_named_argument(info, "SF", uhub_itoa(hub_get_shared_files(hub)));
+		adc_msg_add_named_argument(info, "SF", uhub_itoa(hub_get_shared_files(u->hub)));
 		
 		/* Maximum/minimum share size */
-		value = hub_get_max_share(hub);
+		value = hub_get_max_share(u->hub);
 		if (value) adc_msg_add_named_argument(info, "XS", uhub_itoa(value));
-		value = hub_get_min_share(hub);
+		value = hub_get_min_share(u->hub);
 		if (value) adc_msg_add_named_argument(info, "MS", uhub_itoa(value));
 		
 		/* Maximum/minimum upload slots allowed per user */
-		value = hub_get_max_slots(hub);
+		value = hub_get_max_slots(u->hub);
 		if (value) adc_msg_add_named_argument(info, "XL", uhub_itoa(value));
-		value = hub_get_min_slots(hub);
+		value = hub_get_min_slots(u->hub);
 		if (value) adc_msg_add_named_argument(info, "ML", uhub_itoa(value));
 		
 		/* guest users must be on min/max hubs */
-		value = hub_get_max_hubs_user(hub);
+		value = hub_get_max_hubs_user(u->hub);
 		if (value) adc_msg_add_named_argument(info, "XU", uhub_itoa(value));
-		value = hub_get_min_hubs_user(hub);
+		value = hub_get_min_hubs_user(u->hub);
 		if (value) adc_msg_add_named_argument(info, "MU", uhub_itoa(value));
 		
 		/* registered users must be on min/max hubs */
-		value = hub_get_max_hubs_reg(hub);
+		value = hub_get_max_hubs_reg(u->hub);
 		if (value) adc_msg_add_named_argument(info, "XR", uhub_itoa(value));
-		value = hub_get_min_hubs_reg(hub);
+		value = hub_get_min_hubs_reg(u->hub);
 		if (value) adc_msg_add_named_argument(info, "MR", uhub_itoa(value));
 		
 		/* operators must be on min/max hubs */
-		value = hub_get_max_hubs_op(hub);
+		value = hub_get_max_hubs_op(u->hub);
 		if (value) adc_msg_add_named_argument(info, "XO", uhub_itoa(value));
-		value = hub_get_min_hubs_op(hub);
+		value = hub_get_min_hubs_op(u->hub);
 		if (value) adc_msg_add_named_argument(info, "MO", uhub_itoa(value));
 		
 		/* uptime in seconds */
-		adc_msg_add_named_argument(info, "UP", uhub_itoa((int) difftime(time(0), hub->tm_started)));
+		adc_msg_add_named_argument(info, "UP", uhub_itoa((int) difftime(time(0), u->hub->tm_started)));
 	}
 	
 	if (user_is_connecting(u) || user_is_logged_in(u))
@@ -298,17 +347,20 @@ void hub_send_hubinfo(struct hub_info* hub, struct user* u)
 	adc_msg_free(info);
 	
 	/* Only send banner when connecting */
-	if (hub->config->show_banner && user_is_connecting(u))
+	if (u->hub->config->show_banner && user_is_connecting(u))
 	{
-		route_to_user(u, hub->command_banner);
+		route_to_user(u, u->hub->command_banner);
-	}
 	}
 	
-void hub_send_handshake(struct hub_info* hub, struct user* u)
+	
+}
+
+
+void hub_send_handshake(struct user* u)
 {
-	hub_send_support(hub, u);
+	hub_send_support(u);
-	hub_send_sid(hub, u);
+	hub_send_sid(u);
-	hub_send_hubinfo(hub, u);
+	hub_send_hubinfo(u);
 
 	if (!user_is_disconnecting(u))
 	{
@@ -316,15 +368,17 @@ void hub_send_handshake(struct hub_info* hub, struct user* u)
 	}
 }
 
-void hub_send_motd(struct hub_info* hub, struct user* u)
+
+void hub_send_motd(struct user* u)
 {
-	if (hub->command_motd)
+	if (u->hub->command_motd)
 	{
-		route_to_user(u, hub->command_motd);
+		route_to_user(u, u->hub->command_motd);
 	}
 }
 
-void hub_send_password_challenge(struct hub_info* hub, struct user* u)
+
+void hub_send_password_challenge(struct user* u)
 {
 	struct adc_message* igpa;
 	igpa = adc_msg_construct(ADC_CMD_IGPA, 38);
@@ -336,8 +390,8 @@ void hub_send_password_challenge(struct hub_info* hub, struct user* u)
 
 static void hub_event_dispatcher(void* callback_data, struct event_data* message)
 {
-	struct hub_info* hub = (struct hub_info*) callback_data;
 /*
+	struct hub_info* hub = (struct hub_info*) callback_data;
 	hub_log(log_trace, "hub_event_dispatcher: %x (ptr=%p)", message->id, message->ptr);
 */
 	
@@ -350,20 +404,20 @@ static void hub_event_dispatcher(void* callback_data, struct event_data* message
 		
 			if (message->flags)
 			{
-				hub_send_password_challenge(hub, (struct user*) message->ptr);
+				hub_send_password_challenge((struct user*) message->ptr);
 			}
 			else
 			{
-				on_login_success(hub, (struct user*) message->ptr);
+				on_login_success((struct user*) message->ptr);
 			}
 			break;
 		}
 
 		case UHUB_EVENT_USER_QUIT:
 		{
-			uman_remove(hub, (struct user*) message->ptr);
+			user_manager_remove((struct user*) message->ptr);
-			uman_send_quit_message((struct user*) message->ptr);
+			send_quit_message((struct user*) message->ptr);
-			on_logout_user(hub, (struct user*) message->ptr);
+			on_logout_user((struct user*) message->ptr);
 			user_schedule_destroy((struct user*) message->ptr);
 			break;
 		}
@@ -385,9 +439,12 @@ static void hub_event_dispatcher(void* callback_data, struct event_data* message
 struct hub_info* hub_start_service(struct hub_config* config)
 {
 	struct hub_info* hub = 0;
+	int server_tcp, ret, ipv6_supported, af;
+#ifdef ADC_UDP_OPERATION
+	int server_udp;
+#endif
 	struct sockaddr_storage addr;
 	socklen_t sockaddr_size;
-	int server_tcp, ret, ipv6_supported, af;
 	char address_buf[INET6_ADDRSTRLEN+1];
 	
 	hub = hub_malloc_zero(sizeof(struct hub_info));
@@ -445,24 +502,66 @@ struct hub_info* hub_start_service(struct hub_config* config)
 		return 0;
 	}
 	
+#ifdef ADC_UDP_OPERATION
+	server_udp = net_socket_create(af, SOCK_DGRAM,  IPPROTO_UDP);
+	if (server_udp == -1)
+	{
+		event_base_free(hub->evbase);
+		hub_free(hub);
+		return 0;
+	}
+#endif
+	
 	ret = net_set_reuseaddress(server_tcp, 1);
 	if (ret == -1)
 	{
 		event_base_free(hub->evbase);
 		hub_free(hub);
 		net_close(server_tcp);
+#ifdef ADC_UDP_OPERATION
+		net_close(server_udp);
+#endif
 		return 0;
 	}
 	
+#ifdef ADC_UDP_OPERATION
+	ret = net_set_reuseaddress(server_udp, 1);
+	if (ret == -1)
+	{
+		event_base_free(hub->evbase);
+		hub_free(hub);
+		net_close(server_tcp);
+		net_close(server_udp);
+		return 0;
+	}
+#endif
+
+	
 	ret = net_set_nonblocking(server_tcp, 1);
 	if (ret == -1)
 	{
 		event_base_free(hub->evbase);
 		hub_free(hub);
 		net_close(server_tcp);
+#ifdef ADC_UDP_OPERATION
+		net_close(server_udp);
+#endif
 		return 0;
 	}
 	
+#ifdef ADC_UDP_OPERATION
+	ret = net_set_nonblocking(server_udp, 1);
+	if (ret == -1)
+	{
+		event_base_free(hub->evbase);
+		hub_free(hub);
+		net_close(server_tcp);
+		net_close(server_udp);
+		return 0;
+	}
+#endif
+	
+	
 	ret = net_bind(server_tcp, (struct sockaddr*) &addr, sockaddr_size);
 	if (ret == -1)
 	{
@@ -470,9 +569,25 @@ struct hub_info* hub_start_service(struct hub_config* config)
 		event_base_free(hub->evbase);
 		hub_free(hub);
 		net_close(server_tcp);
+#ifdef ADC_UDP_OPERATION
+		net_close(server_udp);
+#endif
 		return 0;
 	}
 
+#ifdef ADC_UDP_OPERATION
+	ret = net_bind(server_udp, (struct sockaddr*) &addr, sockaddr_size);
+	if (ret == -1)
+	{
+		hub_log(log_fatal, "hub_start_service(): Unable to bind to UDP local address. errno=%d, str=%s", net_error(), net_error_string(net_error()));
+		event_base_free(hub->evbase);
+		hub_free(hub);
+		net_close(server_tcp);
+		net_close(server_udp);
+		return 0;
+	}
+#endif	
+
 	ret = net_listen(server_tcp, SERVER_BACKLOG);
 	if (ret == -1)
 	{
@@ -480,17 +595,26 @@ struct hub_info* hub_start_service(struct hub_config* config)
 		event_base_free(hub->evbase);
 		hub_free(hub);
 		net_close(server_tcp);
+#ifdef ADC_UDP_OPERATION
+		net_close(server_udp);
+#endif
 		return 0;
 	}
 	
 	hub->fd_tcp = server_tcp;
+#ifdef ADC_UDP_OPERATION	
+	hub->fd_udp = server_udp;
+#endif
 	hub->config = config;
 	hub->users = NULL;
 	
-	if (uman_init(hub) == -1)
+	if (user_manager_init(hub) == -1)
 	{
 		hub_free(hub);
 		net_close(server_tcp);
+#ifdef ADC_UDP_OPERATION
+		net_close(server_udp);
+#endif
 		return 0;
 	}
 	
@@ -498,17 +622,36 @@ struct hub_info* hub_start_service(struct hub_config* config)
 	event_base_set(hub->evbase, &hub->ev_accept);
 	if (event_add(&hub->ev_accept, NULL) == -1)
 	{
-		uman_shutdown(hub);
+		user_manager_shutdown(hub);
 		hub_free(hub);
 		net_close(server_tcp);
+#ifdef ADC_UDP_OPERATION
+		net_close(server_udp);
+#endif
 		return 0;
 	}
 
-	if (event_queue_initialize(&hub->queue, hub_event_dispatcher, (void*) hub) == -1)
+#ifdef ADC_UDP_OPERATION
+	event_set(&hub->ev_datagram, hub->fd_udp, EV_READ | EV_PERSIST, net_on_packet, hub);
+	event_base_set(hub->evbase, &hub->ev_datagram);
+	if (event_add(&hub->ev_datagram, NULL) == -1)
 	{
-		uman_shutdown(hub);
+		user_manager_shutdown(hub);
 		hub_free(hub);
 		net_close(server_tcp);
+		net_close(server_udp);
+		return 0;
+	}
+#endif
+
+	if (event_queue_initialize(&hub->queue, hub_event_dispatcher, (void*) hub) == -1)
+	{
+		user_manager_shutdown(hub);
+		hub_free(hub);
+		net_close(server_tcp);
+#ifdef ADC_UDP_OPERATION
+		net_close(server_udp);
+#endif
 		return 0;
 	}
 	
@@ -524,8 +667,12 @@ void hub_shutdown_service(struct hub_info* hub)
 
 	event_queue_shutdown(hub->queue);
 	event_del(&hub->ev_accept);
+#ifdef ADC_UDP_OPERATION
+	event_del(&hub->ev_datagram);
+	net_close(hub->fd_udp);
+#endif
 	net_close(hub->fd_tcp);
-	uman_shutdown(hub);
+	user_manager_shutdown(hub);
 	hub->status = hub_status_stopped;
 	event_base_free(hub->evbase);
 	hub_free(hub);
@@ -611,7 +758,7 @@ void hub_free_variables(struct hub_info* hub)
  */
 static inline int is_nick_in_use(struct hub_info* hub, const char* nick)
 {
-	struct user* lookup = uman_get_user_by_nick(hub, nick);
+	struct user* lookup = get_user_by_nick(hub, nick);
 	if (lookup)
 	{
 		return 1;
@@ -625,7 +772,7 @@ static inline int is_nick_in_use(struct hub_info* hub, const char* nick)
  */
 static inline int is_cid_in_use(struct hub_info* hub, const char* cid)
 {
-	struct user* lookup = uman_get_user_by_cid(hub, cid);
+	struct user* lookup = get_user_by_cid(hub, cid);
 	if (lookup)
 	{
 		return 1;
@@ -650,9 +797,9 @@ static void set_status_code(enum msg_status_level level, int code, char buffer[4
  * @param msg See enum status_message
  * @param level See enum status_level
  */
-void hub_send_status(struct hub_info* hub, struct user* user, enum status_message msg, enum msg_status_level level)
+void hub_send_status(struct user* user, enum status_message msg, enum msg_status_level level)
 {
-	struct hub_config* cfg = hub->config;
+	struct hub_config* cfg = user->hub->config;
 	struct adc_message* cmd = adc_msg_construct(ADC_CMD_ISTA, 6);
 	if (!cmd) return;
 	char code[4];

src/hub.h

@@ -82,8 +82,14 @@ struct hub_stats
 struct hub_info
 {
 	int fd_tcp;
+#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;
@@ -110,94 +116,106 @@ struct hub_info
  *
  * @return 0 on success, -1 on error
  */
-extern int hub_handle_message(struct hub_info* hub, struct 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 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 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 user* u, struct adc_message* cmd);
+extern int hub_handle_chat_message(struct user* u, struct adc_message* cmd);
 
 /**
  * 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 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 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 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 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 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 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 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 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 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 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);
 
@@ -222,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.
  */

src/hubevent.c

@@ -47,17 +47,15 @@ static void log_user_nick_change(struct user* u, const char* nick)
 
 
 /* Send MOTD, do logging etc */
-void on_login_success(struct hub_info* hub, struct user* u)
+void on_login_success(struct user* u)
 {
-	struct timeval timeout = { TIMEOUT_IDLE, 0 };
-	
 	/* Send user list of all existing users */
-	if (!uman_send_user_list(u))
+	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);
-	uman_add(hub, u);
+	user_manager_add(u);
 
 	/* Print log message */
 	log_user_login(u);
@@ -68,21 +66,17 @@ void on_login_success(struct hub_info* hub, struct user* u)
 	
 	/* Send message of the day (if any) */
 	if (user_is_logged_in(u)) /* Previous send() can fail! */
-		hub_send_motd(hub, u);
+		hub_send_motd(u);
-		
-	/* reset to idle timeout */
-	if (u->ev_read)
-		event_add(u->ev_read, &timeout);
 }
 
-void on_login_failure(struct hub_info* hub, struct user* u, enum status_message msg)
+void on_login_failure(struct user* u, enum status_message msg)
 {
 	log_user_login_error(u, msg);
-	hub_send_status(hub, u, msg, status_level_fatal);
+	hub_send_status(u, msg, status_level_fatal);
 	user_disconnect(u, quit_logon_error);
 }
 
-void on_nick_change(struct hub_info* hub, struct user* u, const char* nick)
+void on_nick_change(struct user* u, const char* nick)
 {
 	if (user_is_logged_in(u))
 	{
@@ -90,7 +84,7 @@ void on_nick_change(struct hub_info* hub, struct user* u, const char* nick)
 	}
 }
 
-void on_logout_user(struct hub_info* hub, struct user* user)
+void on_logout_user(struct user* user)
 {
 	const char* reason = "";
 	
@@ -109,7 +103,7 @@ void on_logout_user(struct hub_info* hub, struct user* user)
 		case quit_hub_disabled:     reason = "hub disabled";   break;
 		case quit_ghost_timeout:    reason = "ghost";          break;
 		default:
-			if (hub->status == hub_status_shutdown)
+			if (user->hub->status == hub_status_shutdown)
 				reason = "hub shutdown";
 			else
 				reason = "unknown error";

src/hubevent.h

@@ -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 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 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 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 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

@@ -89,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 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);
@@ -150,7 +150,7 @@ static int check_cid(struct hub_info* hub, struct user* user, struct adc_message
 }
 
 
-static int check_required_login_flags(struct hub_info* hub, struct user* user, struct adc_message* cmd)
+static int check_required_login_flags(struct user* user, struct adc_message* cmd)
 {
 	int num = 0;
 	
@@ -186,12 +186,12 @@ static int check_required_login_flags(struct hub_info* hub, struct user* user, s
  * remove any wrong address, and replace it with the correct one
  * as seen by the hub.
  */
-int check_network(struct hub_info* hub, struct user* user, struct adc_message* cmd)
+int check_network(struct user* user, struct adc_message* cmd)
 {
 	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 (strcmp(client_given_ip, "0.0.0.0") != 0)
@@ -222,13 +222,6 @@ int check_network(struct hub_info* hub, struct user* user, struct adc_message* c
 	return 0;
 }
 
-void strip_network(struct 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)
 {
@@ -276,7 +269,7 @@ static int nick_is_utf8(const char* nick)
 }
 
 
-static int check_nick(struct hub_info* hub, struct user* user, struct adc_message* cmd)
+static int check_nick(struct user* user, struct adc_message* cmd)
 {
 	char* nick;
 	char* tmp;
@@ -324,10 +317,10 @@ static int check_nick(struct hub_info* hub, struct user* user, struct adc_messag
 }
 
 
-static int check_logged_in(struct hub_info* hub, struct user* user, struct adc_message* cmd)
+static int check_logged_in(struct user* user, struct adc_message* cmd)
 {
-	struct user* lookup1 = uman_get_user_by_nick(hub, user->id.nick);
+	struct user* lookup1 = get_user_by_nick(user->hub, user->id.nick);
-	struct 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)
 	{
@@ -365,7 +358,7 @@ static int check_logged_in(struct hub_info* hub, struct user* user, struct adc_m
  * 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 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;
@@ -386,19 +379,19 @@ static int check_user_agent(struct hub_info* hub, struct user* user, struct adc_
 }
 
 
-static int check_acl(struct hub_info* hub, struct 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;
 	}
@@ -406,7 +399,7 @@ static int check_acl(struct hub_info* hub, struct user* user, struct adc_message
 	return 0;
 }
 
-static int check_limits(struct hub_info* hub, struct 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)
@@ -417,8 +410,8 @@ static int check_limits(struct hub_info* hub, struct user* user, struct adc_mess
 		
 		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);
@@ -434,8 +427,8 @@ static int check_limits(struct hub_info* hub, struct user* user, struct adc_mess
 		
 		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);
@@ -487,37 +480,37 @@ static int check_limits(struct hub_info* hub, struct user* user, struct adc_mess
 
 	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;
 		}
@@ -532,10 +525,10 @@ static int check_limits(struct hub_info* hub, struct user* user, struct adc_mess
  * 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 user* user, struct adc_message* cmd)
+static int set_credentials(struct user* user, struct adc_message* cmd)
 {
 	int ret = 0;
-	struct 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)
 	{
@@ -626,13 +619,43 @@ static int user_is_registered(struct user* user)
 }
 
 
-static int check_is_hub_full(struct hub_info* hub, struct user* user)
+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;
 	}
@@ -640,15 +663,22 @@ static int check_is_hub_full(struct hub_info* hub, struct user* user)
 }
 
 
-static int check_registered_users_only(struct hub_info* hub, struct 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;
 }
 
+#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 */
@@ -660,9 +690,9 @@ static int hub_handle_info_common(struct user* user, struct adc_message* cmd)
 	return 0;
 }
 
-static int hub_handle_info_low_bandwidth(struct hub_info* hub, struct 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);
@@ -681,54 +711,40 @@ static int hub_handle_info_low_bandwidth(struct hub_info* hub, struct user* 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 user* user, struct adc_message* cmd)
-{
-	/* Make syntax checks.  */
-	INF_CHECK(check_required_login_flags, hub, user, cmd);
-	INF_CHECK(check_cid,                  hub, user, cmd);
-	INF_CHECK(check_nick,                 hub, user, cmd);
-	INF_CHECK(check_network,              hub, user, cmd);
-	INF_CHECK(check_user_agent,           hub, user, cmd);
-	INF_CHECK(check_acl,                  hub, user, cmd);
-	INF_CHECK(check_logged_in,            hub, user, cmd);
-	
-	return 0;
-}
-
-int hub_handle_info_login(struct hub_info* hub, struct user* user, struct adc_message* cmd)
 {
 	int need_auth = 0;
 	
-	INF_CHECK(hub_perform_login_checks, hub, user, cmd);
+	/* Make syntax checks.  */
+	INF_CHECK(check_required_login_flags,     user, cmd);
+	INF_CHECK(check_cid,                      user, cmd);
+	INF_CHECK(check_nick,                     user, cmd);
+	INF_CHECK(check_network,                  user, cmd);
+	INF_CHECK(check_user_agent,               user, cmd);
+	INF_CHECK(check_acl,                      user, cmd);
+	INF_CHECK(check_logged_in,                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 */
-	need_auth = 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);
@@ -749,7 +765,7 @@ int hub_handle_info_login(struct hub_info* hub, struct user* user, struct adc_me
  * - CID/PID (valid, not taken, etc).
  * - IP addresses (IPv4 and IPv6)
  */
-int hub_handle_info(struct hub_info* hub, struct 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 */
@@ -773,10 +789,10 @@ int hub_handle_info(struct hub_info* hub, struct user* user, const struct adc_me
 			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;
 		}
@@ -788,7 +804,7 @@ int hub_handle_info(struct hub_info* hub, struct user* user, const struct adc_me
 			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;
 		}
@@ -806,17 +822,15 @@ int hub_handle_info(struct hub_info* hub, struct user* user, const struct adc_me
 		if (adc_msg_has_named_argument(cmd, ADC_INF_FLAG_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))
 		{

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 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/message.c

@@ -34,7 +34,6 @@
 
 struct adc_message* adc_msg_incref(struct adc_message* msg)
 {
-	if (!msg) return 0;
 #ifndef ADC_MESSAGE_INCREF
 	msg->references++;
 	return msg;

src/netevent.c

@@ -20,32 +20,14 @@
 #include "uhub.h"
 
 
-void net_on_read(int fd, short ev, void *arg)
+static int on_read(struct user* user)
 {
 	static char buf[MAX_RECV_BUF];
-	struct user* user = (struct user*) arg;
-	char* pos;
 	size_t offset;
 	size_t buflen;
 	ssize_t size;
 	int more = 1;
-	int flag_close = 0;
+	char* pos;
-	
-	hub_log(log_trace, "net_on_read() : fd=%d, ev=%d, arg=%p", fd, (int) ev, arg);
-	
-	if (ev == EV_TIMEOUT)
-	{
-		more = 0;
-		if (user_is_connecting(user))
-		{
-			flag_close = quit_timeout;
-		}
-		else
-		{
-			// FIXME: hub is not neccesarily set!
-			// hub_send_ping(hub, user);
-		}
-	}
 
 	while (more)
 	{
@@ -56,17 +38,16 @@ void net_on_read(int fd, short ev, void *arg)
 			offset = user->recv_buf_offset;
 		}
 		
-		size = net_recv(fd, &buf[offset], MAX_RECV_BUF - offset, 0);
+		size = net_recv(user->sd, &buf[offset], MAX_RECV_BUF - offset, 0);
 		if (size == -1)
 		{
 			if (net_error() != EWOULDBLOCK)
-				flag_close = quit_socket_error;
+				return quit_socket_error;
 			break;
 		}
 		else if (size == 0)
 		{
-			flag_close = quit_disconnected;
+			return quit_disconnected;
-			break;
 		}
 		else
 		{
@@ -86,12 +67,9 @@ void net_on_read(int fd, short ev, void *arg)
 				{
 					if (msglen < user->hub->config->max_recv_buffer)
 					{
-						// FIXME: hub is not set????
+						if (hub_handle_message(user, &buf[handled], msglen) == -1)
-						if (hub_handle_message(user->hub, user, &buf[handled], msglen) == -1)
 						{
-							flag_close = quit_protocol_error;
+							return quit_protocol_error;
-							more = 0;
-							break;
 						}
 					}
 				}
@@ -126,8 +104,7 @@ void net_on_read(int fd, short ev, void *arg)
 					}
 					else
 					{
-						flag_close = quit_memory_error;
+						return quit_memory_error;
-						break;
 					}
 				}
 			}
@@ -142,39 +119,14 @@ void net_on_read(int fd, short ev, void *arg)
 			}
 		}
 	}
-	
+	return 0;
-	if (flag_close)
-	{
-		user_disconnect(user, flag_close);
-		return;
 }
 
-	if (user_is_logged_in(user))
+static int on_write(struct user* user)
 {
-		if (user->ev_read)
-		{
-			struct timeval timeout = { TIMEOUT_IDLE, 0 };
-			event_add(user->ev_read, &timeout);
-		}
-	}
-	else if (user_is_connecting(user))
-	{
-		if (user->ev_read)
-		{
-			struct timeval timeout = { TIMEOUT_HANDSHAKE, 0 };
-			event_add(user->ev_read, &timeout);
-		}
-	}
-}
-
-
-void net_on_write(int fd, short ev, void *arg)
-{
-	struct user* user = (struct user*) arg;
 	struct adc_message* msg;
 	int ret;
 	int length;
-	int close_flag = 0;
 	
 	msg = list_get_first(user->send_queue);
 	while (msg)
@@ -184,29 +136,16 @@ void net_on_write(int fd, short ev, void *arg)
 	
 		if (ret == 0 || (ret == -1 && net_error() == EWOULDBLOCK))
 		{
-			close_flag = 0;
+			return 0;
-			break;
 		}
 		else if (ret > 0)
 		{
-			
 			user->tm_last_write = time(NULL);
 			
 			if (ret == length)
 			{
-#ifdef DEBUG_SENDQ
-				hub_log(log_error, "SENDQ: sent=%d bytes/%d (all), send_queue_size=%d, offset=%d", ret, (int) msg->length, user->send_queue_size, user->send_queue_offset);
-#endif
 				user->send_queue_size -= ret;
 				user->send_queue_offset = 0;
-			
-#ifdef DEBUG_SENDQ
-				if ((user->send_queue_size < 0) || (user->send_queue_offset < 0))
-				{
-					hub_log(log_error, "INVALID: send_queue_size=%d, send_queue_offset=%d", user->send_queue_size, user->send_queue_offset);
-				}
-#endif
-			
 				list_remove(user->send_queue, msg);
 				
 				if (user_flag_get(user, flag_user_list) && (msg == user->info || user->send_queue_size == 0))
@@ -222,40 +161,73 @@ void net_on_write(int fd, short ev, void *arg)
 			}
 			else
 			{
-#ifdef DEBUG_SENDQ
-                                hub_log(log_error, "SENDQ: sent=%d bytes/%d (part), send_queue_size=%d, offset=%d", ret, (int) msg->length, user->send_queue_size, user->send_queue_offset);
-#endif
 				user->send_queue_size -= ret;
 				user->send_queue_offset += ret;
-				
-#ifdef DEBUG_SENDQ				
-				if ((user->send_queue_size < 0) || (user->send_queue_offset < 0) || (user->send_queue_offset > msg->length))
-				{
-					hub_log(log_error, "INVALID: send_queue_size=%d, send_queue_offset=%d", user->send_queue_size, user->send_queue_offset);
-				}
-#endif
 				break;
 			}
 		}
 		else
 		{
-			close_flag = quit_socket_error;
+			return quit_socket_error;
-			break;
 		}
 		msg = list_get_first(user->send_queue);
 	}
+	return 0;
+}
 
 
-	if (close_flag)
+void on_net_event(int fd, short ev, void *arg)
 {
-		user_disconnect(user, close_flag);
+	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
 		{
-		if (user->send_queue_size > 0 && user->ev_write)
+			hub_send_ping(user);
-			event_add(user->ev_write, NULL);
 		}
 	}
+	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)
@@ -264,7 +236,6 @@ void net_on_accept(int server_fd, short ev, void *arg)
 	struct user* user = 0;
 	struct ip_addr_encap ipaddr;
 	const char* addr;
-	struct timeval timeout = { TIMEOUT_CONNECTED, 0 };
 	
 	for (;;)
 	{
@@ -308,12 +279,23 @@ void net_on_accept(int server_fd, short ev, void *arg)
 
 		net_set_nonblocking(fd, 1);
 		net_set_nosigpipe(fd, 1);
-		
+		user_trigger_init(user);
-		event_set(user->ev_read,  fd, EV_READ | EV_PERSIST, net_on_read,  user);
-		event_set(user->ev_write, fd, EV_WRITE,             net_on_write, user);
-		event_base_set(hub->evbase, user->ev_read);
-		event_base_set(hub->evbase, user->ev_write);
-		event_add(user->ev_read,  &timeout);
 	}
 }
 
+#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

@@ -20,25 +20,19 @@
 #ifndef HAVE_UHUB_NET_EVENT_H
 #define HAVE_UHUB_NET_EVENT_H
 
-/**
+struct user;
- * Network callback for reading data from a socket.
- */
-extern void net_on_read(int fd, short ev, void *arg);
 
-/**
+extern void on_net_event(int fd, short ev, void *arg);
- * Network callback for writing data to a socket.
- */
-extern void net_on_write(int fd, short ev, void *arg);
-
-/**
- * Network callback for timers.
- */
-extern void net_on_read_timeout(int fd, short ev, void* arg);
 
 /**
  * Network callback to accept incoming connections.
  */
 extern void net_on_accept(int fd, short ev, void *arg);
 
+/**
+ *
+ */
+extern void net_update_trigger(struct user* user, int write, struct timeval timeout);
+
 #endif /* HAVE_UHUB_NET_EVENT_H */
 

src/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/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/route.c

@@ -31,7 +31,7 @@ int route_message(struct user* u, struct adc_message* msg)
 			break;
 			
 		case 'D':
-			target = uman_get_user_by_sid(u->hub, msg->target);
+			target = get_user_by_sid(u->hub, msg->target);
 			if (target)
 			{
 				route_to_user(target, msg);
@@ -39,7 +39,7 @@ int route_message(struct user* u, struct adc_message* msg)
 			break;
 			
 		case 'E':
-			target = uman_get_user_by_sid(u->hub, msg->target);
+			target = get_user_by_sid(u->hub, msg->target);
 			if (target)
 			{
 				route_to_user(target, msg);
@@ -135,8 +135,8 @@ int route_to_user(struct user* user, struct adc_message* msg)
 		{
 			queue_command(user, msg, ret);
 			
-			if (user->send_queue_size && user->ev_write)
+			if (user->send_queue_size && user->ev_handle)
-				event_add(user->ev_write, NULL);
+				event_add(user->ev_handle, NULL);
 		}
 		else
 		{
@@ -158,8 +158,8 @@ int route_to_user(struct user* user, struct adc_message* msg)
 		{
 			/* queue command */
 			queue_command(user, msg, 0);
-                        if (user->ev_write)
+                        if (user->ev_handle)
-				event_add(user->ev_write, NULL);
+				event_add(user->ev_handle, NULL);
 
 		}
 		else

src/user.c

@@ -30,13 +30,11 @@ struct user* user_create(struct hub_info* hub, int sd)
 	if (user == NULL)
 		return NULL; /* OOM */
 
-	user->ev_write = hub_malloc_zero(sizeof(struct event));
+	user->ev_handle = hub_malloc_zero(sizeof(struct event));
-	user->ev_read  = hub_malloc_zero(sizeof(struct event));
 
-	if (!user->ev_write || !user->ev_read)
+	if (!user->ev_handle)
 	{
-	    hub_free(user->ev_read);
+	    hub_free(user->ev_handle);
-	    hub_free(user->ev_write);
 	    hub_free(user);
 	    return NULL;
 	}
@@ -65,22 +63,8 @@ void user_destroy(struct user* user)
 {
 	hub_log(log_trace, "user_destroy(), user=%p", user);
 
-	if (user->ev_write)
+	user_trigger_shutdown(user);
-	{
-		event_del(user->ev_write);
-		hub_free(user->ev_write);
-		user->ev_write = 0;
-	}
-	
-	if (user->ev_read)
-	{
-		event_del(user->ev_read);
-		hub_free(user->ev_read);
-		user->ev_read = 0;
-	}
-	
 	net_close(user->sd);
-	
 	adc_msg_free(user->info);
 	user_clear_feature_cast_support(user);
 	
@@ -115,51 +99,12 @@ void user_set_info(struct user* user, struct adc_message* cmd)
 	user->info = adc_msg_incref(cmd);
 }
 
-void user_update_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;
-	}
-	
-	/*
-	 * 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;
 			
@@ -252,12 +197,7 @@ void user_disconnect(struct user* user, int reason)
 	}
 	
 	/* dont read more data from this user */
-	if (user->ev_read)
+	user_flag_set(user, flag_ignore);
-	{
-		event_del(user->ev_read);
-		hub_free(user->ev_read);
-		user->ev_read = 0;
-	}
 	
 	hub_log(log_trace, "user_disconnect(), user=%p, reason=%d, state=%d", user, reason, user->state);
 	
@@ -342,6 +282,36 @@ int user_is_disconnecting(struct user* user)
 	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

@@ -99,8 +99,7 @@ struct user_counts
 struct user
 {
 	int                  sd;                      /** socket descriptor */
-	struct event*        ev_read;                 /** libevent struct for read events */
+	struct event*        ev_handle;
-	struct event*        ev_write;                /** libevent struct for write events */
 	enum user_state      state;                   /** see enum user_state */
 	enum user_credentials credentials;            /** see enum user_credentials */
 	struct user_info     id;                      /** Contains nick name and CID */
@@ -171,18 +170,9 @@ 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 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 user* user, struct adc_message* cmd);
-
 /**
  * Specify a user's state.
  * NOTE: DON'T, unless you know what you are doing.
@@ -265,7 +255,9 @@ extern int user_set_feature_cast_support(struct user* u, char feature[4]);
  */
 extern void user_clear_feature_cast_support(struct user* u);
 
-
+extern void user_trigger_init(struct user* user);
+extern void user_trigger_update(struct user* user, int w, int timeout_sec);
+extern void user_trigger_shutdown(struct user* user);
 
 #endif /* HAVE_UHUB_USER_H */
 

src/usermanager.c

@@ -21,7 +21,7 @@
 
 /*
  * This callback function is used to clear user objects from the userlist.
- * Should only be used in uman_shutdown().
+ * Should only be used in user_manager_shutdown().
  */
 static void clear_user_list_callback(void* ptr)
 {
@@ -39,7 +39,7 @@ static void clear_user_list_callback(void* ptr)
 }
 
 
-void uman_update_stats(struct hub_info* hub)
+void user_manager_update_stats(struct hub_info* hub)
 {
 	const int factor = TIMEOUT_STATS;
 	struct net_statistics* total;
@@ -57,7 +57,7 @@ void uman_update_stats(struct hub_info* hub)
 }
 
 
-void uman_print_stats(struct hub_info* hub)
+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,
@@ -68,31 +68,23 @@ void uman_print_stats(struct hub_info* hub)
 		(int) hub->stats.net_rx_peak / 1024);
 }
 
-#ifdef USERMANAGER_TIMER
 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);
+	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);
 }
-#endif
 
 
-int uman_init(struct hub_info* hub)
+int user_manager_init(struct hub_info* hub)
 {
 	struct user_manager* users = NULL;
-#ifdef USERMANAGER_TIMER
 	struct timeval timeout = { TIMEOUT_STATS, 0 };
-#endif
-	if (!hub)
-		return -1;
 
 	users = (struct user_manager*) hub_malloc_zero(sizeof(struct user_manager));
-	if (!users)
-		return -1;
 
 	users->list = list_create();
 	users->free_sid = 1;
@@ -105,73 +97,45 @@ int uman_init(struct hub_info* hub)
 	
 	hub->users = users;
 	
-#ifdef USERMANAGER_TIMER
 	evtimer_set(&hub->ev_timer, timer_statistics, hub);
 	event_base_set(hub->evbase, &hub->ev_timer);
 	evtimer_add(&hub->ev_timer, &timeout);
-#endif // 0
 	return 0;
 }
 
 
-int uman_shutdown(struct hub_info* hub)
+void user_manager_shutdown(struct hub_info* hub)
 {
-	if (!hub || !hub->users)
+	struct user_manager* users = hub->users;
-		return -1;
-
-#ifdef USERMANAGER_TIMER
 	event_del(&hub->ev_timer);
-#endif
 
-	if (hub->users->list)
+	list_clear(users->list, &clear_user_list_callback);
-	{
+	list_destroy(users->list);
-		list_clear(hub->users->list, &clear_user_list_callback);
-		list_destroy(hub->users->list);
-	}
 	hub_free(hub->users);
-	hub->users = 0;
-
-	return 0;
 }
 
 
-int uman_add(struct hub_info* hub, struct user* user)
+void user_manager_add(struct user* user)
 {
-	if (!hub || !user)
+	list_append(user->hub->users->list, user);
-		return -1;
+	user->hub->users->count++;
+	user->hub->users->count_peak = MAX(user->hub->users->count, user->hub->users->count_peak);
 
-	if (user->hub)
+	user->hub->users->shared_size  += user->limits.shared_size;
-		return -1;
+	user->hub->users->shared_files += user->limits.shared_files;
-
-	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 user* user)
+void user_manager_remove(struct user* user)
 {
-	if (!hub || !user)
+	list_remove(user->hub->users->list, user);
-		return -1;
+	user->hub->users->count--;
 	
-	list_remove(hub->users->list, user);
+	user->hub->users->shared_size  -= user->limits.shared_size;
-	hub->users->count--;
+	user->hub->users->shared_files -= user->limits.shared_files;
-	
-	hub->users->shared_size  -= user->limits.shared_size;
-	hub->users->shared_files -= user->limits.shared_files;
-
-	user->hub = 0;
-	
-	return 0;
 }
 
 
-struct user* uman_get_user_by_sid(struct hub_info* hub, sid_t sid)
+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)
@@ -184,7 +148,7 @@ struct user* uman_get_user_by_sid(struct hub_info* hub, sid_t sid)
 }
 
 
-struct user* uman_get_user_by_cid(struct hub_info* hub, const char* cid)
+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)
@@ -197,7 +161,7 @@ struct user* uman_get_user_by_cid(struct hub_info* hub, const char* cid)
 }
 
 
-struct user* uman_get_user_by_nick(struct hub_info* hub, const char* nick)
+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)
@@ -210,7 +174,7 @@ struct user* uman_get_user_by_nick(struct hub_info* hub, const char* nick)
 }
 
 
-int uman_send_user_list(struct user* target)
+int send_user_list(struct user* target)
 {
 	int ret = 1;
 	user_flag_set(target, flag_user_list);
@@ -234,7 +198,7 @@ int uman_send_user_list(struct user* target)
 }
 
 
-void uman_send_quit_message(struct user* leaving)
+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));
@@ -249,7 +213,7 @@ void uman_send_quit_message(struct user* leaving)
 }
 
 
-sid_t uman_get_free_sid(struct hub_info* hub)
+sid_t user_manager_get_free_sid(struct hub_info* hub)
 {
 #if 0
 	struct user* user;

src/usermanager.h

@@ -34,70 +34,55 @@ struct user_manager
  * 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 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 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);
+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 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 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 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);
 
 /**
  * Send the user list of connected clients to 'user'.
@@ -105,13 +90,13 @@ extern struct user* uman_get_user_by_nick(struct hub_info* hub, const char* nick
  *
  * @return 1 if sending the user list succeeded, 0 otherwise.
  */
-extern int uman_send_user_list(struct 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 user* user);
+extern void send_quit_message(struct user* user);
 
 
 #endif /* HAVE_UHUB_USER_MANAGER_H */

version.h

@@ -7,7 +7,7 @@
 #endif
 
 #ifndef VERSION
-#define VERSION "0.2.9-rc1"
+#define VERSION "0.2.8"
 #endif
 
 #ifndef COPYRIGHT