X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fsocketengine.cpp;h=9186f2c8c9ce88b78b0314a6357ccf763c39fcd0;hb=e2b0f3dc9ef4d56c71d7abda13e6139ca092e387;hp=af2f1b16972b33fbfb340730ba8926f3a8965c2d;hpb=09b802d5e94b71318e3b49f2d35554438efc5331;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/socketengine.cpp b/src/socketengine.cpp index af2f1b169..9186f2c8c 100644 --- a/src/socketengine.cpp +++ b/src/socketengine.cpp @@ -1,160 +1,186 @@ -/* +------------------------------------+ - * | 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) 2017-2020 Sadie Powell + * Copyright (C) 2013-2014 Adam + * Copyright (C) 2012, 2014-2015 Attila Molnar + * Copyright (C) 2012 Robby + * Copyright (C) 2012 ChrisTX + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2008, 2017 Robin Burchell + * Copyright (C) 2007 burlex + * Copyright (C) 2007 Dennis Friis + * Copyright (C) 2006-2008, 2010 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 . */ -/* $Core */ -/********* DEFAULTS **********/ +#include "exitcodes.h" +#include "inspircd.h" -/* $ExtraSources: socketengines/socketengine_select.cpp */ -/* $ExtraObjects: socketengine_select.o */ +#include -/* $If: USE_POLL */ -/* $ExtraSources: socketengines/socketengine_poll.cpp */ -/* $ExtraObjects: socketengine_poll.o */ -/* $EndIf */ +/** Reference table, contains all current handlers + **/ +std::vector SocketEngine::ref; -/* $If: USE_KQUEUE */ -/* $ExtraSources: socketengines/socketengine_kqueue.cpp */ -/* $ExtraObjects: socketengine_kqueue.o */ -/* $EndIf */ +/** Current number of descriptors in the engine + */ +size_t SocketEngine::CurrentSetSize = 0; -/* $If: USE_EPOLL */ -/* $ExtraSources: socketengines/socketengine_epoll.cpp */ -/* $ExtraObjects: socketengine_epoll.o */ -/* $EndIf */ +/** List of handlers that want a trial read/write + */ +std::set SocketEngine::trials; -/* $If: USE_PORTS */ -/* $ExtraSources: socketengines/socketengine_ports.cpp */ -/* $ExtraObjects: socketengine_ports.o */ -/* $EndIf */ +size_t SocketEngine::MaxSetSize = 0; -#include "inspircd.h" -#include "socketengine.h" +/** Socket engine statistics: count of various events, bandwidth usage + */ +SocketEngine::Statistics SocketEngine::stats; EventHandler::EventHandler() { - this->IOHook = NULL; + fd = -1; + event_mask = 0; } -bool EventHandler::AddIOHook(Module *IOHooker) +void EventHandler::SwapInternals(EventHandler& other) { - if (this->IOHook) - return false; - - this->IOHook = IOHooker; - return true; + std::swap(fd, other.fd); + std::swap(event_mask, other.event_mask); } -bool EventHandler::DelIOHook() +void EventHandler::SetFd(int FD) { - if (!this->IOHook) - return false; - - this->IOHook = NULL; - return true; + this->fd = FD; } -Module *EventHandler::GetIOHook() +void EventHandler::OnEventHandlerWrite() { - return this->IOHook; } -int EventHandler::GetFd() +void EventHandler::OnEventHandlerError(int errornum) { - return this->fd; } -void EventHandler::SetFd(int FD) +void SocketEngine::InitError() { - this->fd = FD; + std::cerr << con_red << "FATAL ERROR!" << con_reset << " Socket engine initialization failed. " << strerror(errno) << '.' << std::endl; + exit(EXIT_STATUS_SOCKETENGINE); } -bool EventHandler::Readable() +void SocketEngine::LookupMaxFds() { - return true; -} +#if defined _WIN32 + MaxSetSize = FD_SETSIZE; +#else + struct rlimit limits; + if (!getrlimit(RLIMIT_NOFILE, &limits)) + MaxSetSize = limits.rlim_cur; -bool EventHandler::Writeable() -{ - return false; +#if defined __APPLE__ + limits.rlim_cur = limits.rlim_max == RLIM_INFINITY ? OPEN_MAX : limits.rlim_max; +#else + limits.rlim_cur = limits.rlim_max; +#endif + if (!setrlimit(RLIMIT_NOFILE, &limits)) + MaxSetSize = limits.rlim_cur; +#endif } -void SocketEngine::WantWrite(EventHandler* eh) +void SocketEngine::ChangeEventMask(EventHandler* eh, int change) { -} + int old_m = eh->event_mask; + int new_m = old_m; -SocketEngine::SocketEngine(InspIRCd* Instance) : ServerInstance(Instance) -{ - TotalEvents = WriteEvents = ReadEvents = ErrorEvents = 0; - lastempty = ServerInstance->Time(); - indata = outdata = 0; -} + // if we are changing read/write type, remove the previously set bit + if (change & FD_WANT_READ_MASK) + new_m &= ~FD_WANT_READ_MASK; + if (change & FD_WANT_WRITE_MASK) + new_m &= ~FD_WANT_WRITE_MASK; -SocketEngine::~SocketEngine() -{ -} + // if adding a trial read/write, insert it into the set + if (change & FD_TRIAL_NOTE_MASK && !(old_m & FD_TRIAL_NOTE_MASK)) + trials.insert(eh->GetFd()); -bool SocketEngine::AddFd(EventHandler* eh) -{ - return true; -} + new_m |= change; + if (new_m == old_m) + return; -bool SocketEngine::HasFd(int fd) -{ - if ((fd < 0) || (fd > MAX_DESCRIPTORS)) - return false; - return ref[fd]; + eh->event_mask = new_m; + OnSetEvent(eh, old_m, new_m); } -EventHandler* SocketEngine::GetRef(int fd) +void SocketEngine::DispatchTrialWrites() { - if ((fd < 0) || (fd > MAX_DESCRIPTORS)) - return 0; - return ref[fd]; + std::vector working_list; + working_list.reserve(trials.size()); + working_list.assign(trials.begin(), trials.end()); + trials.clear(); + for(unsigned int i=0; i < working_list.size(); i++) + { + int fd = working_list[i]; + EventHandler* eh = GetRef(fd); + if (!eh) + continue; + int mask = eh->event_mask; + eh->event_mask &= ~(FD_ADD_TRIAL_READ | FD_ADD_TRIAL_WRITE); + if ((mask & (FD_ADD_TRIAL_READ | FD_READ_WILL_BLOCK)) == FD_ADD_TRIAL_READ) + eh->OnEventHandlerRead(); + if ((mask & (FD_ADD_TRIAL_WRITE | FD_WRITE_WILL_BLOCK)) == FD_ADD_TRIAL_WRITE) + eh->OnEventHandlerWrite(); + } } -bool SocketEngine::DelFd(EventHandler* eh, bool force) +bool SocketEngine::AddFdRef(EventHandler* eh) { - return true; -} + int fd = eh->GetFd(); + if (HasFd(fd)) + return false; -int SocketEngine::GetMaxFds() -{ - return 0; + while (static_cast(fd) >= ref.size()) + ref.resize(ref.empty() ? 1 : (ref.size() * 2)); + ref[fd] = eh; + CurrentSetSize++; + return true; } -int SocketEngine::GetRemainingFds() +void SocketEngine::DelFdRef(EventHandler *eh) { - return 0; + int fd = eh->GetFd(); + if (GetRef(fd) == eh) + { + ref[fd] = NULL; + CurrentSetSize--; + } } -int SocketEngine::DispatchEvents() +bool SocketEngine::HasFd(int fd) { - return 0; + return GetRef(fd) != NULL; } -std::string SocketEngine::GetName() +EventHandler* SocketEngine::GetRef(int fd) { - return "misconfigured"; + if (fd < 0 || static_cast(fd) >= ref.size()) + return NULL; + return ref[fd]; } bool SocketEngine::BoundsCheckFd(EventHandler* eh) { - if (!eh) - return false; - if ((eh->GetFd() < 0) || (eh->GetFd() > MAX_DESCRIPTORS)) - return false; - return true; + return eh && eh->HasFd(); } @@ -163,18 +189,17 @@ int SocketEngine::Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen) return accept(fd->GetFd(), addr, addrlen); } -int SocketEngine::Close(EventHandler* fd) +int SocketEngine::Close(EventHandler* eh) { -#ifdef WINDOWS - return closesocket(fd->GetFd()); -#else - return close(fd->GetFd()); -#endif + DelFd(eh); + int ret = Close(eh->GetFd()); + eh->SetFd(-1); + return ret; } int SocketEngine::Close(int fd) { -#ifdef WINDOWS +#ifdef _WIN32 return closesocket(fd); #else return close(fd); @@ -183,7 +208,7 @@ int SocketEngine::Close(int fd) int SocketEngine::Blocking(int fd) { -#ifdef WINDOWS +#ifdef _WIN32 unsigned long opt = 0; return ioctlsocket(fd, FIONBIO, &opt); #else @@ -194,7 +219,7 @@ int SocketEngine::Blocking(int fd) int SocketEngine::NonBlocking(int fd) { -#ifdef WINDOWS +#ifdef _WIN32 unsigned long opt = 1; return ioctlsocket(fd, FIONBIO, &opt); #else @@ -203,38 +228,74 @@ int SocketEngine::NonBlocking(int fd) #endif } -int SocketEngine::GetSockName(EventHandler* fd, sockaddr *name, socklen_t* namelen) +void SocketEngine::SetReuse(int fd) { - return getsockname(fd->GetFd(), name, namelen); + int on = 1; + setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on)); } int SocketEngine::RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen) { - this->UpdateStats(len, 0); - return recvfrom(fd->GetFd(), buf, len, flags, from, fromlen); + int nbRecvd = recvfrom(fd->GetFd(), (char*)buf, len, flags, from, fromlen); + stats.UpdateReadCounters(nbRecvd); + return nbRecvd; } int SocketEngine::Send(EventHandler* fd, const void *buf, size_t len, int flags) { - this->UpdateStats(0, len); - return send(fd->GetFd(), buf, len, flags); + int nbSent = send(fd->GetFd(), (const char*)buf, len, flags); + stats.UpdateWriteCounters(nbSent); + return nbSent; } int SocketEngine::Recv(EventHandler* fd, void *buf, size_t len, int flags) { - this->UpdateStats(len, 0); - return recv(fd->GetFd(), buf, len, flags); + int nbRecvd = recv(fd->GetFd(), (char*)buf, len, flags); + stats.UpdateReadCounters(nbRecvd); + return nbRecvd; +} + +int SocketEngine::SendTo(EventHandler* fd, const void* buf, size_t len, int flags, const irc::sockets::sockaddrs& address) +{ + int nbSent = sendto(fd->GetFd(), (const char*)buf, len, flags, &address.sa, address.sa_size()); + stats.UpdateWriteCounters(nbSent); + return nbSent; } -int SocketEngine::SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen) +int SocketEngine::WriteV(EventHandler* fd, const IOVector* iovec, int count) { - this->UpdateStats(0, len); - return sendto(fd->GetFd(), buf, len, flags, to, tolen); + int sent = writev(fd->GetFd(), iovec, count); + stats.UpdateWriteCounters(sent); + return sent; } -int SocketEngine::Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen) +#ifdef _WIN32 +int SocketEngine::WriteV(EventHandler* fd, const iovec* iovec, int count) { - return connect(fd->GetFd(), serv_addr, addrlen); + // On Windows the fields in iovec are not in the order required by the Winsock API; IOVector has + // the fields in the correct order. + // Create temporary IOVectors from the iovecs and pass them to the WriteV() method that accepts the + // platform's native struct. + IOVector wiovec[128]; + count = std::min(count, static_cast(sizeof(wiovec) / sizeof(IOVector))); + + for (int i = 0; i < count; i++) + { + wiovec[i].iov_len = iovec[i].iov_len; + wiovec[i].iov_base = reinterpret_cast(iovec[i].iov_base); + } + return WriteV(fd, wiovec, count); +} +#endif + +int SocketEngine::Connect(EventHandler* fd, const irc::sockets::sockaddrs& address) +{ + int ret = connect(fd->GetFd(), &address.sa, address.sa_size()); +#ifdef _WIN32 + if ((ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEWOULDBLOCK)) + errno = EINPROGRESS; +#endif + return ret; } int SocketEngine::Shutdown(EventHandler* fd, int how) @@ -242,9 +303,9 @@ int SocketEngine::Shutdown(EventHandler* fd, int how) return shutdown(fd->GetFd(), how); } -int SocketEngine::Bind(int fd, const sockaddr *my_addr, socklen_t addrlen) +int SocketEngine::Bind(int fd, const irc::sockets::sockaddrs& addr) { - return bind(fd, my_addr, addrlen); + return bind(fd, &addr.sa, addr.sa_size()); } int SocketEngine::Listen(int sockfd, int backlog) @@ -257,27 +318,74 @@ int SocketEngine::Shutdown(int fd, int how) return shutdown(fd, how); } -void SocketEngine::RecoverFromFork() +void SocketEngine::Statistics::UpdateReadCounters(int len_in) +{ + CheckFlush(); + + ReadEvents++; + if (len_in > 0) + indata += len_in; + else if (len_in < 0) + ErrorEvents++; +} + +void SocketEngine::Statistics::UpdateWriteCounters(int len_out) { + CheckFlush(); + + WriteEvents++; + if (len_out > 0) + outdata += len_out; + else if (len_out < 0) + ErrorEvents++; } -void SocketEngine::UpdateStats(size_t len_in, size_t len_out) +void SocketEngine::Statistics::CheckFlush() const { - if (lastempty != ServerInstance->Time()) + // Reset the in/out byte counters if it has been more than a second + time_t now = ServerInstance->Time(); + if (lastempty != now) { - lastempty = ServerInstance->Time(); + lastempty = now; indata = outdata = 0; } - indata += len_in; - outdata += len_out; } -void SocketEngine::GetStats(float &kbitpersec_in, float &kbitpersec_out, float &kbitpersec_total) +void SocketEngine::Statistics::GetBandwidth(float& kbitpersec_in, float& kbitpersec_out, float& kbitpersec_total) const { - UpdateStats(0, 0); /* Forces emptying of the values if its been more than a second */ + CheckFlush(); float in_kbit = indata * 8; float out_kbit = outdata * 8; kbitpersec_total = ((in_kbit + out_kbit) / 1024); kbitpersec_in = in_kbit / 1024; kbitpersec_out = out_kbit / 1024; } + +std::string SocketEngine::LastError() +{ +#ifndef _WIN32 + return strerror(errno); +#else + char szErrorString[500]; + DWORD dwErrorCode = WSAGetLastError(); + if (FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dwErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)szErrorString, _countof(szErrorString), NULL) == 0) + sprintf_s(szErrorString, _countof(szErrorString), "Error code: %u", dwErrorCode); + + std::string::size_type p; + std::string ret = szErrorString; + while ((p = ret.find_last_of("\r\n")) != std::string::npos) + ret.erase(p, 1); + + return ret; +#endif +} + +std::string SocketEngine::GetError(int errnum) +{ +#ifndef _WIN32 + return strerror(errnum); +#else + WSASetLastError(errnum); + return LastError(); +#endif +}