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         return true;
  51 }
  52
  53 bool EventHandler::DelIOHook()
  54 {
  55         if (!this->IOHook)
  56                 return false;
  57
  58         this->IOHook = false;
  59         return true;
  60 }
  61
  62 Module *EventHandler::GetIOHook()
  63 {
  64         return this->IOHook;
  65 }
  66
  67 int EventHandler::GetFd()
  68 {
  69         return this->fd;
  70 }
  71
  72 void EventHandler::SetFd(int FD)
  73 {
  74         this->fd = FD;
  75 }
  76
  77 bool EventHandler::Readable()
  78 {
  79         return true;
  80 }
  81
  82 bool EventHandler::Writeable()
  83 {
  84         return false;
  85 }
  86
  87 void SocketEngine::WantWrite(EventHandler* eh)
  88 {
  89 }
  90
  91 SocketEngine::SocketEngine(InspIRCd* Instance) : ServerInstance(Instance)
  92 {
  93         TotalEvents = WriteEvents = ReadEvents = ErrorEvents = 0;
  94         lastempty = time(NULL);
  95         indata = outdata = 0;
  96 }
  97
  98 SocketEngine::~SocketEngine()
  99 {
 100 }
 101
 102 bool SocketEngine::AddFd(EventHandler* eh)
 103 {
 104         return true;
 105 }
 106
 107 bool SocketEngine::HasFd(int fd)
 108 {
 109         if ((fd < 0) || (fd > MAX_DESCRIPTORS))
 110                 return false;
 111         return ref[fd];
 112 }
 113
 114 EventHandler* SocketEngine::GetRef(int fd)
 115 {
 116         if ((fd < 0) || (fd > MAX_DESCRIPTORS))
 117                 return 0;
 118         return ref[fd];
 119 }
 120
 121 bool SocketEngine::DelFd(EventHandler* eh, bool force)
 122 {
 123         return true;
 124 }
 125
 126 int SocketEngine::GetMaxFds()
 127 {
 128         return 0;
 129 }
 130
 131 int SocketEngine::GetRemainingFds()
 132 {
 133         return 0;
 134 }
 135
 136 int SocketEngine::DispatchEvents()
 137 {
 138         return 0;
 139 }
 140
 141 std::string SocketEngine::GetName()
 142 {
 143         return "misconfigured";
 144 }
 145
 146 bool SocketEngine::BoundsCheckFd(EventHandler* eh)
 147 {
 148         if (!eh)
 149                 return false;
 150         if ((eh->GetFd() < 0) || (eh->GetFd() > MAX_DESCRIPTORS))
 151                 return false;
 152         return true;
 153 }
 154
 155
 156 int SocketEngine::Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen)
 157 {
 158         return accept(fd->GetFd(), addr, addrlen);
 159 }
 160
 161 int SocketEngine::Close(EventHandler* fd)
 162 {
 163 #ifdef WINDOWS
 164         return closesocket(fd->GetFd());
 165 #else
 166         return close(fd->GetFd());
 167 #endif
 168 }
 169
 170 int SocketEngine::Close(int fd)
 171 {
 172 #ifdef WINDOWS
 173         return closesocket(fd);
 174 #else
 175         return close(fd);
 176 #endif
 177 }
 178
 179 int SocketEngine::Blocking(int fd)
 180 {
 181 #ifdef WINDOWS
 182         unsigned long opt = 0;
 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 int SocketEngine::NonBlocking(int fd)
 191 {
 192 #ifdef WINDOWS
 193         unsigned long opt = 1;
 194         return ioctlsocket(fd, FIONBIO, &opt);
 195 #else
 196         int flags = fcntl(fd, F_GETFL, 0);
 197         return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 198 #endif
 199 }
 200
 201 int SocketEngine::GetSockName(EventHandler* fd, sockaddr *name, socklen_t* namelen)
 202 {
 203         return getsockname(fd->GetFd(), name, namelen);
 204 }
 205
 206 int SocketEngine::RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen)
 207 {
 208         this->UpdateStats(len, 0);
 209         return recvfrom(fd->GetFd(), (char*)buf, len, flags, from, fromlen);
 210 }
 211
 212 int SocketEngine::Send(EventHandler* fd, const void *buf, size_t len, int flags)
 213 {
 214         this->UpdateStats(0, len);
 215         return send(fd->GetFd(), (const char*)buf, len, flags);
 216 }
 217
 218 int SocketEngine::Recv(EventHandler* fd, void *buf, size_t len, int flags)
 219 {
 220         this->UpdateStats(len, 0);
 221         return recv(fd->GetFd(), (char*)buf, len, flags);
 222 }
 223
 224 int SocketEngine::SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen)
 225 {
 226         this->UpdateStats(0, len);
 227         return sendto(fd->GetFd(), (const char*)buf, len, flags, to, tolen);
 228 }
 229
 230 int SocketEngine::Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen)
 231 {
 232         return connect(fd->GetFd(), serv_addr, addrlen);
 233 }
 234
 235 int SocketEngine::Shutdown(EventHandler* fd, int how)
 236 {
 237         return shutdown(fd->GetFd(), how);
 238 }
 239
 240 int SocketEngine::Bind(int fd, const sockaddr *my_addr, socklen_t addrlen)
 241 {
 242         return bind(fd, my_addr, addrlen);
 243 }
 244
 245 int SocketEngine::Listen(int sockfd, int backlog)
 246 {
 247         return listen(sockfd, backlog);
 248 }
 249
 250 int SocketEngine::Shutdown(int fd, int how)
 251 {
 252         return shutdown(fd, how);
 253 }
 254
 255 void SocketEngine::RecoverFromFork()
 256 {
 257 }
 258
 259 void SocketEngine::UpdateStats(size_t len_in, size_t len_out)
 260 {
 261         if (lastempty != time(NULL))
 262         {
 263                 lastempty = time(NULL);
 264                 indata = outdata = 0;
 265         }
 266         indata += len_in;
 267         outdata += len_out;
 268 }
 269
 270 void SocketEngine::GetStats(float &kbitpersec_in, float &kbitpersec_out, float &kbitpersec_total)
 271 {
 272         UpdateStats(0, 0); /* Forces emptying of the values if its been more than a second */
 273         float in_kbit = indata * 8;
 274         float out_kbit = outdata * 8;
 275         kbitpersec_total = ((in_kbit + out_kbit) / 1024);
 276         kbitpersec_in = in_kbit / 1024;
 277         kbitpersec_out = out_kbit / 1024;
 278 }