X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fsocketengines%2Fsocketengine_select.cpp;h=bc7b5c63fcd4aa77365eef479651e17b6fcc6cfe;hb=e2b0f3dc9ef4d56c71d7abda13e6139ca092e387;hp=b57a83ae856809ff8aeb83934ee477db13271a45;hpb=e4acbc95b8b6cd5b28d38a2242c02e8ff4991e4a;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/socketengines/socketengine_select.cpp b/src/socketengines/socketengine_select.cpp index b57a83ae8..bc7b5c63f 100644 --- a/src/socketengines/socketengine_select.cpp +++ b/src/socketengines/socketengine_select.cpp @@ -1,165 +1,185 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2008 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * Copyright (C) 2013-2015 Attila Molnar + * Copyright (C) 2013, 2017, 2019 Sadie Powell + * Copyright (C) 2012 Robby + * Copyright (C) 2012 ChrisTX + * Copyright (C) 2011, 2014 Adam + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2008 Robin Burchell + * Copyright (C) 2007 Dennis Friis + * Copyright (C) 2006-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.h" + +#ifndef _WIN32 #include -#include "socketengines/socketengine_select.h" +#endif // _WIN32 + +/** A specialisation of the SocketEngine class, designed to use traditional select(). + */ +namespace +{ + fd_set ReadSet, WriteSet, ErrSet; + int MaxFD = 0; +} + +void SocketEngine::Init() +{ +#ifdef _WIN32 + // Set up winsock. + WSADATA wsadata; + WSAStartup(MAKEWORD(2,2), &wsadata); +#endif + MaxSetSize = FD_SETSIZE; -SelectEngine::SelectEngine(InspIRCd* Instance) : SocketEngine(Instance) + FD_ZERO(&ReadSet); + FD_ZERO(&WriteSet); + FD_ZERO(&ErrSet); +} + +void SocketEngine::Deinit() { - EngineHandle = 0; - CurrentSetSize = 0; - memset(writeable, 0, sizeof(writeable)); } -SelectEngine::~SelectEngine() +void SocketEngine::RecoverFromFork() { } -bool SelectEngine::AddFd(EventHandler* eh) +bool SocketEngine::AddFd(EventHandler* eh, int event_mask) { int fd = eh->GetFd(); - if ((fd < 0) || (fd > MAX_DESCRIPTORS)) + + if (fd < 0) return false; - if (GetRemainingFds() <= 1) + if (static_cast(fd) >= GetMaxFds()) return false; - if (ref[fd]) + if (!SocketEngine::AddFdRef(eh)) return false; - fds[fd] = fd; - ref[fd] = eh; - CurrentSetSize++; + eh->SetEventMask(event_mask); + OnSetEvent(eh, 0, event_mask); + FD_SET(fd, &ErrSet); + if (fd > MaxFD) + MaxFD = fd; - ServerInstance->Log(DEBUG,"New file descriptor: %d", fd); + ServerInstance->Logs->Log("SOCKET", 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) +void SocketEngine::DelFd(EventHandler* eh) { int fd = eh->GetFd(); - if ((fd < 0) || (fd > MAX_DESCRIPTORS)) - return false; + if (fd < 0) + return; - std::map::iterator t = fds.find(fd); - if (t != fds.end()) - fds.erase(t); + if (static_cast(fd) >= GetMaxFds()) + return; - CurrentSetSize--; - ref[fd] = NULL; - fds[fd] = 0; + SocketEngine::DelFdRef(eh); - ServerInstance->Log(DEBUG,"Remove file descriptor: %d", fd); - return true; -} + FD_CLR(fd, &ReadSet); + FD_CLR(fd, &WriteSet); + FD_CLR(fd, &ErrSet); + if (fd == MaxFD) + --MaxFD; -int SelectEngine::GetMaxFds() -{ - return FD_SETSIZE; + ServerInstance->Logs->Log("SOCKET", LOG_DEBUG, "Remove file descriptor: %d", fd); } -int SelectEngine::GetRemainingFds() +void SocketEngine::OnSetEvent(EventHandler* eh, int old_mask, int new_mask) { - return FD_SETSIZE - CurrentSetSize; + int fd = eh->GetFd(); + int diff = old_mask ^ new_mask; + + 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() +int SocketEngine::DispatchEvents() { - int result = 0; timeval tval; - int sresult = 0; - EventHandler* ev[MAX_DESCRIPTORS]; - socklen_t codesize; - int errcode; + tval.tv_sec = 1; + tval.tv_usec = 0; - FD_ZERO(&wfdset); - FD_ZERO(&rfdset); - FD_ZERO(&errfdset); + fd_set rfdset = ReadSet, wfdset = WriteSet, errfdset = ErrSet; - for (std::map::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); + int sresult = select(MaxFD + 1, &rfdset, &wfdset, &errfdset, &tval); + ServerInstance->UpdateTime(); - 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 (int i = 0, j = sresult; i <= MaxFD && j > 0; i++) { - for (std::map::iterator a = fds.begin(); a != fds.end(); a++) + 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)) + continue; + + --j; + + EventHandler* ev = GetRef(i); + if (!ev) + continue; + + if (has_error) { - if ((FD_ISSET (a->second, &rfdset)) || (FD_ISSET (a->second, &wfdset)) || FD_ISSET (a->second, &errfdset)) - { - ev[result++] = ref[a->second]; - } + stats.ErrorEvents++; + + socklen_t codesize = sizeof(int); + int errcode = 0; + if (getsockopt(i, SOL_SOCKET, SO_ERROR, (char*)&errcode, &codesize) < 0) + errcode = errno; + + ev->OnEventHandlerError(errcode); + continue; } - } - /** 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 (has_read) { - 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); - } + ev->SetEventMask(ev->GetEventMask() & ~FD_READ_WILL_BLOCK); + ev->OnEventHandlerRead(); + if (ev != GetRef(i)) 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; -} + if (has_write) + { + int newmask = (ev->GetEventMask() & ~(FD_WRITE_WILL_BLOCK | FD_WANT_SINGLE_WRITE)); + SocketEngine::OnSetEvent(ev, ev->GetEventMask(), newmask); + ev->SetEventMask(newmask); + ev->OnEventHandlerWrite(); + } + } -std::string SelectEngine::GetName() -{ - return "select"; + return sresult; }