HPM Update

- Custom Packet Support
- Custom Data Struct Support (currently append-able to map_session_data and socket_data)
- Char Server Support
- Login Server Support
http://hercules.ws/board/topic/1934-hercules-plugin-manager-update/
Documentation will soon be updated in http://hercules.ws/wiki/HPM

Signed-off-by: shennetsind <ind@henn.et>

7 files changed, 341 insertions, 38 deletions

diff --git a/src/common/HPM.c b/src/common/HPM.c
index 53059d224..3b79febd7 100644
--- a/src/common/HPM.c
+++ b/src/common/HPM.c
@@ -22,6 +22,9 @@
 #include <unistd.h>
 #endif
 
+struct malloc_interface iMalloc_HPM;
+struct malloc_interface *HPMiMalloc;
+
 void hplugin_trigger_event(enum hp_event_types type) {
 	unsigned int i;
 	for( i = 0; i < HPM->plugin_count; i++ ) {
@@ -189,12 +192,17 @@ void hplugin_load(const char* filename) {
 	
 	if( !HPM->populate(plugin,filename) )
 		return;
-	
-	if( SERVER_TYPE == SERVER_TYPE_MAP ) {
-		plugin->hpi->addCommand		= HPM->import_symbol("addCommand");
-		plugin->hpi->addScript		= HPM->import_symbol("addScript");
-		plugin->hpi->addCPCommand	= HPM->import_symbol("addCPCommand");
-	}
+	/* id */
+	plugin->hpi->pid				= plugin->idx;
+	/* core */
+	plugin->hpi->addCPCommand		= HPM->import_symbol("addCPCommand");
+	plugin->hpi->addPacket			= HPM->import_symbol("addPacket");
+	plugin->hpi->addToSession		= HPM->import_symbol("addToSession");
+	plugin->hpi->getFromSession		= HPM->import_symbol("getFromSession");
+	plugin->hpi->removeFromSession	= HPM->import_symbol("removeFromSession");
+	/* server specific */
+	if( HPM->load_sub )
+		HPM->load_sub(plugin);
 	
 	plugin->info = info;
 	plugin->filename = aStrdup(filename);
@@ -209,7 +217,8 @@ void hplugin_unload(struct hplugin* plugin) {
 		aFree(plugin->filename);
 	if( plugin->dll )
 		plugin_close(plugin->dll);
-	
+	/* TODO: for manual packet unload */
+	/* - Go thru known packets and unlink any belonging to the plugin being removed */
 	aFree(plugin);
 	if( !HPM->off ) {
 		HPM->plugins[i] = NULL;
@@ -253,11 +262,191 @@ void hplugins_config_read(void) {
 	if( HPM->plugin_count )
 		ShowStatus("HPM: There are '"CL_WHITE"%d"CL_RESET"' plugins loaded, type '"CL_WHITE"plugins"CL_RESET"' to list them\n", HPM->plugin_count);
 }
+CPCMD(plugins) {
+	if( HPM->plugin_count == 0 ) {
+		ShowInfo("HPC: there are no plugins loaded\n");
+	} else {
+		unsigned int i;
+		
+		ShowInfo("HPC: There are '"CL_WHITE"%d"CL_RESET"' plugins loaded\n",HPM->plugin_count);
+		
+		for(i = 0; i < HPM->plugin_count; i++) {
+			ShowInfo("HPC: - '"CL_WHITE"%s"CL_RESET"' (%s)\n",HPM->plugins[i]->info->name,HPM->plugins[i]->filename);
+		}
+	}
+}
+
+void hplugins_addToSession(struct socket_data *sess, void *data, unsigned int id, unsigned int type, bool autofree) {
+	struct HPluginData *HPData;
+	unsigned int i;
+	
+	for(i = 0; i < sess->hdatac; i++) {
+		if( sess->hdata[i]->pluginID == id && sess->hdata[i]->type == type ) {
+			ShowError("HPM->addToSession:%s: error! attempting to insert duplicate struct of id %u and type %u\n",HPM->pid2name(id),id,type);
+			return;
+		}
+	}
+	
+	//HPluginData is always same size, probably better to use the ERS
+	CREATE(HPData, struct HPluginData, 1);
+	
+	HPData->pluginID = id;
+	HPData->type = type;
+	HPData->flag.free = autofree ? 1 : 0;
+	HPData->data = data;
+	
+	RECREATE(sess->hdata,struct HPluginData *,++sess->hdatac);
+	sess->hdata[sess->hdatac - 1] = HPData;
+}
+void *hplugins_getFromSession(struct socket_data *sess, unsigned int id, unsigned int type) {
+	unsigned int i;
+	
+	for(i = 0; i < sess->hdatac; i++) {
+		if( sess->hdata[i]->pluginID == id && sess->hdata[i]->type == type ) {
+			break;
+		}
+	}
+	
+	if( i != sess->hdatac )
+		return sess->hdata[i]->data;
+	
+	return NULL;
+}
+void hplugins_removeFromSession(struct socket_data *sess, unsigned int id, unsigned int type) {
+	unsigned int i;
+	
+	for(i = 0; i < sess->hdatac; i++) {
+		if( sess->hdata[i]->pluginID == id && sess->hdata[i]->type == type ) {
+			break;
+		}
+	}
+	
+	if( i != sess->hdatac ) {
+		unsigned int cursor;
+
+		aFree(sess->hdata[i]->data);
+		aFree(sess->hdata[i]);
+		sess->hdata[i] = NULL;
+		
+		for(i = 0, cursor = 0; i < sess->hdatac; i++) {
+			if( sess->hdata[i] == NULL )
+				continue;
+			if( i != cursor )
+				sess->hdata[cursor] = sess->hdata[i];
+			cursor++;
+		}
+		sess->hdatac = cursor;
+	}
+	
+}
+
+bool hplugins_addpacket(unsigned short cmd, short length,void (*receive) (int fd),unsigned int point,unsigned int pluginID) {
+	struct HPluginPacket *packet;
+	unsigned int i;
+	
+	if( point >= hpPHP_MAX ) {
+		ShowError("HPM->addPacket:%s: unknown point '%u' specified for packet 0x%04x (len %d)\n",HPM->pid2name(pluginID),point,cmd,length);
+		return false;
+	}
+
+	for(i = 0; i < HPM->packetsc[point]; i++) {
+		if( HPM->packets[point][i].cmd == cmd ) {
+			ShowError("HPM->addPacket:%s: can't add packet 0x%04x, already in use by '%s'!",HPM->pid2name(pluginID),cmd,HPM->pid2name(HPM->packets[point][i].pluginID));
+			return false;
+		}
+	}
+	
+	RECREATE(HPM->packets[point], struct HPluginPacket, ++HPM->packetsc[point]);
+	packet = &HPM->packets[point][HPM->packetsc[point] - 1];
+	
+	packet->pluginID = pluginID;
+	packet->cmd = cmd;
+	packet->len = length;
+	packet->receive = receive;
+	
+	return true;
+}
+/* 
+ 0 = unknown
+ 1 = OK
+ 2 = incomplete
+ */
+unsigned char hplugins_parse_packets(int fd, enum HPluginPacketHookingPoints point) {
+	unsigned int i;
+		
+	for(i = 0; i < HPM->packetsc[point]; i++) {
+		if( HPM->packets[point][i].cmd == RFIFOW(fd,0) )
+			break;
+	}
+	
+	if( i != HPM->packetsc[point] ) {
+		struct HPluginPacket *packet = &HPM->packets[point][i];
+		short length;
+		
+		if( (length = packet->len) == -1 ) {
+			if( (length = RFIFOW(fd, 2)) < (int)RFIFOREST(fd) )
+			   return 2;
+		}
+		
+		packet->receive(fd);
+		RFIFOSKIP(fd, length);
+		return 1;
+	}
+	
+	return 0;
+}
+
+char *hplugins_id2name (unsigned int pid) {
+	unsigned int i;
+	
+	for( i = 0; i < HPM->plugin_count; i++ ) {
+		if( HPM->plugins[i]->idx == pid )
+			return HPM->plugins[i]->info->name;
+	}
+	
+	return "UnknownPlugin";
+}
+char* HPM_file2ptr(const char *file) {
+	unsigned int i;
+	
+	for(i = 0; i < HPM->fnamec; i++) {
+		if( HPM->fnames[i].addr == file )
+			return HPM->fnames[i].name;
+	}
+	
+	i = HPM->fnamec;
+	
+	/* we handle this memory outside of the server's memory manager because we need it to exist after the memory manager goes down */
+	HPM->fnames = realloc(HPM->fnames,(++HPM->fnamec)*sizeof(struct HPMFileNameCache));
+		
+	HPM->fnames[i].addr = file;
+	HPM->fnames[i].name = strdup(file);
+
+	return HPM->fnames[i].name;
+}
+void* HPM_mmalloc(size_t size, const char *file, int line, const char *func) {
+	return iMalloc->malloc(size,HPM_file2ptr(file),line,func);
+}
+void* HPM_calloc(size_t num, size_t size, const char *file, int line, const char *func) {
+	return iMalloc->calloc(num,size,HPM_file2ptr(file),line,func);
+}
+void* HPM_realloc(void *p, size_t size, const char *file, int line, const char *func) {
+	return iMalloc->realloc(p,size,HPM_file2ptr(file),line,func);
+}
+char* HPM_astrdup(const char *p, const char *file, int line, const char *func) {
+	return iMalloc->astrdup(p,HPM_file2ptr(file),line,func);
+}
+
 void hplugins_share_defaults(void) {
 	/* console */
 #ifdef CONSOLE_INPUT
 	HPM->share(console->addCommand,"addCPCommand");
 #endif
+	/* our own */
+	HPM->share(hplugins_addpacket,"addPacket");
+	HPM->share(hplugins_addToSession,"addToSession");
+	HPM->share(hplugins_getFromSession,"getFromSession");
+	HPM->share(hplugins_removeFromSession,"removeFromSession");
 	/* core */
 	HPM->share(&runflag,"runflag");
 	HPM->share(arg_v,"arg_v");
@@ -267,15 +456,13 @@ void hplugins_share_defaults(void) {
 	HPM->share((void*)get_svn_revision,"get_svn_revision");
 	HPM->share((void*)get_git_hash,"get_git_hash");
 	HPM->share(DB, "DB");
-	HPM->share(iMalloc, "iMalloc");
+	HPM->share(HPMiMalloc, "iMalloc");
 	/* socket */
 	HPM->share(RFIFOSKIP,"RFIFOSKIP");
 	HPM->share(WFIFOSET,"WFIFOSET");
 	HPM->share(do_close,"do_close");
 	HPM->share(make_connection,"make_connection");
-	HPM->share(session,"session");
-	HPM->share(&fd_max,"fd_max");
-	HPM->share(addr_,"addr");
+	//session,fd_max and addr_ are shared from within socket.c
 	/* strlib */
 	HPM->share(strlib,"strlib");
 	HPM->share(sv,"sv");
@@ -286,31 +473,34 @@ void hplugins_share_defaults(void) {
 	HPM->share(iTimer,"iTimer");
 	
 }
-CPCMD(plugins) {
-	if( HPM->plugin_count == 0 ) {
-		ShowInfo("HPC: there are no plugins loaded\n");
-	} else {
-		unsigned int i;
-		
-		ShowInfo("HPC: There are '"CL_WHITE"%d"CL_RESET"' plugins loaded\n",HPM->plugin_count);
-		
-		for(i = 0; i < HPM->plugin_count; i++) {
-			ShowInfo("HPC: - '"CL_WHITE"%s"CL_RESET"' (%s)\n",HPM->plugins[i]->info->name,HPM->plugins[i]->filename);
-		}
-	}
-}
+
 void hpm_init(void) {
+	unsigned int i;
+	
 	HPM->symbols = NULL;
 	HPM->plugins = NULL;
 	HPM->plugin_count = HPM->symbol_count = 0;
 	HPM->off = false;
 	
+	memcpy(&iMalloc_HPM, iMalloc, sizeof(struct malloc_interface));
+	HPMiMalloc = &iMalloc_HPM;
+	HPMiMalloc->malloc = HPM_mmalloc;
+	HPMiMalloc->calloc = HPM_calloc;
+	HPMiMalloc->realloc = HPM_realloc;
+	HPMiMalloc->astrdup = HPM_astrdup;
+
 	sscanf(HPM_VERSION, "%d.%d", &HPM->version[0], &HPM->version[1]);
 	
 	if( HPM->version[0] == 0 && HPM->version[1] == 0 ) {
 		ShowError("HPM:init:failed to retrieve HPM version!!\n");
 		return;
 	}
+	
+	for(i = 0; i < hpPHP_MAX; i++) {
+		HPM->packets[i] = NULL;
+		HPM->packetsc[i] = 0;
+	}
+	
 	HPM->symbol_defaults();
 	
 #ifdef CONSOLE_INPUT
@@ -318,7 +508,18 @@ void hpm_init(void) {
 #endif
 	return;
 }
-
+void hpm_memdown(void) {
+	unsigned int i;
+	
+	/* this memory is handled outside of the server's memory manager and thus cleared after memory manager goes down */
+	
+	for( i = 0; i < HPM->fnamec; i++ ) {
+		free(HPM->fnames[i].name);
+	}
+	
+	if( HPM->fnames )
+		free(HPM->fnames);
+}
 void hpm_final(void) {
 	unsigned int i;
 	
@@ -337,12 +538,23 @@ void hpm_final(void) {
 	
 	if( HPM->symbols )
 		aFree(HPM->symbols);
-			
+	
+	for( i = 0; i < hpPHP_MAX; i++ ) {
+		if( HPM->packets[i] )
+			aFree(HPM->packets[i]);
+	}
+	
+	/* HPM->fnames is cleared after the memory manager goes down */
+	iMalloc->post_shutdown = hpm_memdown;
+	
 	return;
 }
 void hpm_defaults(void) {
 	HPM = &HPM_s;
 	
+	HPM->fnames = NULL;
+	HPM->fnamec = 0;
+	
 	HPM->init = hpm_init;
 	HPM->final = hpm_final;
 	
@@ -358,4 +570,7 @@ void hpm_defaults(void) {
 	HPM->config_read = hplugins_config_read;
 	HPM->populate = hplugin_populate;
 	HPM->symbol_defaults_sub = NULL;
+	HPM->pid2name = hplugins_id2name;
+	HPM->parse_packets = hplugins_parse_packets;
+	HPM->load_sub = NULL;
 }
diff --git a/src/common/HPM.h b/src/common/HPM.h
index 10b1f0e79..d2a1308f2 100644
--- a/src/common/HPM.h
+++ b/src/common/HPM.h
@@ -49,6 +49,27 @@ struct hpm_symbol {
 	void *ptr;
 };
 
+struct HPluginData {
+	unsigned int pluginID;
+	unsigned int type;
+	struct {
+		unsigned int free : 1;
+	} flag;
+	void *data;
+};
+
+struct HPluginPacket {
+	unsigned int pluginID;
+	unsigned short cmd;
+	short len;
+	void (*receive) (int fd);
+};
+
+struct HPMFileNameCache {
+	const char *addr;
+	char *name;
+};
+
 /* Hercules Plugin Manager Interface */
 struct HPM_interface {
 	/* vars */
@@ -59,6 +80,12 @@ struct HPM_interface {
 	unsigned int plugin_count;
 	struct hpm_symbol **symbols;
 	unsigned int symbol_count;
+	/* packet hooking points */
+	struct HPluginPacket *packets[hpPHP_MAX];
+	unsigned int packetsc[hpPHP_MAX];
+	/* plugin file ptr caching */
+	struct HPMFileNameCache *fnames;
+	unsigned int fnamec;
 	/* funcs */
 	void (*init) (void);
 	void (*final) (void);
@@ -73,7 +100,10 @@ struct HPM_interface {
 	void (*symbol_defaults) (void);
 	void (*config_read) (void);
 	bool (*populate) (struct hplugin *plugin,const char *filename);
-	void (*symbol_defaults_sub) (void);
+	void (*symbol_defaults_sub) (void);//TODO drop
+	char *(*pid2name) (unsigned int pid);
+	unsigned char (*parse_packets) (int fd, enum HPluginPacketHookingPoints point);
+	void (*load_sub) (struct hplugin *plugin);
 } HPM_s;
 
 struct HPM_interface *HPM;
diff --git a/src/common/HPMi.h b/src/common/HPMi.h
index 3cdb804e0..5e44b80c7 100644
--- a/src/common/HPMi.h
+++ b/src/common/HPMi.h
@@ -11,6 +11,8 @@
 
 struct script_state;
 struct AtCommandInfo;
+struct socket_data;
+struct map_session_data;
 
 #ifdef WIN32
 	#define HPExport __declspec(dllexport)
@@ -33,7 +35,7 @@ struct AtCommandInfo;
 /* after */
 #include "../common/showmsg.h"
 
-#define HPM_VERSION "0.1"
+#define HPM_VERSION "0.2"
 
 struct hplugin_info {
 	char* name;
@@ -56,12 +58,37 @@ enum hp_event_types {
 	HPET_MAX,
 };
 
+enum HPluginPacketHookingPoints {
+	hpClif_Parse,		/* map-server (client-map) */
+	hpChrif_Parse,		/* map-server (char-map) */
+	hpParse_FromMap,	/* char-server (map-char) */
+	hpParse_FromLogin,	/* char-server (login-char) */
+	hpParse_Char,		/* char-server (client-char) */
+	hpParse_FromChar,	/* login-server (char-login) */
+	hpParse_Login,		/* login-server (client-login) */
+	/* */
+	hpPHP_MAX,
+};
+
 /* Hercules Plugin Mananger Include Interface */
 HPExport struct HPMi_interface {
+	/* */
+	unsigned int pid;
+	/* */
 	void (*event[HPET_MAX]) (void);
 	bool (*addCommand) (char *name, bool (*func)(const int fd, struct map_session_data* sd, const char* command, const char* message,struct AtCommandInfo *info));
 	bool (*addScript) (char *name, char *args, bool (*func)(struct script_state *st));
 	void (*addCPCommand) (char *name, CParseFunc func);
+	/* map_session_data */
+	void (*addToMSD) (struct map_session_data *sd, void *data, unsigned int id, unsigned int type, bool autofree);
+	void *(*getFromMSD) (struct map_session_data *sd, unsigned int id, unsigned int type);
+	void (*removeFromMSD) (struct map_session_data *sd, unsigned int id, unsigned int type);
+	/* session[] */
+	void (*addToSession) (struct socket_data *sess, void *data, unsigned int id, unsigned int type, bool autofree);
+	void *(*getFromSession) (struct socket_data *sess, unsigned int id, unsigned int type);
+	void (*removeFromSession) (struct socket_data *sess, unsigned int id, unsigned int type);
+	/* packet */
+	bool (*addPacket) (unsigned short cmd, unsigned short length, void (*receive)(int fd), unsigned int point, unsigned int pluginID);
 } HPMi_s;
 #ifndef _HPM_H_
 	HPExport struct HPMi_interface *HPMi;
diff --git a/src/common/malloc.c b/src/common/malloc.c
index d629aa63f..4d2c93b77 100644
--- a/src/common/malloc.c
+++ b/src/common/malloc.c
@@ -11,6 +11,8 @@
 #include <string.h>
 #include <time.h>
 
+struct malloc_interface iMalloc_s;
+
 ////////////// Memory Libraries //////////////////
 
 #if defined(MEMWATCH)
@@ -672,7 +674,7 @@ void memmgr_report (int extra) {
 	
 	if( extra != 0 )
 		msize = extra;
-	
+
 	while (block) {
 		if (block->unit_used) {
 			int i;
@@ -784,6 +786,8 @@ void malloc_final (void) {
 	memmgr_final ();
 #endif
 	MEMORY_CHECK();
+	if( iMalloc->post_shutdown )
+		iMalloc->post_shutdown();
 }
 
 void malloc_init (void) {
@@ -825,4 +829,5 @@ void malloc_defaults(void) {
 	iMalloc->astrdup =	aStrdup_;
 	iMalloc->free    =	aFree_;
 #endif
+	iMalloc->post_shutdown = NULL;
 }
diff --git a/src/common/malloc.h b/src/common/malloc.h
index 834781905..bc8aa9a20 100644
--- a/src/common/malloc.h
+++ b/src/common/malloc.h
@@ -67,18 +67,21 @@
 void malloc_defaults(void);
 
 struct malloc_interface {
+	void	(*init) (void);
+	void	(*final) (void);
+	/* */
 	void* (*malloc	)(size_t size, const char *file, int line, const char *func);
 	void* (*calloc	)(size_t num, size_t size, const char *file, int line, const char *func);
 	void* (*realloc	)(void *p, size_t size, const char *file, int line, const char *func);
 	char* (*astrdup	)(const char *p, const char *file, int line, const char *func);
 	void  (*free	)(void *p, const char *file, int line, const char *func);
-
+	/* */
 	void	(*memory_check)(void);
 	bool	(*verify_ptr)(void* ptr);
 	size_t	(*usage) (void);
-	void	(*init) (void);
-	void	(*final) (void);
-} iMalloc_s;
+	/* */
+	void (*post_shutdown) (void);
+};
 
 void memmgr_report (int extra);
 
diff --git a/src/common/socket.c b/src/common/socket.c
index f6d5849be..4f2e386ec 100644
--- a/src/common/socket.c
+++ b/src/common/socket.c
@@ -9,6 +9,7 @@
 #include "../common/showmsg.h"
 #include "../common/strlib.h"
 #include "../config/core.h"
+#include "../common/HPM.h"
 #include "socket.h"
 
 #include <stdio.h>
@@ -239,8 +240,6 @@ static time_t socket_data_last_tick = 0;
 // The connection is closed if it goes over the limit.
 #define WFIFO_MAX (1*1024*1024)
 
-struct socket_data* session[FD_SETSIZE];
-
 #ifdef SEND_SHORTLIST
 int send_shortlist_array[FD_SETSIZE];// we only support FD_SETSIZE sockets, limit the array to that
 int send_shortlist_count = 0;// how many fd's are in the shortlist
@@ -594,13 +593,15 @@ static int create_session(int fd, RecvFunc func_recv, SendFunc func_send, ParseF
 	session[fd]->func_parse = func_parse;
 	session[fd]->rdata_tick = last_tick;
 	session[fd]->session_data = NULL;
+	session[fd]->hdata = NULL;
+	session[fd]->hdatac = 0;
 	return 0;
 }
 
 static void delete_session(int fd)
 {
-	if( session_isValid(fd) )
-	{
+	if( session_isValid(fd) ) {
+		unsigned int i;
 #ifdef SHOW_SERVER_STATS
 		socket_data_qi -= session[fd]->rdata_size - session[fd]->rdata_pos;
 		socket_data_qo -= session[fd]->wdata_size;
@@ -609,6 +610,14 @@ static void delete_session(int fd)
 		aFree(session[fd]->wdata);
 		if( session[fd]->session_data )
 			aFree(session[fd]->session_data);
+		for(i = 0; i < session[fd]->hdatac; i++) {
+			if( session[fd]->hdata[i]->flag.free ) {
+				aFree(session[fd]->hdata[i]->data);
+				aFree(session[fd]->hdata[i]);
+			}
+		}
+		if( session[fd]->hdata )
+			aFree(session[fd]->hdata);
 		aFree(session[fd]);
 		session[fd] = NULL;
 	}
@@ -1214,6 +1223,8 @@ void socket_final(void)
 	aFree(session[0]->rdata);
 	aFree(session[0]->wdata);
 	aFree(session[0]);
+	
+	aFree(session);
 }
 
 /// Closes a socket.
@@ -1375,6 +1386,8 @@ void socket_init(void)
 	memset(send_shortlist_set, 0, sizeof(send_shortlist_set));
 #endif
 
+	CREATE(session, struct socket_data *, FD_SETSIZE);
+	
 	socket_config_read(SOCKET_CONF_FILENAME);
 
 	// initialise last send-receive tick
@@ -1392,6 +1405,11 @@ void socket_init(void)
 #endif
 
 	ShowInfo("Server supports up to '"CL_WHITE"%u"CL_RESET"' concurrent connections.\n", rlim_cur);
+	
+	/* Hercules Plugin Manager */
+	HPM->share(session,"session");
+	HPM->share(&fd_max,"fd_max");
+	HPM->share(addr_,"addr");
 }
 
 bool session_isValid(int fd)
diff --git a/src/common/socket.h b/src/common/socket.h
index 82f8b84c3..0e34da660 100644
--- a/src/common/socket.h
+++ b/src/common/socket.h
@@ -18,6 +18,8 @@
 
 #include <time.h>
 
+struct HPluginData;
+
 #define FIFOSIZE_SERVERLINK 256*1024
 
 // socket I/O macros
@@ -96,6 +98,9 @@ struct socket_data
 	ParseFunc func_parse;
 
 	void* session_data; // stores application-specific data related to the session
+	
+	struct HPluginData **hdata;
+	unsigned int hdatac;
 };
 
 struct hSockOpt {
@@ -105,7 +110,7 @@ struct hSockOpt {
 
 // Data prototype declaration
 
-extern struct socket_data* session[FD_SETSIZE];
+struct socket_data **session;
 
 extern int fd_max;