X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fsocketengines%2Fsocketengine_select.cpp;h=0b5abaf304792b6d14978992ec1aa53d1cb77b86;hb=571714e28b26cc59cbc8d27098a5ba981240ee2d;hp=7f6a4e283742dc1bb1f3e0ede9b050704426d793;hpb=e2af2347fc035d702e45f12e772223a8d578410d;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/socketengines/socketengine_select.cpp b/src/socketengines/socketengine_select.cpp index 7f6a4e283..0b5abaf30 100644 --- a/src/socketengines/socketengine_select.cpp +++ b/src/socketengines/socketengine_select.cpp @@ -1,32 +1,65 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2009 InspIRCd Development Team - * See: http://wiki.inspircd.org/Credits + * Copyright (C) 2009 Daniel De Graaf + * Copyright (C) 2007-2008 Craig Edwards * - * This program is free but copyrighted software; see - * the file COPYING for details. + * This file is part of InspIRCd. InspIRCd 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, version 2. * - * --------------------------------------------------- + * 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 . */ + +#include "inspircd_config.h" + #include "inspircd.h" -#ifndef WINDOWS +#include "socketengine.h" + +#ifndef _WIN32 #include -#endif // WINDOWS -#include "socketengines/socketengine_select.h" +#endif // _WIN32 +/** A specialisation of the SocketEngine class, designed to use traditional select(). + */ +class SelectEngine : public SocketEngine +{ + fd_set ReadSet, WriteSet, ErrSet; + int MaxFD; + +public: + /** Create a new SelectEngine + */ + SelectEngine(); + /** Delete a SelectEngine + */ + virtual ~SelectEngine(); + virtual bool AddFd(EventHandler* eh, int event_mask); + virtual void DelFd(EventHandler* eh); + void OnSetEvent(EventHandler* eh, int, int); + virtual int DispatchEvents(); + virtual std::string GetName(); +}; SelectEngine::SelectEngine() { MAX_DESCRIPTORS = FD_SETSIZE; - EngineHandle = 0; CurrentSetSize = 0; - writeable.assign(GetMaxFds(), false); ref = new EventHandler* [GetMaxFds()]; memset(ref, 0, GetMaxFds() * sizeof(EventHandler*)); + + FD_ZERO(&ReadSet); + FD_ZERO(&WriteSet); + FD_ZERO(&ErrSet); + MaxFD = 0; } SelectEngine::~SelectEngine() @@ -34,128 +67,124 @@ SelectEngine::~SelectEngine() delete[] ref; } -bool SelectEngine::AddFd(EventHandler* eh, bool writeFirst) +bool SelectEngine::AddFd(EventHandler* eh, int event_mask) { int fd = eh->GetFd(); if ((fd < 0) || (fd > GetMaxFds() - 1)) return false; - if (GetRemainingFds() <= 1) - return false; - if (ref[fd]) return false; - fds.insert(fd); ref[fd] = eh; - CurrentSetSize++; - writeable[eh->GetFd()] = writeFirst; + SocketEngine::SetEventMask(eh, event_mask); + OnSetEvent(eh, 0, event_mask); + FD_SET(fd, &ErrSet); + if (fd > MaxFD) + MaxFD = fd; + + CurrentSetSize++; ServerInstance->Logs->Log("SOCKET",DEBUG,"New file descriptor: %d", fd); return true; } -void SelectEngine::WantWrite(EventHandler* eh) -{ - writeable[eh->GetFd()] = true; -} - -bool SelectEngine::DelFd(EventHandler* eh, bool force) +void SelectEngine::DelFd(EventHandler* eh) { int fd = eh->GetFd(); if ((fd < 0) || (fd > GetMaxFds() - 1)) - return false; - - std::set::iterator t = fds.find(fd); - if (t != fds.end()) - fds.erase(t); + return; CurrentSetSize--; ref[fd] = NULL; + FD_CLR(fd, &ReadSet); + FD_CLR(fd, &WriteSet); + FD_CLR(fd, &ErrSet); + if (fd == MaxFD) + --MaxFD; + ServerInstance->Logs->Log("SOCKET",DEBUG,"Remove file descriptor: %d", fd); - return true; } -int SelectEngine::GetMaxFds() +void SelectEngine::OnSetEvent(EventHandler* eh, int old_mask, int new_mask) { - return FD_SETSIZE; -} + int fd = eh->GetFd(); + int diff = old_mask ^ new_mask; -int SelectEngine::GetRemainingFds() -{ - return GetMaxFds() - CurrentSetSize; + if (diff & (FD_WANT_POLL_READ | FD_WANT_FAST_READ)) + { + if (new_mask & (FD_WANT_POLL_READ | FD_WANT_FAST_READ)) + FD_SET(fd, &ReadSet); + else + FD_CLR(fd, &ReadSet); + } + if (diff & (FD_WANT_POLL_WRITE | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE)) + { + if (new_mask & (FD_WANT_POLL_WRITE | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE)) + FD_SET(fd, &WriteSet); + else + FD_CLR(fd, &WriteSet); + } } int SelectEngine::DispatchEvents() { timeval tval; - int sresult = 0; - socklen_t codesize = sizeof(int); - int errcode = 0; - - FD_ZERO(&wfdset); - FD_ZERO(&rfdset); - FD_ZERO(&errfdset); - - /* Populate the select FD set (this is why select sucks compared to epoll, kqueue, IOCP) */ - for (std::set::iterator a = fds.begin(); a != fds.end(); a++) - { - /* Explicitly one-time writeable */ - if (writeable[*a]) - FD_SET (*a, &wfdset); - else - FD_SET (*a, &rfdset); - - /* All sockets must receive error notifications regardless */ - FD_SET (*a, &errfdset); - } - - /* One second waits */ tval.tv_sec = 1; tval.tv_usec = 0; - sresult = select(FD_SETSIZE, &rfdset, &wfdset, &errfdset, &tval); + fd_set rfdset = ReadSet, wfdset = WriteSet, errfdset = ErrSet; + + int sresult = select(MaxFD + 1, &rfdset, &wfdset, &errfdset, &tval); + ServerInstance->UpdateTime(); /* Nothing to process this time around */ if (sresult < 1) return 0; - std::vector copy(fds.begin(), fds.end()); - for (std::vector::iterator a = copy.begin(); a != copy.end(); a++) + for (int i = 0, j = sresult; i <= MaxFD && j > 0; i++) { - EventHandler* ev = ref[*a]; - if (ev) + int has_read = FD_ISSET(i, &rfdset), has_write = FD_ISSET(i, &wfdset), has_error = FD_ISSET(i, &errfdset); + + if (has_read || has_write || has_error) { - if (FD_ISSET (ev->GetFd(), &errfdset)) + --j; + + EventHandler* ev = ref[i]; + if (!ev) + continue; + + if (has_error) { ErrorEvents++; - if (getsockopt(ev->GetFd(), SOL_SOCKET, SO_ERROR, (char*)&errcode, &codesize) < 0) + + socklen_t codesize = sizeof(int); + int errcode = 0; + if (getsockopt(i, SOL_SOCKET, SO_ERROR, (char*)&errcode, &codesize) < 0) errcode = errno; ev->HandleEvent(EVENT_ERROR, errcode); continue; } - else + + if (has_read) { - /* NOTE: This is a pair of seperate if statements as the socket - * may be in both read and writeable state at the same time. - * If an error event occurs above it is not worth processing the - * read and write states even if set. - */ - if (FD_ISSET (ev->GetFd(), &wfdset)) - { - WriteEvents++; - writeable[ev->GetFd()] = false; - ev->HandleEvent(EVENT_WRITE); - } - if (FD_ISSET (ev->GetFd(), &rfdset)) - { - ReadEvents++; - ev->HandleEvent(EVENT_READ); - } + ReadEvents++; + SetEventMask(ev, ev->GetEventMask() & ~FD_READ_WILL_BLOCK); + ev->HandleEvent(EVENT_READ); + if (ev != ref[i]) + continue; + } + if (has_write) + { + WriteEvents++; + int newmask = (ev->GetEventMask() & ~(FD_WRITE_WILL_BLOCK | FD_WANT_SINGLE_WRITE)); + this->OnSetEvent(ev, ev->GetEventMask(), newmask); + SetEventMask(ev, newmask); + ev->HandleEvent(EVENT_WRITE); } } } @@ -167,3 +196,8 @@ std::string SelectEngine::GetName() { return "select"; } + +SocketEngine* CreateSocketEngine() +{ + return new SelectEngine; +}