src/socketengine.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
   6  * See: http://www.inspircd.org/wiki/index.php/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *          the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 /* $Core */
  15
  16 /*********        DEFAULTS       **********/
  17
  18 /* $ExtraSources: socketengines/socketengine_select.cpp */
  19 /* $ExtraObjects: socketengine_select.o */
  20
  21 /* $If: USE_POLL */
  22 /* $ExtraSources: socketengines/socketengine_poll.cpp */
  23 /* $ExtraObjects: socketengine_poll.o */
  24 /* $EndIf */
  25
  26 /* $If: USE_KQUEUE */
  27 /* $ExtraSources: socketengines/socketengine_kqueue.cpp */
  28 /* $ExtraObjects: socketengine_kqueue.o */
  29 /* $EndIf */
  30
  31 /* $If: USE_EPOLL */
  32 /* $ExtraSources: socketengines/socketengine_epoll.cpp */
  33 /* $ExtraObjects: socketengine_epoll.o */
  34 /* $EndIf */
  35
  36 /* $If: USE_PORTS */
  37 /* $ExtraSources: socketengines/socketengine_ports.cpp */
  38 /* $ExtraObjects: socketengine_ports.o */
  39 /* $EndIf */
  40
  41 #include "inspircd.h"
  42 #include "socketengine.h"
  43
  44 bool EventHandler::AddIOHook(Module *IOHooker)
  45 {
  46         if (this->IOHook)
  47                 return false;
  48
  49         this->IOHook = IOHooker;
  50 }
  51
  52 bool EventHandler::DelIOHook()
  53 {
  54         if (!this->IOHook)
  55                 return false
  56
  57         this->IOHook = false;
  58 }
  59
  60 Module *EventHandler::GetIOHook()
  61 {
  62         return this->IOHook;
  63 }
  64
  65 int EventHandler::GetFd()
  66 {
  67         return this->fd;
  68 }
  69
  70 void EventHandler::SetFd(int FD)
  71 {
  72         this->fd = FD;
  73 }
  74
  75 bool EventHandler::Readable()
  76 {
  77         return true;
  78 }
  79
  80 bool EventHandler::Writeable()
  81 {
  82         return false;
  83 }
  84
  85 void SocketEngine::WantWrite(EventHandler* eh)
  86 {
  87 }
  88
  89 SocketEngine::SocketEngine(InspIRCd* Instance) : ServerInstance(Instance)
  90 {
  91         TotalEvents = WriteEvents = ReadEvents = ErrorEvents = 0;
  92         lastempty = time(NULL);
  93         indata = outdata = 0;
  94 }
  95
  96 SocketEngine::~SocketEngine()
  97 {
  98 }
  99
 100 bool SocketEngine::AddFd(EventHandler* eh)
 101 {
 102         return true;
 103 }
 104
 105 bool SocketEngine::HasFd(int fd)
 106 {
 107         if ((fd < 0) || (fd > MAX_DESCRIPTORS))
 108                 return false;
 109         return ref[fd];
 110 }
 111
 112 EventHandler* SocketEngine::GetRef(int fd)
 113 {
 114         if ((fd < 0) || (fd > MAX_DESCRIPTORS))
 115                 return 0;
 116         return ref[fd];
 117 }
 118
 119 bool SocketEngine::DelFd(EventHandler* eh, bool force)
 120 {
 121         return true;
 122 }
 123
 124 int SocketEngine::GetMaxFds()
 125 {
 126         return 0;
 127 }
 128
 129 int SocketEngine::GetRemainingFds()
 130 {
 131         return 0;
 132 }
 133
 134 int SocketEngine::DispatchEvents()
 135 {
 136         return 0;
 137 }
 138
 139 std::string SocketEngine::GetName()
 140 {
 141         return "misconfigured";
 142 }
 143
 144 bool SocketEngine::BoundsCheckFd(EventHandler* eh)
 145 {
 146         if (!eh)
 147                 return false;
 148         if ((eh->GetFd() < 0) || (eh->GetFd() > MAX_DESCRIPTORS))
 149                 return false;
 150         return true;
 151 }
 152
 153
 154 int SocketEngine::Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen)
 155 {
 156         return accept(fd->GetFd(), addr, addrlen);
 157 }
 158
 159 int SocketEngine::Close(EventHandler* fd)
 160 {
 161 #ifdef WINDOWS
 162         return closesocket(fd->GetFd());
 163 #else
 164         return close(fd->GetFd());
 165 #endif
 166 }
 167
 168 int SocketEngine::Close(int fd)
 169 {
 170 #ifdef WINDOWS
 171         return closesocket(fd);
 172 #else
 173         return close(fd);
 174 #endif
 175 }
 176
 177 int SocketEngine::Blocking(int fd)
 178 {
 179 #ifdef WINDOWS
 180         unsigned long opt = 0;
 181         return ioctlsocket(fd, FIONBIO, &opt);
 182 #else
 183         int flags = fcntl(fd, F_GETFL, 0);
 184         return fcntl(fd, F_SETFL, flags ^ O_NONBLOCK);
 185 #endif
 186 }
 187
 188 int SocketEngine::NonBlocking(int fd)
 189 {
 190 #ifdef WINDOWS
 191         unsigned long opt = 1;
 192         return ioctlsocket(fd, FIONBIO, &opt);
 193 #else
 194         int flags = fcntl(fd, F_GETFL, 0);
 195         return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 196 #endif
 197 }
 198
 199 int SocketEngine::GetSockName(EventHandler* fd, sockaddr *name, socklen_t* namelen)
 200 {
 201         return getsockname(fd->GetFd(), name, namelen);
 202 }
 203
 204 int SocketEngine::RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen)
 205 {
 206         this->UpdateStats(len, 0);
 207         return recvfrom(fd->GetFd(), (char*)buf, len, flags, from, fromlen);
 208 }
 209
 210 int SocketEngine::Send(EventHandler* fd, const void *buf, size_t len, int flags)
 211 {
 212         this->UpdateStats(0, len);
 213         return send(fd->GetFd(), (const char*)buf, len, flags);
 214 }
 215
 216 int SocketEngine::Recv(EventHandler* fd, void *buf, size_t len, int flags)
 217 {
 218         this->UpdateStats(len, 0);
 219         return recv(fd->GetFd(), (char*)buf, len, flags);
 220 }
 221
 222 int SocketEngine::SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen)
 223 {
 224         this->UpdateStats(0, len);
 225         return sendto(fd->GetFd(), (const char*)buf, len, flags, to, tolen);
 226 }
 227
 228 int SocketEngine::Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen)
 229 {
 230         return connect(fd->GetFd(), serv_addr, addrlen);
 231 }
 232
 233 int SocketEngine::Shutdown(EventHandler* fd, int how)
 234 {
 235         return shutdown(fd->GetFd(), how);
 236 }
 237
 238 int SocketEngine::Bind(int fd, const sockaddr *my_addr, socklen_t addrlen)
 239 {
 240         return bind(fd, my_addr, addrlen);
 241 }
 242
 243 int SocketEngine::Listen(int sockfd, int backlog)
 244 {
 245         return listen(sockfd, backlog);
 246 }
 247
 248 int SocketEngine::Shutdown(int fd, int how)
 249 {
 250         return shutdown(fd, how);
 251 }
 252
 253 void SocketEngine::RecoverFromFork()
 254 {
 255 }
 256
 257 void SocketEngine::UpdateStats(size_t len_in, size_t len_out)
 258 {
 259         if (lastempty != time(NULL))
 260         {
 261                 lastempty = time(NULL);
 262                 indata = outdata = 0;
 263         }
 264         indata += len_in;
 265         outdata += len_out;
 266 }
 267
 268 void SocketEngine::GetStats(float &kbitpersec_in, float &kbitpersec_out, float &kbitpersec_total)
 269 {
 270         UpdateStats(0, 0); /* Forces emptying of the values if its been more than a second */
 271         float in_kbit = indata * 8;
 272         float out_kbit = outdata * 8;
 273         kbitpersec_total = ((in_kbit + out_kbit) / 1024);
 274         kbitpersec_in = in_kbit / 1024;
 275         kbitpersec_out = out_kbit / 1024;
 276 }