Moved some files and diretories around, made cmake skip files it knows it can't compile because of missing dependices.

2 files changed, 291 insertions, 0 deletions

diff --git a/modules/socketengines/m_socketengine_epoll.cpp b/modules/socketengines/m_socketengine_epoll.cpp
new file mode 100644
index 000000000..c5e152af3
--- /dev/null
+++ b/modules/socketengines/m_socketengine_epoll.cpp
@@ -0,0 +1,157 @@
+/* RequiredFunctions: epoll_wait */
+
+#include "module.h"
+#include <sys/epoll.h>
+#include <ulimit.h>
+
+class SocketEngineEPoll : public SocketEngineBase
+{
+ private:
+	long max;
+	int EngineHandle;
+	epoll_event *events;
+	unsigned SocketCount;
+
+ public:
+	SocketEngineEPoll()
+	{
+		SocketCount = 0;
+		max = ulimit(4, 0);
+		
+		if (max <= 0)
+		{
+			Alog() << "Can't determine maximum number of open sockets";
+			throw ModuleException("Can't determine maximum number of open sockets");
+		}
+
+		EngineHandle = epoll_create(max / 4);
+
+		if (EngineHandle == -1)
+		{
+			Alog() << "Could not initialize epoll socket engine: " << strerror(errno);
+			throw ModuleException("Could not initialize epoll socket engine: " + std::string(strerror(errno)));
+		}
+
+		events = new epoll_event[max];
+		memset(events, 0, sizeof(epoll_event) * max);
+	}
+
+	~SocketEngineEPoll()
+	{
+		delete [] events;
+	}
+
+	void AddSocket(Socket *s)
+	{
+		epoll_event ev;
+		
+		memset(&ev, 0, sizeof(ev));
+
+		ev.events = EPOLLIN | EPOLLOUT;
+		ev.data.fd = s->GetSock();
+
+		if (epoll_ctl(EngineHandle, EPOLL_CTL_ADD, ev.data.fd, &ev) == -1)
+		{
+			Alog() << "Unable to add fd " << ev.data.fd << " to socketengine epoll: " << strerror(errno);
+			return;
+		}
+
+		Sockets.insert(std::make_pair(ev.data.fd, s));
+
+		++SocketCount;
+	}
+
+	void DelSocket(Socket *s)
+	{
+		epoll_event ev;
+
+		memset(&ev, 0, sizeof(ev));
+
+		ev.data.fd = s->GetSock();
+
+		if (epoll_ctl(EngineHandle, EPOLL_CTL_DEL, ev.data.fd, &ev) == -1)
+		{
+			Alog() << "Unable to delete fd " << ev.data.fd << " from socketengine epoll: " << strerror(errno);
+			return;
+		}
+
+		Sockets.erase(ev.data.fd);
+
+		--SocketCount;
+	}
+
+	void Process()
+	{
+		int total = epoll_wait(EngineHandle, events, max - 1, (Config.ReadTimeout * 1000));
+
+		if (total == -1)
+		{
+			Alog() << "SockEngine::Process(): error " << strerror(errno);
+			return;
+		}
+
+		for (int i = 0; i < total; ++i)
+		{
+			epoll_event *ev = &events[i];
+			Socket *s = Sockets[ev->data.fd];
+
+			if (ev->events & (EPOLLHUP | EPOLLERR))
+			{
+				s->ProcessError();
+				s->SetFlag(SF_DEAD);
+				continue;
+			}
+
+			if (ev->events & EPOLLIN)
+			{
+				if (!s->ProcessRead())
+				{
+					s->SetFlag(SF_DEAD);
+				}
+			}
+
+			if (ev->events & EPOLLOUT)
+			{
+				if (!s->ProcessWrite())
+				{
+					s->SetFlag(SF_DEAD);
+				}
+			}
+		}
+
+		for (std::map<int, Socket *>::iterator it = Sockets.begin(), it_end = Sockets.end(); it != it_end;)
+		{
+			Socket *s = it->second;
+			++it;
+
+			if (s->HasFlag(SF_DEAD))
+			{
+				delete s;
+			}
+		}
+	}
+};
+
+class ModuleSocketEngineEPoll : public Module
+{
+	SocketEngineEPoll *engine;
+
+ public:
+	ModuleSocketEngineEPoll(const std::string &modname, const std::string &creator) : Module(modname, creator)
+	{
+		this->SetPermanent(true);
+		this->SetType(SOCKETENGINE);
+
+		engine = new SocketEngineEPoll();
+		SocketEngine = engine;
+	}
+
+	~ModuleSocketEngineEPoll()
+	{
+		delete engine;
+		SocketEngine = NULL;
+	}
+};
+
+MODULE_INIT(ModuleSocketEngineEPoll)
+
diff --git a/modules/socketengines/m_socketengine_select.cpp b/modules/socketengines/m_socketengine_select.cpp
new file mode 100644
index 000000000..c7346f87c
--- /dev/null
+++ b/modules/socketengines/m_socketengine_select.cpp
@@ -0,0 +1,134 @@
+#include "module.h"
+
+class SocketEngineSelect : public SocketEngineBase
+{
+ private:
+ 	/* Max Read FD */
+	int MaxFD;
+	/* Read FDs */
+	fd_set ReadFDs;
+	/* Write FDs */
+	fd_set WriteFDs;
+
+ public:
+	SocketEngineSelect()
+	{
+		MaxFD = 0;
+		FD_ZERO(&ReadFDs);
+		FD_ZERO(&WriteFDs);
+	}
+
+	~SocketEngineSelect()
+	{
+		FD_ZERO(&ReadFDs);
+		FD_ZERO(&WriteFDs);
+	}
+
+	void AddSocket(Socket *s)
+	{
+		if (s->GetSock() > MaxFD)
+			MaxFD = s->GetSock();
+		FD_SET(s->GetSock(), &ReadFDs);
+		Sockets.insert(std::make_pair(s->GetSock(), s));
+	}
+
+	void DelSocket(Socket *s)
+	{
+		if (s->GetSock() == MaxFD)
+			--MaxFD;
+		FD_CLR(s->GetSock(), &ReadFDs);
+		FD_CLR(s->GetSock(), &WriteFDs);
+		Sockets.erase(s->GetSock());
+	}
+
+	void MarkWriteable(Socket *s)
+	{
+		FD_SET(s->GetSock(), &WriteFDs);
+	}
+
+	void ClearWriteable(Socket *s)
+	{
+		FD_CLR(s->GetSock(), &WriteFDs);
+	}
+
+	void Process()
+	{
+		fd_set rfdset = ReadFDs, wfdset = WriteFDs, efdset = ReadFDs;
+		timeval tval;
+		tval.tv_sec = Config.ReadTimeout;
+		tval.tv_usec = 0;
+
+		int sresult = select(MaxFD + 1, &rfdset, &wfdset, &efdset, &tval);
+
+		if (sresult == -1)
+		{
+#ifdef WIN32
+			errno = WSAGetLastError();
+#endif
+			Alog() << "SockEngine::Process(): error" << strerror(errno);
+		}
+		else if (sresult)
+		{
+			for (std::map<int, Socket *>::const_iterator it = Sockets.begin(), it_end = Sockets.end(); it != it_end; ++it)
+			{
+				Socket *s = it->second;
+
+				if (FD_ISSET(s->GetSock(), &efdset))
+				{
+					s->ProcessError();
+					s->SetFlag(SF_DEAD);
+					continue;
+				}
+				if (FD_ISSET(s->GetSock(), &rfdset))
+				{
+					if (!s->ProcessRead())
+					{
+						s->SetFlag(SF_DEAD);
+					}
+				}
+				if (FD_ISSET(s->GetSock(), &wfdset))
+				{
+					if (!s->ProcessWrite())
+					{
+						s->SetFlag(SF_DEAD);
+					}
+				}
+			}
+
+			for (std::map<int, Socket *>::iterator it = Sockets.begin(), it_end = Sockets.end(); it != it_end;)
+			{
+				Socket *s = it->second;
+				++it;
+
+				if (s->HasFlag(SF_DEAD))
+				{
+					delete s;
+				}
+			}
+		}
+	}
+};
+
+class ModuleSocketEngineSelect : public Module
+{
+	SocketEngineSelect *engine;
+
+ public:
+	ModuleSocketEngineSelect(const std::string &modname, const std::string &creator) : Module(modname, creator)
+	{
+		this->SetPermanent(true);
+		this->SetType(SOCKETENGINE);
+
+		engine = new SocketEngineSelect();
+		SocketEngine = engine;
+	}
+
+	~ModuleSocketEngineSelect()
+	{
+		delete engine;
+		SocketEngine = NULL;
+	}
+};
+
+MODULE_INIT(ModuleSocketEngineSelect)
+