diff options
Diffstat (limited to 'src/socketengines')
| -rw-r--r-- | src/socketengines/socketengine_epoll.cpp | 164 | ||||
| -rw-r--r-- | src/socketengines/socketengine_iocp.cpp | 515 | ||||
| -rw-r--r-- | src/socketengines/socketengine_kqueue.cpp | 169 | ||||
| -rw-r--r-- | src/socketengines/socketengine_ports.cpp | 129 | ||||
| -rw-r--r-- | src/socketengines/socketengine_select.cpp | 165 |
5 files changed, 1142 insertions, 0 deletions
diff --git a/src/socketengines/socketengine_epoll.cpp b/src/socketengines/socketengine_epoll.cpp new file mode 100644 index 000000000..9da569b8f --- /dev/null +++ b/src/socketengines/socketengine_epoll.cpp @@ -0,0 +1,164 @@ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "exitcodes.h" +#include <sys/epoll.h> +#include "socketengines/socketengine_epoll.h" + +EPollEngine::EPollEngine(InspIRCd* Instance) : SocketEngine(Instance) +{ + EngineHandle = epoll_create(MAX_DESCRIPTORS); + + if (EngineHandle == -1) + { + ServerInstance->Log(SPARSE,"ERROR: Could not initialize socket engine: %s", strerror(errno)); + ServerInstance->Log(SPARSE,"ERROR: Your kernel probably does not have the proper features. This is a fatal error, exiting now."); + printf("ERROR: Could not initialize socket engine: %s\n", strerror(errno)); + printf("ERROR: Your kernel probably does not have the proper features. This is a fatal error, exiting now.\n"); + ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE); + } + CurrentSetSize = 0; +} + +EPollEngine::~EPollEngine() +{ + this->Close(EngineHandle); +} + +bool EPollEngine::AddFd(EventHandler* eh) +{ + int fd = eh->GetFd(); + if ((fd < 0) || (fd > MAX_DESCRIPTORS)) + { + ServerInstance->Log(DEBUG,"Out of range FD"); + return false; + } + + if (GetRemainingFds() <= 1) + return false; + + if (ref[fd]) + return false; + + struct epoll_event ev; + memset(&ev,0,sizeof(struct epoll_event)); + eh->Readable() ? ev.events = EPOLLIN : ev.events = EPOLLOUT; + ev.data.fd = fd; + int i = epoll_ctl(EngineHandle, EPOLL_CTL_ADD, fd, &ev); + if (i < 0) + { + return false; + } + + ServerInstance->Log(DEBUG,"New file descriptor: %d", fd); + + ref[fd] = eh; + CurrentSetSize++; + return true; +} + +void EPollEngine::WantWrite(EventHandler* eh) +{ + /** Use oneshot so that the system removes the writeable + * status for us and saves us a call. + */ + struct epoll_event ev; + memset(&ev,0,sizeof(struct epoll_event)); + ev.events = EPOLLOUT; + ev.data.fd = eh->GetFd(); + epoll_ctl(EngineHandle, EPOLL_CTL_MOD, eh->GetFd(), &ev); +} + +bool EPollEngine::DelFd(EventHandler* eh, bool force) +{ + int fd = eh->GetFd(); + if ((fd < 0) || (fd > MAX_DESCRIPTORS)) + return false; + + struct epoll_event ev; + memset(&ev,0,sizeof(struct epoll_event)); + eh->Readable() ? ev.events = EPOLLIN : ev.events = EPOLLOUT; + ev.data.fd = fd; + int i = epoll_ctl(EngineHandle, EPOLL_CTL_DEL, fd, &ev); + + if (i < 0 && !force) + { + ServerInstance->Log(DEBUG,"Cant remove socket: %s", strerror(errno)); + return false; + } + + ref[fd] = NULL; + CurrentSetSize--; + + ServerInstance->Log(DEBUG,"Remove file descriptor: %d", fd); + return true; +} + +int EPollEngine::GetMaxFds() +{ + return MAX_DESCRIPTORS; +} + +int EPollEngine::GetRemainingFds() +{ + return MAX_DESCRIPTORS - CurrentSetSize; +} + +int EPollEngine::DispatchEvents() +{ + socklen_t codesize; + int errcode; + int i = epoll_wait(EngineHandle, events, MAX_DESCRIPTORS, 1000); + for (int j = 0; j < i; j++) + { + if (events[j].events & EPOLLHUP) + { + if (ref[events[j].data.fd]) + ref[events[j].data.fd]->HandleEvent(EVENT_ERROR, 0); + continue; + } + if (events[j].events & EPOLLERR) + { + /* Get error number */ + if (getsockopt(events[j].data.fd, SOL_SOCKET, SO_ERROR, &errcode, &codesize) < 0) + errcode = errno; + if (ref[events[j].data.fd]) + ref[events[j].data.fd]->HandleEvent(EVENT_ERROR, errcode); + continue; + } + if (events[j].events & EPOLLOUT) + { + struct epoll_event ev; + memset(&ev,0,sizeof(struct epoll_event)); + ev.events = EPOLLIN; + ev.data.fd = events[j].data.fd; + epoll_ctl(EngineHandle, EPOLL_CTL_MOD, events[j].data.fd, &ev); + if (ref[events[j].data.fd]) + ref[events[j].data.fd]->HandleEvent(EVENT_WRITE); + } + else + { + if (ref[events[j].data.fd]) + ref[events[j].data.fd]->HandleEvent(EVENT_READ); + } + } + + return i; +} + +std::string EPollEngine::GetName() +{ + return "epoll"; +} + diff --git a/src/socketengines/socketengine_iocp.cpp b/src/socketengines/socketengine_iocp.cpp new file mode 100644 index 000000000..84371ca3a --- /dev/null +++ b/src/socketengines/socketengine_iocp.cpp @@ -0,0 +1,515 @@ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "socketengines/socketengine_iocp.h" +#include "exitcodes.h" +#include <mswsock.h> + +IOCPEngine::IOCPEngine(InspIRCd * Instance) : SocketEngine(Instance) +{ + /* Create completion port */ + m_completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, (ULONG_PTR)0, 0); + + if (!m_completionPort) + { + ServerInstance->Log(SPARSE,"ERROR: Could not initialize socket engine. Your kernel probably does not have the proper features."); + ServerInstance->Log(SPARSE,"ERROR: this is a fatal error, exiting now."); + printf("ERROR: Could not initialize socket engine. Your kernel probably does not have the proper features."); + printf("ERROR: this is a fatal error, exiting now."); + ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE); + } + + /* Null variables out. */ + CurrentSetSize = 0; + EngineHandle = 0; + memset(ref, 0, sizeof(EventHandler*) * MAX_DESCRIPTORS); +} + +IOCPEngine::~IOCPEngine() +{ + /* Clean up winsock and close completion port */ + CloseHandle(m_completionPort); + WSACleanup(); +} + +bool IOCPEngine::AddFd(EventHandler* eh) +{ + /* Does it at least look valid? */ + if (!eh) + return false; + + int* fake_fd = new int(GenerateFd(eh->GetFd())); + int is_accept = 0; + int opt_len = sizeof(int); + + /* In range? */ + if ((*fake_fd < 0) || (*fake_fd > MAX_DESCRIPTORS)) + { + delete fake_fd; + return false; + } + + /* Already an entry here */ + if (ref[*fake_fd]) + { + delete fake_fd; + return false; + } + + /* are we a listen socket? */ + getsockopt(eh->GetFd(), SOL_SOCKET, SO_ACCEPTCONN, (char*)&is_accept, &opt_len); + + /* set up the read event so the socket can actually receive data :P */ + eh->Extend("internal_fd", fake_fd); + + unsigned long completion_key = (ULONG_PTR)*fake_fd; + /* assign the socket to the completion port */ + if (!CreateIoCompletionPort((HANDLE)eh->GetFd(), m_completionPort, completion_key, 0)) + return false; + + /* setup initial events */ + if(is_accept) + PostAcceptEvent(eh); + else + PostReadEvent(eh); + + /* log message */ + ServerInstance->Log(DEBUG, "New fake fd: %u, real fd: %u, address 0x%p", *fake_fd, eh->GetFd(), eh); + + /* post a write event if there is data to be written */ + if(eh->Writeable()) + WantWrite(eh); + + /* we're all good =) */ + try + { + m_binding.insert( map<int, EventHandler*>::value_type( eh->GetFd(), eh ) ); + } + catch (...) + { + /* Ohshi-, map::insert failed :/ */ + return false; + } + + ++CurrentSetSize; + ref[*fake_fd] = eh; + + return true; +} + +bool IOCPEngine::DelFd(EventHandler* eh, bool force /* = false */) +{ + if (!eh) + return false; + + int* fake_fd = NULL; + + if (!eh->GetExt("internal_fd", fake_fd)) + return false; + + int fd = eh->GetFd(); + + void* m_readEvent = NULL; + void* m_writeEvent = NULL; + void* m_acceptEvent = NULL; + + ServerInstance->Log(DEBUG, "Removing fake fd %u, real fd %u, address 0x%p", *fake_fd, eh->GetFd(), eh); + + /* Cancel pending i/o operations. */ + if (CancelIo((HANDLE)fd) == FALSE) + return false; + + /* Free the buffer, and delete the event. */ + if (eh->GetExt("windows_readevent", m_readEvent)) + { + if(((Overlapped*)m_readEvent)->m_params != 0) + delete ((udp_overlap*)((Overlapped*)m_readEvent)->m_params); + + delete ((Overlapped*)m_readEvent); + eh->Shrink("windows_readevent"); + } + + if(eh->GetExt("windows_writeevent", m_writeEvent)) + { + delete ((Overlapped*)m_writeEvent); + eh->Shrink("windows_writeevent"); + } + + if(eh->GetExt("windows_acceptevent", m_acceptEvent)) + { + delete ((accept_overlap*)((Overlapped*)m_acceptEvent)->m_params); + delete ((Overlapped*)m_acceptEvent); + eh->Shrink("windows_accepevent"); + } + + /* Clear binding */ + ref[*fake_fd] = 0; + m_binding.erase(eh->GetFd()); + + delete fake_fd; + eh->Shrink("internal_fd"); + + /* decrement set size */ + --CurrentSetSize; + + /* success */ + return true; +} + +void IOCPEngine::WantWrite(EventHandler* eh) +{ + if (!eh) + return; + + void* m_writeEvent = NULL; + + int* fake_fd = NULL; + if (!eh->GetExt("internal_fd", fake_fd)) + return; + + /* Post event - write begin */ + if(!eh->GetExt("windows_writeevent", m_writeEvent)) + { + ULONG_PTR completion_key = (ULONG_PTR)*fake_fd; + Overlapped * ov = new Overlapped(SOCKET_IO_EVENT_WRITE_READY, 0); + eh->Shrink("windows_writeevent"); + eh->Extend("windows_writeevent",ov); + PostQueuedCompletionStatus(m_completionPort, 0, completion_key, &ov->m_overlap); + } +} + +bool IOCPEngine::PostCompletionEvent(EventHandler * eh, SocketIOEvent type, int param) +{ + if (!eh) + return false; + + int* fake_fd = NULL; + if (!eh->GetExt("internal_fd", fake_fd)) + return false; + + Overlapped * ov = new Overlapped(type, param); + ULONG_PTR completion_key = (ULONG_PTR)*fake_fd; + return PostQueuedCompletionStatus(m_completionPort, 0, completion_key, &ov->m_overlap); +} + +void IOCPEngine::PostReadEvent(EventHandler * eh) +{ + if (!eh) + return; + + Overlapped * ov = new Overlapped(SOCKET_IO_EVENT_READ_READY, 0); + DWORD flags = 0; + DWORD r_length = 0; + WSABUF buf; + + /* by passing a null buffer pointer, we can have this working in the same way as epoll.. + * its slower, but it saves modifying all network code. + */ + buf.buf = 0; + buf.len = 0; + + /* determine socket type. */ + DWORD sock_type; + int sock_len = sizeof(DWORD); + if(getsockopt(eh->GetFd(), SOL_SOCKET, SO_TYPE, (char*)&sock_type, &sock_len) == -1) + { + /* wtfhax? */ + PostCompletionEvent(eh, SOCKET_IO_EVENT_ERROR, 0); + delete ov; + return; + } + switch(sock_type) + { + case SOCK_DGRAM: /* UDP Socket */ + { + udp_overlap * uv = new udp_overlap; + uv->udp_sockaddr_len = sizeof(sockaddr); + buf.buf = (char*)uv->udp_buffer; + buf.len = sizeof(uv->udp_buffer); + ov->m_params = (unsigned long)uv; + if(WSARecvFrom(eh->GetFd(), &buf, 1, &uv->udp_len, &flags, uv->udp_sockaddr, (LPINT)&uv->udp_sockaddr_len, &ov->m_overlap, 0)) + { + int err = WSAGetLastError(); + if(err != WSA_IO_PENDING) + { + delete ov; + PostCompletionEvent(eh, SOCKET_IO_EVENT_ERROR, 0); + return; + } + } + } + break; + + case SOCK_STREAM: /* TCP Socket */ + { + if(WSARecv(eh->GetFd(), &buf, 1, &r_length, &flags, &ov->m_overlap, 0) == SOCKET_ERROR) + { + if(WSAGetLastError() != WSA_IO_PENDING) + { + delete ov; + PostCompletionEvent(eh, SOCKET_IO_EVENT_ERROR, 0); + return; + } + } + } + break; + + default: + { + printf("unknwon socket type: %u\n", sock_type); + return; + } + break; + } + eh->Extend("windows_readevent", ov); +} + +int IOCPEngine::DispatchEvents() +{ + DWORD len; + LPOVERLAPPED overlap; + Overlapped * ov; + EventHandler * eh; + ULONG_PTR intfd; + int ret; + unsigned long bytes_recv; + + while (GetQueuedCompletionStatus(m_completionPort, &len, &intfd, &overlap, 1000)) + { + if (intfd < 0 || intfd > MAX_DESCRIPTORS) + continue; + + // woot, we got an event on a socket :P + eh = ref[intfd]; + ov = CONTAINING_RECORD(overlap, Overlapped, m_overlap); + + if (eh == 0) + continue; + + void* m_readEvent = NULL; + void* m_writeEvent = NULL; + + eh->GetExt("windows_readevent", m_readEvent); + eh->GetExt("windows_writeevent", m_writeEvent); + + switch(ov->m_event) + { + case SOCKET_IO_EVENT_WRITE_READY: + { + eh->Shrink("windows_writeevent"); + eh->HandleEvent(EVENT_WRITE, 0); + } + break; + + case SOCKET_IO_EVENT_READ_READY: + { + if(ov->m_params) + { + // if we had params, it means we are a udp socket with a udp_overlap pointer in this long. + udp_overlap * uv = (udp_overlap*)ov->m_params; + uv->udp_len = len; + this->udp_ov = uv; + eh->Shrink("windows_readevent"); + eh->HandleEvent(EVENT_READ, 0); + this->udp_ov = 0; + delete uv; + PostReadEvent(eh); + } + else + { + ret = ioctlsocket(eh->GetFd(), FIONREAD, &bytes_recv); + eh->Shrink("windows_readevent"); + if(ret != 0 || bytes_recv == 0) + { + /* end of file */ + PostCompletionEvent(eh, SOCKET_IO_EVENT_ERROR, EIO); /* Old macdonald had an error, EIEIO. */ + } + else + { + eh->HandleEvent(EVENT_READ, 0); + PostReadEvent(eh); + } + } + } + break; + + case SOCKET_IO_EVENT_ACCEPT: + { + /* this is kinda messy.. :/ */ + eh->HandleEvent(EVENT_READ, ov->m_params); + delete ((accept_overlap*)ov->m_params); + eh->Shrink("windows_acceptevent"); + PostAcceptEvent(eh); + } + break; + + case SOCKET_IO_EVENT_ERROR: + { + eh->HandleEvent(EVENT_ERROR, ov->m_params); + } + break; + } + + delete ov; + } + + return 0; +} + +void IOCPEngine::PostAcceptEvent(EventHandler * eh) +{ + if (!eh) + return; + + int on = 1; + u_long arg = 1; + struct linger linger = { 0 }; + + int fd = WSASocket(AF_INET, SOCK_STREAM, 0, 0, 0, WSA_FLAG_OVERLAPPED); + + setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on)); + /* This is BSD compatible, setting l_onoff to 0 is *NOT* http://web.irc.org/mla/ircd-dev/msg02259.html */ + linger.l_onoff = 1; + linger.l_linger = 1; + setsockopt(fd, SOL_SOCKET, SO_LINGER, (char*)&linger,sizeof(linger)); + ioctlsocket(fd, FIONBIO, &arg); + + int len = sizeof(sockaddr_in) + 16; + DWORD dwBytes; + accept_overlap* ao = new accept_overlap; + memset(ao->buf, 0, 1024); + ao->socket = fd; + + Overlapped* ov = new Overlapped(SOCKET_IO_EVENT_ACCEPT, (int)ao); + eh->Extend("windows_acceptevent", ov); + + if(AcceptEx(eh->GetFd(), fd, ao->buf, 0, len, len, &dwBytes, &ov->m_overlap) == FALSE) + { + int err = WSAGetLastError(); + if(err != WSA_IO_PENDING) + { + printf("PostAcceptEvent err: %d\n", err); + } + } +} + + +std::string IOCPEngine::GetName() +{ + return "iocp"; +} + +EventHandler * IOCPEngine::GetRef(int fd) +{ + map<int, EventHandler*>::iterator itr = m_binding.find(fd); + return (itr == m_binding.end()) ? 0 : itr->second; +} + +bool IOCPEngine::HasFd(int fd) +{ + return (GetRef(fd) != 0); +} + +bool IOCPEngine::BoundsCheckFd(EventHandler* eh) +{ + int * internal_fd; + if (!eh || eh->GetFd() < 0) + return false; + + if(!eh->GetExt("internal_fd", internal_fd)) + return false; + + if(*internal_fd > MAX_DESCRIPTORS) + return false; + + return true; +} + +EventHandler * IOCPEngine::GetIntRef(int fd) +{ + if(fd < 0 || fd > MAX_DESCRIPTORS) + return 0; + return ref[fd]; +} + +int IOCPEngine::Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen) +{ + SOCKET s = fd->GetFd(); + + Overlapped* acceptevent = NULL; + if (!fd->GetExt("windows_acceptevent", acceptevent)) + /* Shit, no accept event on this socket! :( */ + return -1; + + Overlapped* ovl = acceptevent; + accept_overlap* ov = (accept_overlap*)ovl->m_params; + + sockaddr_in* server_address = (sockaddr_in*)&ov->buf[10]; + sockaddr_in* client_address = (sockaddr_in*)&ov->buf[38]; + + memcpy(addr, client_address, sizeof(sockaddr_in)); + *addrlen = sizeof(sockaddr_in); + + return ov->socket; +} + +int IOCPEngine::GetSockName(EventHandler* fd, sockaddr *name, socklen_t* namelen) +{ + Overlapped* ovl = NULL; + + if (!fd->GetExt("windows_acceptevent", ovl)) + return -1; + + accept_overlap* ov = (accept_overlap*)ovl->m_params; + + sockaddr_in* server_address = (sockaddr_in*)&ov->buf[10]; + sockaddr_in* client_address = (sockaddr_in*)&ov->buf[38]; + + memcpy(name, server_address, sizeof(sockaddr_in)); + *namelen = sizeof(sockaddr_in); + + return 0; +} + +int IOCPEngine::RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen) +{ + udp_overlap * ov = NULL; + if (!fd->GetExt("windows_readevent", ov)) + return -1; + memcpy(buf, ov->udp_buffer, ov->udp_len); + memcpy(from, ov->udp_sockaddr, *fromlen); + return ov->udp_len; +} + +int IOCPEngine::Blocking(int fd) +{ + unsigned long opt = 0; + return ioctlsocket(fd, FIONBIO, &opt); +} + +int IOCPEngine::NonBlocking(int fd) +{ + unsigned long opt = 1; + return ioctlsocket(fd, FIONBIO, &opt); +} + +int IOCPEngine::Close(int fd) +{ + return closesocket(fd); +} + +int IOCPEngine::Close(EventHandler* fd) +{ + return this->Close(fd->GetFd()); +} + diff --git a/src/socketengines/socketengine_kqueue.cpp b/src/socketengines/socketengine_kqueue.cpp new file mode 100644 index 000000000..18a2261ef --- /dev/null +++ b/src/socketengines/socketengine_kqueue.cpp @@ -0,0 +1,169 @@ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "exitcodes.h" +#include <sys/types.h> +#include <sys/event.h> +#include <sys/time.h> +#include "socketengines/socketengine_kqueue.h" + + +KQueueEngine::KQueueEngine(InspIRCd* Instance) : SocketEngine(Instance) +{ + this->RecoverFromFork(); +} + +void KQueueEngine::RecoverFromFork() +{ + /* + * The only bad thing about kqueue is that its fd cant survive a fork and is not inherited. + * BUM HATS. + * + */ + EngineHandle = kqueue(); + if (EngineHandle == -1) + { + ServerInstance->Log(SPARSE,"ERROR: Could not initialize socket engine. Your kernel probably does not have the proper features."); + ServerInstance->Log(SPARSE,"ERROR: this is a fatal error, exiting now."); + printf("ERROR: Could not initialize socket engine. Your kernel probably does not have the proper features."); + printf("ERROR: this is a fatal error, exiting now."); + ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE); + } + CurrentSetSize = 0; +} + +KQueueEngine::~KQueueEngine() +{ + this->Close(EngineHandle); +} + +bool KQueueEngine::AddFd(EventHandler* eh) +{ + int fd = eh->GetFd(); + + if ((fd < 0) || (fd > MAX_DESCRIPTORS)) + return false; + + if (GetRemainingFds() <= 1) + return false; + + if (ref[fd]) + return false; + + struct kevent ke; + EV_SET(&ke, fd, eh->Readable() ? EVFILT_READ : EVFILT_WRITE, EV_ADD, 0, 0, NULL); + + int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL); + if (i == -1) + { + return false; + } + + ref[fd] = eh; + CurrentSetSize++; + + ServerInstance->Log(DEBUG,"New file descriptor: %d", fd); + return true; +} + +bool KQueueEngine::DelFd(EventHandler* eh, bool force) +{ + int fd = eh->GetFd(); + + if ((fd < 0) || (fd > MAX_DESCRIPTORS)) + return false; + + struct kevent ke; + EV_SET(&ke, eh->GetFd(), EVFILT_READ, EV_DELETE, 0, 0, NULL); + + int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL); + + EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_DELETE, 0, 0, NULL); + + int j = kevent(EngineHandle, &ke, 1, 0, 0, NULL); + + if ((j < 0) && (i < 0) && !force) + return false; + + CurrentSetSize--; + ref[fd] = NULL; + + ServerInstance->Log(DEBUG,"Remove file descriptor: %d", fd); + return true; +} + +void KQueueEngine::WantWrite(EventHandler* eh) +{ + /** When changing an item in a kqueue, there is no 'modify' call + * as in epoll. Instead, we add the item again, and this overwrites + * the original setting rather than adding it twice. See man kqueue. + */ + struct kevent ke; + EV_SET(&ke, eh->GetFd(), EVFILT_WRITE, EV_ADD | EV_ONESHOT, 0, 0, NULL); + kevent(EngineHandle, &ke, 1, 0, 0, NULL); +} + +int KQueueEngine::GetMaxFds() +{ + return MAX_DESCRIPTORS; +} + +int KQueueEngine::GetRemainingFds() +{ + return MAX_DESCRIPTORS - CurrentSetSize; +} + +int KQueueEngine::DispatchEvents() +{ + ts.tv_nsec = 0; + ts.tv_sec = 1; + int i = kevent(EngineHandle, NULL, 0, &ke_list[0], MAX_DESCRIPTORS, &ts); + for (int j = 0; j < i; j++) + { + if (ke_list[j].flags & EV_EOF) + { + /* We love you kqueue, oh yes we do *sings*! + * kqueue gives us the error number directly in the EOF state! + * Unlike smelly epoll and select, where we have to getsockopt + * to get the error, this saves us time and cpu cycles. Go BSD! + */ + if (ref[ke_list[j].ident]) + ref[ke_list[j].ident]->HandleEvent(EVENT_ERROR, ke_list[j].fflags); + continue; + } + if (ke_list[j].flags & EVFILT_WRITE) + { + /* This looks wrong but its right. As above, theres no modify + * call in kqueue. See the manpage. + */ + struct kevent ke; + EV_SET(&ke, ke_list[j].ident, EVFILT_READ, EV_ADD, 0, 0, NULL); + kevent(EngineHandle, &ke, 1, 0, 0, NULL); + if (ref[ke_list[j].ident]) + ref[ke_list[j].ident]->HandleEvent(EVENT_WRITE); + } + else + { + if (ref[ke_list[j].ident]) + ref[ke_list[j].ident]->HandleEvent(EVENT_READ); + } + } + + return i; +} + +std::string KQueueEngine::GetName() +{ + return "kqueue"; +} diff --git a/src/socketengines/socketengine_ports.cpp b/src/socketengines/socketengine_ports.cpp new file mode 100644 index 000000000..ecaec5070 --- /dev/null +++ b/src/socketengines/socketengine_ports.cpp @@ -0,0 +1,129 @@ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include "exitcodes.h" +#include <port.h> +#include "socketengines/socketengine_ports.h" + +PortsEngine::PortsEngine(InspIRCd* Instance) : SocketEngine(Instance) +{ + EngineHandle = port_create(); + + if (EngineHandle == -1) + { + ServerInstance->Log(SPARSE,"ERROR: Could not initialize socket engine: %s", strerror(errno)); + ServerInstance->Log(SPARSE,"ERROR: This is a fatal error, exiting now."); + printf("ERROR: Could not initialize socket engine: %s\n", strerror(errno)); + printf("ERROR: This is a fatal error, exiting now.\n"); + ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE); + } + CurrentSetSize = 0; +} + +PortsEngine::~PortsEngine() +{ + this->Close(EngineHandle); +} + +bool PortsEngine::AddFd(EventHandler* eh) +{ + int fd = eh->GetFd(); + if ((fd < 0) || (fd > MAX_DESCRIPTORS)) + return false; + + if (GetRemainingFds() <= 1) + return false; + + if (ref[fd]) + return false; + + ref[fd] = eh; + port_associate(EngineHandle, PORT_SOURCE_FD, fd, eh->Readable() ? POLLRDNORM : POLLWRNORM, eh); + + ServerInstance->Log(DEBUG,"New file descriptor: %d", fd); + CurrentSetSize++; + return true; +} + +void PortsEngine::WantWrite(EventHandler* eh) +{ + port_associate(EngineHandle, PORT_SOURCE_FD, eh->GetFd(), POLLWRNORM, eh); +} + +bool PortsEngine::DelFd(EventHandler* eh, bool force) +{ + int fd = eh->GetFd(); + if ((fd < 0) || (fd > MAX_DESCRIPTORS)) + return false; + + port_dissociate(EngineHandle, PORT_SOURCE_FD, fd); + + CurrentSetSize--; + ref[fd] = NULL; + + ServerInstance->Log(DEBUG,"Remove file descriptor: %d", fd); + return true; +} + +int PortsEngine::GetMaxFds() +{ + return MAX_DESCRIPTORS; +} + +int PortsEngine::GetRemainingFds() +{ + return MAX_DESCRIPTORS - CurrentSetSize; +} + +int PortsEngine::DispatchEvents() +{ + struct timespec poll_time; + + poll_time.tv_sec = 1; + poll_time.tv_nsec = 0; + + unsigned int nget = 1; // used to denote a retrieve request. + int i = port_getn(EngineHandle, this->events, MAX_DESCRIPTORS, &nget, &poll_time); + + // first handle an error condition + if (i == -1) + return i; + + for (i = 0; i < nget; i++) + { + switch (this->events[i].portev_source) + { + case PORT_SOURCE_FD: + { + int fd = this->events[i].portev_object; + if (ref[fd]) + { + // reinsert port for next time around + port_associate(EngineHandle, PORT_SOURCE_FD, fd, POLLRDNORM, ref[fd]); + ref[fd]->HandleEvent((this->events[i].portev_events & POLLRDNORM) ? EVENT_READ : EVENT_WRITE); + } + } + default: + break; + } + } + + return i; +} + +std::string PortsEngine::GetName() +{ + return "ports"; +} + diff --git a/src/socketengines/socketengine_select.cpp b/src/socketengines/socketengine_select.cpp new file mode 100644 index 000000000..1fe138f14 --- /dev/null +++ b/src/socketengines/socketengine_select.cpp @@ -0,0 +1,165 @@ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#include "inspircd.h" +#include <sys/select.h> +#include "socketengines/socketengine_select.h" + + +SelectEngine::SelectEngine(InspIRCd* Instance) : SocketEngine(Instance) +{ + EngineHandle = 0; + CurrentSetSize = 0; + memset(writeable, 0, sizeof(writeable)); +} + +SelectEngine::~SelectEngine() +{ +} + +bool SelectEngine::AddFd(EventHandler* eh) +{ + int fd = eh->GetFd(); + if ((fd < 0) || (fd > MAX_DESCRIPTORS)) + return false; + + if (GetRemainingFds() <= 1) + return false; + + if (ref[fd]) + return false; + + fds[fd] = fd; + ref[fd] = eh; + CurrentSetSize++; + + ServerInstance->Log(DEBUG,"New file descriptor: %d", fd); + return true; +} + +void SelectEngine::WantWrite(EventHandler* eh) +{ + writeable[eh->GetFd()] = true; +} + +bool SelectEngine::DelFd(EventHandler* eh, bool force) +{ + int fd = eh->GetFd(); + + if ((fd < 0) || (fd > MAX_DESCRIPTORS)) + return false; + + std::map<int,int>::iterator t = fds.find(fd); + if (t != fds.end()) + fds.erase(t); + + CurrentSetSize--; + ref[fd] = NULL; + fds[fd] = 0; + + ServerInstance->Log(DEBUG,"Remove file descriptor: %d", fd); + return true; +} + +int SelectEngine::GetMaxFds() +{ + return FD_SETSIZE; +} + +int SelectEngine::GetRemainingFds() +{ + return FD_SETSIZE - CurrentSetSize; +} + +int SelectEngine::DispatchEvents() +{ + int result = 0; + timeval tval; + int sresult = 0; + EventHandler* ev[MAX_DESCRIPTORS]; + socklen_t codesize; + int errcode; + + FD_ZERO(&wfdset); + FD_ZERO(&rfdset); + FD_ZERO(&errfdset); + + for (std::map<int,int>::iterator a = fds.begin(); a != fds.end(); a++) + { + if (ref[a->second]->Readable()) + FD_SET (a->second, &rfdset); + else + FD_SET (a->second, &wfdset); + if (writeable[a->second]) + FD_SET (a->second, &wfdset); + + FD_SET (a->second, &errfdset); + } + tval.tv_sec = 1; + tval.tv_usec = 0; + sresult = select(FD_SETSIZE, &rfdset, &wfdset, &errfdset, &tval); + if (sresult > 0) + { + for (std::map<int,int>::iterator a = fds.begin(); a != fds.end(); a++) + { + if ((FD_ISSET (a->second, &rfdset)) || (FD_ISSET (a->second, &wfdset)) || FD_ISSET (a->second, &errfdset)) + { + ev[result++] = ref[a->second]; + } + } + } + + /** An event handler may remove its own descriptor from the list, therefore it is not + * safe to directly iterate over the list and dispatch events there with STL iterators. + * Thats a shame because it makes this code slower and more resource intensive, but maybe + * the user should stop using select(), as select() smells anyway. + */ + for (int i = 0; i < result; i++) + { + if (ev[i]) + { + if (FD_ISSET (ev[i]->GetFd(), &errfdset)) + { + if (ev[i]) + { + if (getsockopt(ev[i]->GetFd(), SOL_SOCKET, SO_ERROR, &errcode, &codesize) < 0) + errcode = errno; + + ev[i]->HandleEvent(EVENT_ERROR, errcode); + } + continue; + } + if (ev[i]) + { + if (writeable[ev[i]->GetFd()]) + { + writeable[ev[i]->GetFd()] = false; + if (ev[i]) + ev[i]->HandleEvent(EVENT_WRITE); + } + else + { + if (ev[i]) + ev[i]->HandleEvent(ev[i]->Readable() ? EVENT_READ : EVENT_WRITE); + } + } + } + } + + return result; +} + +std::string SelectEngine::GetName() +{ + return "select"; +} |