src/socketengine.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2009 InspIRCd Development Team
   6  * See: http://wiki.inspircd.org/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *          the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 #include "inspircd.h"
  15
  16 EventHandler::EventHandler()
  17 {
  18         fd = -1;
  19 }
  20
  21 void EventHandler::SetFd(int FD)
  22 {
  23         this->fd = FD;
  24 }
  25
  26 SocketEngine::SocketEngine()
  27 {
  28         TotalEvents = WriteEvents = ReadEvents = ErrorEvents = 0;
  29         lastempty = ServerInstance->Time();
  30         indata = outdata = 0;
  31 }
  32
  33 SocketEngine::~SocketEngine()
  34 {
  35 }
  36
  37 void SocketEngine::SetEventMask(EventHandler* eh, int mask)
  38 {
  39         eh->event_mask = mask;
  40 }
  41
  42 void SocketEngine::ChangeEventMask(EventHandler* eh, int change)
  43 {
  44         int old_m = eh->event_mask;
  45         int new_m = old_m;
  46
  47         // if we are changing read/write type, remove the previously set bit
  48         if (change & FD_WANT_READ_MASK)
  49                 new_m &= ~FD_WANT_READ_MASK;
  50         if (change & FD_WANT_WRITE_MASK)
  51                 new_m &= ~FD_WANT_WRITE_MASK;
  52
  53         // if adding a trial read/write, insert it into the set
  54         if (change & FD_TRIAL_NOTE_MASK && !(old_m & FD_TRIAL_NOTE_MASK))
  55                 trials.insert(eh->GetFd());
  56
  57         new_m |= change;
  58         if (new_m == old_m)
  59                 return;
  60
  61         eh->event_mask = new_m;
  62         OnSetEvent(eh, old_m, new_m);
  63 }
  64
  65 void SocketEngine::DispatchTrialWrites()
  66 {
  67         std::vector<int> working_list;
  68         working_list.reserve(trials.size());
  69         working_list.assign(trials.begin(), trials.end());
  70         trials.clear();
  71         for(unsigned int i=0; i < working_list.size(); i++)
  72         {
  73                 int fd = working_list[i];
  74                 EventHandler* eh = GetRef(fd);
  75                 if (!eh)
  76                         continue;
  77                 int mask = eh->event_mask;
  78                 eh->event_mask &= ~(FD_ADD_TRIAL_READ | FD_ADD_TRIAL_WRITE);
  79                 if ((mask & (FD_ADD_TRIAL_READ | FD_READ_WILL_BLOCK)) == FD_ADD_TRIAL_READ)
  80                         eh->HandleEvent(EVENT_READ, 0);
  81                 if ((mask & (FD_ADD_TRIAL_WRITE | FD_WRITE_WILL_BLOCK)) == FD_ADD_TRIAL_WRITE)
  82                         eh->HandleEvent(EVENT_WRITE, 0);
  83         }
  84 }
  85
  86 bool SocketEngine::HasFd(int fd)
  87 {
  88         if ((fd < 0) || (fd > GetMaxFds()))
  89                 return false;
  90         return ref[fd];
  91 }
  92
  93 EventHandler* SocketEngine::GetRef(int fd)
  94 {
  95         if ((fd < 0) || (fd > GetMaxFds()))
  96                 return 0;
  97         return ref[fd];
  98 }
  99
 100 bool SocketEngine::BoundsCheckFd(EventHandler* eh)
 101 {
 102         if (!eh)
 103                 return false;
 104         if ((eh->GetFd() < 0) || (eh->GetFd() > GetMaxFds()))
 105                 return false;
 106         return true;
 107 }
 108
 109
 110 int SocketEngine::Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen)
 111 {
 112         return accept(fd->GetFd(), addr, addrlen);
 113 }
 114
 115 int SocketEngine::Close(EventHandler* fd)
 116 {
 117 #ifdef WINDOWS
 118         return closesocket(fd->GetFd());
 119 #else
 120         return close(fd->GetFd());
 121 #endif
 122 }
 123
 124 int SocketEngine::Close(int fd)
 125 {
 126 #ifdef WINDOWS
 127         return closesocket(fd);
 128 #else
 129         return close(fd);
 130 #endif
 131 }
 132
 133 int SocketEngine::Blocking(int fd)
 134 {
 135 #ifdef WINDOWS
 136         unsigned long opt = 0;
 137         return ioctlsocket(fd, FIONBIO, &opt);
 138 #else
 139         int flags = fcntl(fd, F_GETFL, 0);
 140         return fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
 141 #endif
 142 }
 143
 144 int SocketEngine::NonBlocking(int fd)
 145 {
 146 #ifdef WINDOWS
 147         unsigned long opt = 1;
 148         return ioctlsocket(fd, FIONBIO, &opt);
 149 #else
 150         int flags = fcntl(fd, F_GETFL, 0);
 151         return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 152 #endif
 153 }
 154
 155 void SocketEngine::SetReuse(int fd)
 156 {
 157         int on = 1;
 158         struct linger linger = { 0, 0 };
 159         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on));
 160         /* This is BSD compatible, setting l_onoff to 0 is *NOT* http://web.irc.org/mla/ircd-dev/msg02259.html */
 161         linger.l_onoff = 1;
 162         linger.l_linger = 1;
 163         setsockopt(fd, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
 164 }
 165
 166 int SocketEngine::RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen)
 167 {
 168         this->UpdateStats(len, 0);
 169         return recvfrom(fd->GetFd(), (char*)buf, len, flags, from, fromlen);
 170 }
 171
 172 int SocketEngine::Send(EventHandler* fd, const void *buf, size_t len, int flags)
 173 {
 174         this->UpdateStats(0, len);
 175         return send(fd->GetFd(), (char*)buf, len, flags);
 176 }
 177
 178 int SocketEngine::Recv(EventHandler* fd, void *buf, size_t len, int flags)
 179 {
 180         this->UpdateStats(len, 0);
 181         return recv(fd->GetFd(), (char*)buf, len, flags);
 182 }
 183
 184 int SocketEngine::SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen)
 185 {
 186         this->UpdateStats(0, len);
 187         return sendto(fd->GetFd(), (char*)buf, len, flags, to, tolen);
 188 }
 189
 190 int SocketEngine::Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen)
 191 {
 192         return connect(fd->GetFd(), serv_addr, addrlen);
 193 }
 194
 195 int SocketEngine::Shutdown(EventHandler* fd, int how)
 196 {
 197         return shutdown(fd->GetFd(), how);
 198 }
 199
 200 int SocketEngine::Bind(int fd, const irc::sockets::sockaddrs& addr)
 201 {
 202         return bind(fd, &addr.sa, addr.sa_size());
 203 }
 204
 205 int SocketEngine::Listen(int sockfd, int backlog)
 206 {
 207         return listen(sockfd, backlog);
 208 }
 209
 210 int SocketEngine::Shutdown(int fd, int how)
 211 {
 212         return shutdown(fd, how);
 213 }
 214
 215 void SocketEngine::RecoverFromFork()
 216 {
 217 }
 218
 219 void SocketEngine::UpdateStats(size_t len_in, size_t len_out)
 220 {
 221         if (lastempty != ServerInstance->Time())
 222         {
 223                 lastempty = ServerInstance->Time();
 224                 indata = outdata = 0;
 225         }
 226         indata += len_in;
 227         outdata += len_out;
 228 }
 229
 230 void SocketEngine::GetStats(float &kbitpersec_in, float &kbitpersec_out, float &kbitpersec_total)
 231 {
 232         UpdateStats(0, 0); /* Forces emptying of the values if its been more than a second */
 233         float in_kbit = indata * 8;
 234         float out_kbit = outdata * 8;
 235         kbitpersec_total = ((in_kbit + out_kbit) / 1024);
 236         kbitpersec_in = in_kbit / 1024;
 237         kbitpersec_out = out_kbit / 1024;
 238 }