src/socketengine.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   5  *   Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net>
   6  *   Copyright (C) 2005-2008 Craig Edwards <craigedwards@brainbox.cc>
   7  *   Copyright (C) 2007 Burlex <???@???>
   8  *   Copyright (C) 2007 Dennis Friis <peavey@inspircd.org>
   9  *
  10  * This file is part of InspIRCd.  InspIRCd is free software: you can
  11  * redistribute it and/or modify it under the terms of the GNU General Public
  12  * License as published by the Free Software Foundation, version 2.
  13  *
  14  * This program is distributed in the hope that it will be useful, but WITHOUT
  15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  16  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  17  * details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23
  24 #include "inspircd.h"
  25
  26
  27 /** Reference table, contains all current handlers
  28  **/
  29 std::vector<EventHandler*> SocketEngine::ref;
  30
  31 /** Current number of descriptors in the engine
  32  */
  33 size_t SocketEngine::CurrentSetSize = 0;
  34
  35 /** List of handlers that want a trial read/write
  36  */
  37 std::set<int> SocketEngine::trials;
  38
  39 int SocketEngine::MAX_DESCRIPTORS;
  40
  41 /** Socket engine statistics: count of various events, bandwidth usage
  42  */
  43 SocketEngine::Statistics SocketEngine::stats;
  44
  45 EventHandler::EventHandler()
  46 {
  47         fd = -1;
  48         event_mask = 0;
  49 }
  50
  51 void EventHandler::SetFd(int FD)
  52 {
  53         this->fd = FD;
  54 }
  55
  56 void SocketEngine::ChangeEventMask(EventHandler* eh, int change)
  57 {
  58         int old_m = eh->event_mask;
  59         int new_m = old_m;
  60
  61         // if we are changing read/write type, remove the previously set bit
  62         if (change & FD_WANT_READ_MASK)
  63                 new_m &= ~FD_WANT_READ_MASK;
  64         if (change & FD_WANT_WRITE_MASK)
  65                 new_m &= ~FD_WANT_WRITE_MASK;
  66
  67         // if adding a trial read/write, insert it into the set
  68         if (change & FD_TRIAL_NOTE_MASK && !(old_m & FD_TRIAL_NOTE_MASK))
  69                 trials.insert(eh->GetFd());
  70
  71         new_m |= change;
  72         if (new_m == old_m)
  73                 return;
  74
  75         eh->event_mask = new_m;
  76         OnSetEvent(eh, old_m, new_m);
  77 }
  78
  79 void SocketEngine::DispatchTrialWrites()
  80 {
  81         std::vector<int> working_list;
  82         working_list.reserve(trials.size());
  83         working_list.assign(trials.begin(), trials.end());
  84         trials.clear();
  85         for(unsigned int i=0; i < working_list.size(); i++)
  86         {
  87                 int fd = working_list[i];
  88                 EventHandler* eh = GetRef(fd);
  89                 if (!eh)
  90                         continue;
  91                 int mask = eh->event_mask;
  92                 eh->event_mask &= ~(FD_ADD_TRIAL_READ | FD_ADD_TRIAL_WRITE);
  93                 if ((mask & (FD_ADD_TRIAL_READ | FD_READ_WILL_BLOCK)) == FD_ADD_TRIAL_READ)
  94                         eh->HandleEvent(EVENT_READ, 0);
  95                 if ((mask & (FD_ADD_TRIAL_WRITE | FD_WRITE_WILL_BLOCK)) == FD_ADD_TRIAL_WRITE)
  96                         eh->HandleEvent(EVENT_WRITE, 0);
  97         }
  98 }
  99
 100 bool SocketEngine::AddFdRef(EventHandler* eh)
 101 {
 102         int fd = eh->GetFd();
 103         if (HasFd(fd))
 104                 return false;
 105
 106         while (static_cast<unsigned int>(fd) >= ref.size())
 107                 ref.resize(ref.empty() ? 1 : (ref.size() * 2));
 108         ref[fd] = eh;
 109         CurrentSetSize++;
 110         return true;
 111 }
 112
 113 void SocketEngine::DelFdRef(EventHandler *eh)
 114 {
 115         int fd = eh->GetFd();
 116         if (GetRef(fd) == eh)
 117         {
 118                 ref[fd] = NULL;
 119                 CurrentSetSize--;
 120         }
 121 }
 122
 123 bool SocketEngine::HasFd(int fd)
 124 {
 125         return GetRef(fd) != NULL;
 126 }
 127
 128 EventHandler* SocketEngine::GetRef(int fd)
 129 {
 130         if (fd < 0 || static_cast<unsigned int>(fd) >= ref.size())
 131                 return NULL;
 132         return ref[fd];
 133 }
 134
 135 bool SocketEngine::BoundsCheckFd(EventHandler* eh)
 136 {
 137         if (!eh)
 138                 return false;
 139         if ((eh->GetFd() < 0) || (eh->GetFd() > GetMaxFds()))
 140                 return false;
 141         return true;
 142 }
 143
 144
 145 int SocketEngine::Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen)
 146 {
 147         return accept(fd->GetFd(), addr, addrlen);
 148 }
 149
 150 int SocketEngine::Close(EventHandler* fd)
 151 {
 152 #ifdef _WIN32
 153         return closesocket(fd->GetFd());
 154 #else
 155         return close(fd->GetFd());
 156 #endif
 157 }
 158
 159 int SocketEngine::Close(int fd)
 160 {
 161 #ifdef _WIN32
 162         return closesocket(fd);
 163 #else
 164         return close(fd);
 165 #endif
 166 }
 167
 168 int SocketEngine::Blocking(int fd)
 169 {
 170 #ifdef _WIN32
 171         unsigned long opt = 0;
 172         return ioctlsocket(fd, FIONBIO, &opt);
 173 #else
 174         int flags = fcntl(fd, F_GETFL, 0);
 175         return fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
 176 #endif
 177 }
 178
 179 int SocketEngine::NonBlocking(int fd)
 180 {
 181 #ifdef _WIN32
 182         unsigned long opt = 1;
 183         return ioctlsocket(fd, FIONBIO, &opt);
 184 #else
 185         int flags = fcntl(fd, F_GETFL, 0);
 186         return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 187 #endif
 188 }
 189
 190 void SocketEngine::SetReuse(int fd)
 191 {
 192         int on = 1;
 193         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on));
 194 }
 195
 196 int SocketEngine::RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen)
 197 {
 198         int nbRecvd = recvfrom(fd->GetFd(), (char*)buf, len, flags, from, fromlen);
 199         if (nbRecvd > 0)
 200                 stats.Update(nbRecvd, 0);
 201         return nbRecvd;
 202 }
 203
 204 int SocketEngine::Send(EventHandler* fd, const void *buf, size_t len, int flags)
 205 {
 206         int nbSent = send(fd->GetFd(), (const char*)buf, len, flags);
 207         if (nbSent > 0)
 208                 stats.Update(0, nbSent);
 209         return nbSent;
 210 }
 211
 212 int SocketEngine::Recv(EventHandler* fd, void *buf, size_t len, int flags)
 213 {
 214         int nbRecvd = recv(fd->GetFd(), (char*)buf, len, flags);
 215         if (nbRecvd > 0)
 216                 stats.Update(nbRecvd, 0);
 217         return nbRecvd;
 218 }
 219
 220 int SocketEngine::SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen)
 221 {
 222         int nbSent = sendto(fd->GetFd(), (const char*)buf, len, flags, to, tolen);
 223         if (nbSent > 0)
 224                 stats.Update(0, nbSent);
 225         return nbSent;
 226 }
 227
 228 int SocketEngine::Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen)
 229 {
 230         int ret = connect(fd->GetFd(), serv_addr, addrlen);
 231 #ifdef _WIN32
 232         if ((ret == SOCKET_ERROR) && (WSAGetLastError() == WSAEWOULDBLOCK))
 233                 errno = EINPROGRESS;
 234 #endif
 235         return ret;
 236 }
 237
 238 int SocketEngine::Shutdown(EventHandler* fd, int how)
 239 {
 240         return shutdown(fd->GetFd(), how);
 241 }
 242
 243 int SocketEngine::Bind(int fd, const irc::sockets::sockaddrs& addr)
 244 {
 245         return bind(fd, &addr.sa, addr.sa_size());
 246 }
 247
 248 int SocketEngine::Listen(int sockfd, int backlog)
 249 {
 250         return listen(sockfd, backlog);
 251 }
 252
 253 int SocketEngine::Shutdown(int fd, int how)
 254 {
 255         return shutdown(fd, how);
 256 }
 257
 258 void SocketEngine::Statistics::Update(size_t len_in, size_t len_out)
 259 {
 260         CheckFlush();
 261         indata += len_in;
 262         outdata += len_out;
 263 }
 264
 265 void SocketEngine::Statistics::CheckFlush() const
 266 {
 267         // Reset the in/out byte counters if it has been more than a second
 268         time_t now = ServerInstance->Time();
 269         if (lastempty != now)
 270         {
 271                 lastempty = now;
 272                 indata = outdata = 0;
 273         }
 274 }
 275
 276 void SocketEngine::Statistics::GetBandwidth(float& kbitpersec_in, float& kbitpersec_out, float& kbitpersec_total) const
 277 {
 278         CheckFlush();
 279         float in_kbit = indata * 8;
 280         float out_kbit = outdata * 8;
 281         kbitpersec_total = ((in_kbit + out_kbit) / 1024);
 282         kbitpersec_in = in_kbit / 1024;
 283         kbitpersec_out = out_kbit / 1024;
 284 }
 285
 286 std::string SocketEngine::LastError()
 287 {
 288 #ifndef _WIN32
 289         return strerror(errno);
 290 #else
 291         char szErrorString[500];
 292         DWORD dwErrorCode = WSAGetLastError();
 293         if (FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dwErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)szErrorString, _countof(szErrorString), NULL) == 0)
 294                 sprintf_s(szErrorString, _countof(szErrorString), "Error code: %u", dwErrorCode);
 295         return szErrorString;
 296 #endif
 297 }
 298
 299 std::string SocketEngine::GetError(int errnum)
 300 {
 301 #ifndef _WIN32
 302         return strerror(errnum);
 303 #else
 304         WSASetLastError(errnum);
 305         return LastError();
 306 #endif
 307 }