X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fsocketengine.cpp;h=4a9a2ef10539e1b0c50d5c77fbc02e6aa6b49227;hb=571714e28b26cc59cbc8d27098a5ba981240ee2d;hp=976f578fd542adb5e4d69c9252eae590996eb042;hpb=31dc0f8489dfbf63efbf0960711b3bbaa5543e30;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/socketengine.cpp b/src/socketengine.cpp index 976f578fd..4a9a2ef10 100644 --- a/src/socketengine.cpp +++ b/src/socketengine.cpp @@ -1,260 +1,286 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev. - * E-mail: - * - * + * Copyright (C) 2009 Daniel De Graaf + * Copyright (C) 2008 Robin Burchell + * Copyright (C) 2005-2008 Craig Edwards + * Copyright (C) 2007 Burlex + * Copyright (C) 2007 Dennis Friis * - * Written by Craig Edwards, Craig McLure, and others. - * 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 "globals.h" + #include "inspircd.h" -#ifdef USE_EPOLL -#include -#endif -#ifdef USE_KQUEUE -#include -#include -#include -#endif -#include -#include -#include "socketengine.h" -char ref[MAX_DESCRIPTORS]; +EventHandler::EventHandler() +{ + fd = -1; + event_mask = 0; +} + +void EventHandler::SetFd(int FD) +{ + this->fd = FD; +} SocketEngine::SocketEngine() { - log(DEBUG,"SocketEngine::SocketEngine()"); -#ifdef USE_EPOLL - EngineHandle = epoll_create(MAX_DESCRIPTORS); -#endif -#ifdef USE_KQUEUE - EngineHandle = kqueue(); -#endif -#ifdef USE_SELECT - EngineHandle = 0; -#endif - if (EngineHandle == -1) - { - log(SPARSE,"ERROR: Could not initialize socket engine. Your kernel probably does not have the proper features."); - 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."); - Exit(0); - } - CurrentSetSize = 0; + TotalEvents = WriteEvents = ReadEvents = ErrorEvents = 0; + lastempty = ServerInstance->Time(); + indata = outdata = 0; } SocketEngine::~SocketEngine() { - log(DEBUG,"SocketEngine::~SocketEngine()"); -#ifdef USE_EPOLL - close(EngineHandle); -#endif -#ifdef USE_KQUEUE - close(EngineHandle); -#endif } -char SocketEngine::GetType(int fd) +void SocketEngine::SetEventMask(EventHandler* eh, int mask) { - if ((fd < 0) || (fd > MAX_DESCRIPTORS)) - return X_EMPTY_SLOT; - /* Mask off the top bit used for 'read/write' state */ - return (ref[fd] & ~0x80); + eh->event_mask = mask; } -bool SocketEngine::AddFd(int fd, bool readable, char type) +void SocketEngine::ChangeEventMask(EventHandler* eh, int change) { - if ((fd < 0) || (fd > MAX_DESCRIPTORS)) - { - log(DEFAULT,"ERROR: FD of %d added above max of %d",fd,MAX_DESCRIPTORS); - return false; - } - if (GetRemainingFds() <= 1) - { - log(DEFAULT,"ERROR: System out of file descriptors!"); - return false; - } -#ifdef USE_SELECT - fds[fd] = fd; -#endif - ref[fd] = type; - if (readable) - { - log(DEBUG,"Set readbit"); - ref[fd] |= X_READBIT; - } - log(DEBUG,"Add socket %d",fd); -#ifdef USE_EPOLL - struct epoll_event ev; - memset(&ev,0,sizeof(struct epoll_event)); - log(DEBUG,"epoll: Add socket to events, ep=%d socket=%d",EngineHandle,fd); - readable ? ev.events = EPOLLIN : ev.events = EPOLLOUT; - ev.data.fd = fd; - int i = epoll_ctl(EngineHandle, EPOLL_CTL_ADD, fd, &ev); - if (i < 0) - { - log(DEBUG,"epoll: List insertion failure!"); - return false; - } -#endif -#ifdef USE_KQUEUE - struct kevent ke; - log(DEBUG,"kqueue: Add socket to events, kq=%d socket=%d",EngineHandle,fd); - EV_SET(&ke, fd, readable ? EVFILT_READ : EVFILT_WRITE, EV_ADD, 0, 0, NULL); - int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL); - if (i == -1) + int old_m = eh->event_mask; + int new_m = old_m; + + // 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; + + // 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()); + + new_m |= change; + if (new_m == old_m) + return; + + eh->event_mask = new_m; + OnSetEvent(eh, old_m, new_m); +} + +void SocketEngine::DispatchTrialWrites() +{ + 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++) { - log(DEBUG,"kqueue: List insertion failure!"); - return false; + 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->HandleEvent(EVENT_READ, 0); + if ((mask & (FD_ADD_TRIAL_WRITE | FD_WRITE_WILL_BLOCK)) == FD_ADD_TRIAL_WRITE) + eh->HandleEvent(EVENT_WRITE, 0); } -#endif - CurrentSetSize++; - return true; } bool SocketEngine::HasFd(int fd) { - if ((fd < 0) || (fd > MAX_DESCRIPTORS)) + if ((fd < 0) || (fd > GetMaxFds())) return false; - return (ref[fd] != 0); + return (ref[fd] != NULL); } -bool SocketEngine::DelFd(int fd) +EventHandler* SocketEngine::GetRef(int fd) { - log(DEBUG,"SocketEngine::DelFd(%d)",fd); - - if ((fd < 0) || (fd > MAX_DESCRIPTORS)) - return false; + if ((fd < 0) || (fd > GetMaxFds())) + return 0; + return ref[fd]; +} -#ifdef USE_SELECT - std::map::iterator t = fds.find(fd); - if (t != fds.end()) - { - fds.erase(t); - log(DEBUG,"Deleted fd %d",fd); - } -#endif -#ifdef USE_KQUEUE - struct kevent ke; - EV_SET(&ke, fd, ref[fd] & X_READBIT ? EVFILT_READ : EVFILT_WRITE, EV_DELETE, 0, 0, NULL); - int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL); - if (i == -1) - { - log(DEBUG,"kqueue: Failed to remove socket from queue!"); +bool SocketEngine::BoundsCheckFd(EventHandler* eh) +{ + if (!eh) return false; - } -#endif -#ifdef USE_EPOLL - struct epoll_event ev; - memset(&ev,0,sizeof(struct epoll_event)); - ref[fd] && X_READBIT ? ev.events = EPOLLIN : ev.events = EPOLLOUT; - ev.data.fd = fd; - int i = epoll_ctl(EngineHandle, EPOLL_CTL_DEL, fd, &ev); - if (i < 0) - { - log(DEBUG,"epoll: List deletion failure!"); + if ((eh->GetFd() < 0) || (eh->GetFd() > GetMaxFds())) return false; - } -#endif - CurrentSetSize--; - ref[fd] = 0; return true; } -int SocketEngine::GetMaxFds() + +int SocketEngine::Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen) { -#ifdef USE_SELECT - return FD_SETSIZE; -#endif -#ifdef USE_KQUEUE - return MAX_DESCRIPTORS; + return accept(fd->GetFd(), addr, addrlen); +} + +int SocketEngine::Close(EventHandler* fd) +{ +#ifdef _WIN32 + return closesocket(fd->GetFd()); +#else + return close(fd->GetFd()); #endif -#ifdef USE_EPOLL - return MAX_DESCRIPTORS; +} + +int SocketEngine::Close(int fd) +{ +#ifdef _WIN32 + return closesocket(fd); +#else + return close(fd); #endif } -int SocketEngine::GetRemainingFds() +int SocketEngine::Blocking(int fd) { -#ifdef USE_SELECT - return FD_SETSIZE - CurrentSetSize; +#ifdef _WIN32 + unsigned long opt = 0; + return ioctlsocket(fd, FIONBIO, &opt); +#else + int flags = fcntl(fd, F_GETFL, 0); + return fcntl(fd, F_SETFL, flags & ~O_NONBLOCK); #endif -#ifdef USE_KQUEUE - return MAX_DESCRIPTORS - CurrentSetSize; +} + +int SocketEngine::NonBlocking(int fd) +{ +#ifdef _WIN32 + unsigned long opt = 1; + return ioctlsocket(fd, FIONBIO, &opt); +#else + int flags = fcntl(fd, F_GETFL, 0); + return fcntl(fd, F_SETFL, flags | O_NONBLOCK); #endif -#ifdef USE_EPOLL - return MAX_DESCRIPTORS - CurrentSetSize; +} + +void SocketEngine::SetReuse(int fd) +{ + 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) +{ + int nbRecvd = recvfrom(fd->GetFd(), (char*)buf, len, flags, from, fromlen); + if (nbRecvd > 0) + this->UpdateStats(nbRecvd, 0); + return nbRecvd; +} + +int SocketEngine::Send(EventHandler* fd, const void *buf, size_t len, int flags) +{ + int nbSent = send(fd->GetFd(), (const char*)buf, len, flags); + if (nbSent > 0) + this->UpdateStats(0, nbSent); + return nbSent; +} + +int SocketEngine::Recv(EventHandler* fd, void *buf, size_t len, int flags) +{ + int nbRecvd = recv(fd->GetFd(), (char*)buf, len, flags); + if (nbRecvd > 0) + this->UpdateStats(nbRecvd, 0); + return nbRecvd; +} + +int SocketEngine::SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen) +{ + int nbSent = sendto(fd->GetFd(), (const char*)buf, len, flags, to, tolen); + if (nbSent > 0) + this->UpdateStats(0, nbSent); + return nbSent; +} + +int SocketEngine::Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen) +{ + int ret = connect(fd->GetFd(), serv_addr, addrlen); +#ifdef _WIN32 + if ((ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEWOULDBLOCK)) + errno = EINPROGRESS; #endif + return ret; } -int SocketEngine::Wait(int* fdlist) +int SocketEngine::Shutdown(EventHandler* fd, int how) { - int result = 0; -#ifdef USE_SELECT - FD_ZERO(&wfdset); - FD_ZERO(&rfdset); - timeval tval; - int sresult; - for (std::map::iterator a = fds.begin(); a != fds.end(); a++) - { - if (ref[a->second] & X_READBIT) - { - FD_SET (a->second, &rfdset); - } - else - { - FD_SET (a->second, &wfdset); - } - - } - tval.tv_sec = 0; - tval.tv_usec = 50L; - sresult = select(FD_SETSIZE, &rfdset, &wfdset, NULL, &tval); - if (sresult > 0) + return shutdown(fd->GetFd(), how); +} + +int SocketEngine::Bind(int fd, const irc::sockets::sockaddrs& addr) +{ + return bind(fd, &addr.sa, addr.sa_size()); +} + +int SocketEngine::Listen(int sockfd, int backlog) +{ + return listen(sockfd, backlog); +} + +int SocketEngine::Shutdown(int fd, int how) +{ + return shutdown(fd, how); +} + +void SocketEngine::RecoverFromFork() +{ +} + +void SocketEngine::UpdateStats(size_t len_in, size_t len_out) +{ + if (lastempty != ServerInstance->Time()) { - for (std::map::iterator a = fds.begin(); a != fds.end(); a++) - { - if ((FD_ISSET (a->second, &rfdset)) || (FD_ISSET (a->second, &wfdset))) - fdlist[result++] = a->second; - } + lastempty = ServerInstance->Time(); + indata = outdata = 0; } -#endif -#ifdef USE_KQUEUE - ts.tv_nsec = 5000L; - ts.tv_sec = 0; - int i = kevent(EngineHandle, NULL, 0, &ke_list[0], MAX_DESCRIPTORS, &ts); - for (int j = 0; j < i; j++) - fdlist[result++] = ke_list[j].ident; -#endif -#ifdef USE_EPOLL - int i = epoll_wait(EngineHandle, events, MAX_DESCRIPTORS, 50); - for (int j = 0; j < i; j++) - fdlist[result++] = events[j].data.fd; -#endif - return result; + indata += len_in; + outdata += len_out; } -std::string SocketEngine::GetName() +void SocketEngine::GetStats(float &kbitpersec_in, float &kbitpersec_out, float &kbitpersec_total) { -#ifdef USE_SELECT - return "select"; -#endif -#ifdef USE_KQUEUE - return "kqueue"; + UpdateStats(0, 0); /* Forces emptying of the values if its been more than a second */ + 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 -#ifdef USE_EPOLL - return "epoll"; +} + +std::string SocketEngine::GetError(int errnum) +{ +#ifndef _WIN32 + return strerror(errnum); +#else + WSASetLastError(errnum); + return LastError(); #endif - return "misconfigured"; }