src/socketengine.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 #include "inspircd_config.h"
  18 #include "globals.h"
  19 #include "inspircd.h"
  20 #ifdef USE_EPOLL
  21 #include <sys/epoll.h>
  22 #endif
  23 #ifdef USE_KQUEUE
  24 #include <sys/types.h>
  25 #include <sys/event.h>
  26 #include <sys/time.h>
  27 #endif
  28 #include <vector>
  29 #include <string>
  30 #include "socketengine.h"
  31
  32 char ref[MAX_DESCRIPTORS];
  33
  34 SocketEngine::SocketEngine()
  35 {
  36         log(DEBUG,"SocketEngine::SocketEngine()");
  37 #ifdef USE_EPOLL
  38         EngineHandle = epoll_create(MAX_DESCRIPTORS);
  39 #endif
  40 #ifdef USE_KQUEUE
  41         EngineHandle = kqueue();
  42 #endif
  43         CurrentSetSize = 0;
  44 }
  45
  46 SocketEngine::~SocketEngine()
  47 {
  48         log(DEBUG,"SocketEngine::~SocketEngine()");
  49 #ifdef USE_EPOLL
  50         close(EngineHandle);
  51 #endif
  52 #ifdef USE_KQUEUE
  53         close(EngineHandle);
  54 #endif
  55 }
  56
  57 char SocketEngine::GetType(int fd)
  58 {
  59         if ((fd < 0) || (fd > MAX_DESCRIPTORS))
  60                 return X_EMPTY_SLOT;
  61         /* Mask off the top bit used for 'read/write' state */
  62         return (ref[fd] & ~0x80);
  63 }
  64
  65 bool SocketEngine::AddFd(int fd, bool readable, char type)
  66 {
  67         if ((fd < 0) || (fd > MAX_DESCRIPTORS))
  68         {
  69                 log(DEFAULT,"ERROR: FD of %d added above max of %d",fd,MAX_DESCRIPTORS);
  70                 return false;
  71         }
  72         if (GetRemainingFds() <= 1)
  73         {
  74                 log(DEFAULT,"ERROR: System out of file descriptors!");
  75                 return false;
  76         }
  77 #ifdef USE_SELECT
  78         fds[fd] = fd;
  79 #endif
  80         ref[fd] = type;
  81         if (readable)
  82         {
  83                 log(DEBUG,"Set readbit");
  84                 ref[fd] |= X_READBIT;
  85         }
  86         log(DEBUG,"Add socket %d",fd);
  87 #ifdef USE_EPOLL
  88         struct epoll_event ev;
  89         memset(&ev,0,sizeof(struct epoll_event));
  90         log(DEBUG,"epoll: Add socket to events, ep=%d socket=%d",EngineHandle,fd);
  91         readable ? ev.events = EPOLLIN : ev.events = EPOLLOUT;
  92         ev.data.fd = fd;
  93         int i = epoll_ctl(EngineHandle, EPOLL_CTL_ADD, fd, &ev);
  94         if (i < 0)
  95         {
  96                 log(DEBUG,"epoll: List insertion failure!");
  97                 return false;
  98         }
  99 #endif
 100 #ifdef USE_KQUEUE
 101         struct kevent ke;
 102         log(DEBUG,"kqueue: Add socket to events, kq=%d socket=%d",EngineHandle,fd);
 103         EV_SET(&ke, fd, readable ? EVFILT_READ : EVFILT_WRITE, EV_ADD, 0, 0, NULL);
 104         int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL);
 105         if (i == -1)
 106         {
 107                 log(DEBUG,"kqueue: List insertion failure!");
 108                 return false;
 109         }
 110 #endif
 111         CurrentSetSize++;
 112         return true;
 113 }
 114
 115 bool SocketEngine::DelFd(int fd)
 116 {
 117         log(DEBUG,"SocketEngine::DelFd(%d)",fd);
 118
 119         if ((fd < 0) || (fd > MAX_DESCRIPTORS))
 120                 return false;
 121
 122 #ifdef USE_SELECT
 123         std::map<int,int>::iterator t = fds.find(fd);
 124         if (t != fds.end())
 125         {
 126                 fds.erase(t);
 127                 log(DEBUG,"Deleted fd %d",fd);
 128         }
 129 #endif
 130 #ifdef USE_KQUEUE
 131         struct kevent ke;
 132         EV_SET(&ke, fd, ref[fd] & X_READBIT ? EVFILT_READ : EVFILT_WRITE, EV_DELETE, 0, 0, NULL);
 133         int i = kevent(EngineHandle, &ke, 1, 0, 0, NULL);
 134         if (i == -1)
 135         {
 136                 log(DEBUG,"kqueue: Failed to remove socket from queue!");
 137                 return false;
 138         }
 139 #endif
 140 #ifdef USE_EPOLL
 141         struct epoll_event ev;
 142         memset(&ev,0,sizeof(struct epoll_event));
 143         ref[fd] && X_READBIT ? ev.events = EPOLLIN : ev.events = EPOLLOUT;
 144         ev.data.fd = fd;
 145         int i = epoll_ctl(EngineHandle, EPOLL_CTL_DEL, fd, &ev);
 146         if (i < 0)
 147         {
 148                 log(DEBUG,"epoll: List deletion failure!");
 149                 return false;
 150         }
 151 #endif
 152         CurrentSetSize--;
 153         ref[fd] = 0;
 154         return true;
 155 }
 156
 157 int SocketEngine::GetMaxFds()
 158 {
 159 #ifdef USE_SELECT
 160         return FD_SETSIZE;
 161 #endif
 162 #ifdef USE_KQUEUE
 163         return MAX_DESCRIPTORS;
 164 #endif
 165 #ifdef USE_EPOLL
 166         return MAX_DESCRIPTORS;
 167 #endif
 168 }
 169
 170 int SocketEngine::GetRemainingFds()
 171 {
 172 #ifdef USE_SELECT
 173         return FD_SETSIZE - CurrentSetSize;
 174 #endif
 175 #ifdef USE_KQUEUE
 176         return MAX_DESCRIPTORS - CurrentSetSize;
 177 #endif
 178 #ifdef USE_EPOLL
 179         return MAX_DESCRIPTORS - CurrentSetSize;
 180 #endif
 181 }
 182
 183 int SocketEngine::Wait(int* fdlist)
 184 {
 185         int result = 0;
 186 #ifdef USE_SELECT
 187         FD_ZERO(&wfdset);
 188         FD_ZERO(&rfdset);
 189         timeval tval;
 190         int sresult;
 191         for (std::map<int,int>::iterator a = fds.begin(); a != fds.end(); a++)
 192         {
 193                 if (ref[a->second] & X_READBIT)
 194                 {
 195                         FD_SET (a->second, &rfdset);
 196                 }
 197                 else
 198                 {
 199                         FD_SET (a->second, &wfdset);
 200                 }
 201
 202         }
 203         tval.tv_sec = 0;
 204         tval.tv_usec = 50L;
 205         sresult = select(FD_SETSIZE, &rfdset, &wfdset, NULL, &tval);
 206         if (sresult > 0)
 207         {
 208                 for (std::map<int,int>::iterator a = fds.begin(); a != fds.end(); a++)
 209                 {
 210                         if ((FD_ISSET (a->second, &rfdset)) || (FD_ISSET (a->second, &wfdset)))
 211                                 fdlist[result++] = a->second;
 212                 }
 213         }
 214 #endif
 215 #ifdef USE_KQUEUE
 216         ts.tv_nsec = 5000L;
 217         ts.tv_sec = 0;
 218         int i = kevent(EngineHandle, NULL, 0, &ke_list[0], MAX_DESCRIPTORS, &ts);
 219         for (int j = 0; j < i; j++)
 220                 fdlist[result++] = ke_list[j].ident;
 221 #endif
 222 #ifdef USE_EPOLL
 223         int i = epoll_wait(EngineHandle, events, MAX_DESCRIPTORS, 50);
 224         for (int j = 0; j < i; j++)
 225                 fdlist[result++] = events[j].data.fd;
 226 #endif
 227         return result;
 228 }
 229
 230 std::string SocketEngine::GetName()
 231 {
 232 #ifdef USE_SELECT
 233         return "select";
 234 #endif
 235 #ifdef USE_KQUEUE
 236         return "kqueue";
 237 #endif
 238 #ifdef USE_EPOLL
 239         return "epoll";
 240 #endif
 241         return "misconfigured";
 242 }