]> git.netwichtig.de Git - user/henk/code/inspircd.git/blob - src/socketengines/socketengine_poll.cpp
7a026891bb8352d3112cc198af2320d82fac7ab8
[user/henk/code/inspircd.git] / src / socketengines / socketengine_poll.cpp
1 /*
2  * InspIRCd -- Internet Relay Chat Daemon
3  *
4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
5  *   Copyright (C) 2009 Uli Schlachter <psychon@znc.in>
6  *   Copyright (C) 2009 Craig Edwards <craigedwards@brainbox.cc>
7  *   Copyright (C) 2008 Robin Burchell <robin+git@viroteck.net>
8  *
9  * This file is part of InspIRCd.  InspIRCd is free software: you can
10  * redistribute it and/or modify it under the terms of the GNU General Public
11  * License as published by the Free Software Foundation, version 2.
12  *
13  * This program is distributed in the hope that it will be useful, but WITHOUT
14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
15  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
16  * details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
20  */
21
22
23 #include "inspircd.h"
24 #include "exitcodes.h"
25
26 #ifndef SOCKETENGINE_POLL
27 #define SOCKETENGINE_POLL
28
29 #include <vector>
30 #include <string>
31 #include <map>
32 #include "inspircd_config.h"
33 #include "inspircd.h"
34 #include "socketengine.h"
35
36 #ifndef WINDOWS
37         #ifndef __USE_XOPEN
38             #define __USE_XOPEN /* fuck every fucking OS ever made. needed by poll.h to work.*/
39         #endif
40         #include <poll.h>
41         #include <sys/poll.h>
42 #else
43         /* *grumble* */
44         #define struct pollfd WSAPOLLFD
45         #define poll WSAPoll
46 #endif
47
48 class InspIRCd;
49
50 /** A specialisation of the SocketEngine class, designed to use poll().
51  */
52 class PollEngine : public SocketEngine
53 {
54 private:
55         /** These are used by poll() to hold socket events
56          */
57         struct pollfd *events;
58         /** This map maps fds to an index in the events array.
59          */
60         std::map<int, unsigned int> fd_mappings;
61 public:
62         /** Create a new PollEngine
63          */
64         PollEngine();
65         /** Delete a PollEngine
66          */
67         virtual ~PollEngine();
68         virtual bool AddFd(EventHandler* eh, int event_mask);
69         virtual void OnSetEvent(EventHandler* eh, int old_mask, int new_mask);
70         virtual EventHandler* GetRef(int fd);
71         virtual void DelFd(EventHandler* eh);
72         virtual int DispatchEvents();
73         virtual std::string GetName();
74 };
75
76 #endif
77
78 #include <ulimit.h>
79 #ifdef __FreeBSD__
80         #include <sys/sysctl.h>
81 #endif
82
83 PollEngine::PollEngine()
84 {
85         CurrentSetSize = 0;
86 #ifndef __FreeBSD__
87         int max = ulimit(4, 0);
88         if (max > 0)
89         {
90                 MAX_DESCRIPTORS = max;
91         }
92         else
93         {
94                 ServerInstance->Logs->Log("SOCKET", DEFAULT, "ERROR: Can't determine maximum number of open sockets: %s", strerror(errno));
95                 printf("ERROR: Can't determine maximum number of open sockets: %s\n", strerror(errno));
96                 ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
97         }
98 #else
99         int mib[2];
100         size_t len;
101
102         mib[0] = CTL_KERN;
103         mib[1] = KERN_MAXFILES;
104         len = sizeof(MAX_DESCRIPTORS);
105         sysctl(mib, 2, &MAX_DESCRIPTORS, &len, NULL, 0);
106 #endif
107
108         ref = new EventHandler* [GetMaxFds()];
109         events = new struct pollfd[GetMaxFds()];
110
111         memset(events, 0, GetMaxFds() * sizeof(struct pollfd));
112         memset(ref, 0, GetMaxFds() * sizeof(EventHandler*));
113 }
114
115 PollEngine::~PollEngine()
116 {
117         // No destruction required, either.
118         delete[] ref;
119         delete[] events;
120 }
121
122 static int mask_to_poll(int event_mask)
123 {
124         int rv = 0;
125         if (event_mask & (FD_WANT_POLL_READ | FD_WANT_FAST_READ))
126                 rv |= POLLIN;
127         if (event_mask & (FD_WANT_POLL_WRITE | FD_WANT_FAST_WRITE | FD_WANT_SINGLE_WRITE))
128                 rv |= POLLOUT;
129         return rv;
130 }
131
132 bool PollEngine::AddFd(EventHandler* eh, int event_mask)
133 {
134         int fd = eh->GetFd();
135         if ((fd < 0) || (fd > GetMaxFds() - 1))
136         {
137                 ServerInstance->Logs->Log("SOCKET",DEBUG,"AddFd out of range: (fd: %d, max: %d)", fd, GetMaxFds());
138                 return false;
139         }
140
141         if (fd_mappings.find(fd) != fd_mappings.end())
142         {
143                 ServerInstance->Logs->Log("SOCKET",DEBUG,"Attempt to add duplicate fd: %d", fd);
144                 return false;
145         }
146
147         unsigned int index = CurrentSetSize;
148
149         fd_mappings[fd] = index;
150         ref[index] = eh;
151         events[index].fd = fd;
152         events[index].events = mask_to_poll(event_mask);
153
154         ServerInstance->Logs->Log("SOCKET", DEBUG,"New file descriptor: %d (%d; index %d)", fd, events[fd].events, index);
155         SocketEngine::SetEventMask(eh, event_mask);
156         CurrentSetSize++;
157         return true;
158 }
159
160 EventHandler* PollEngine::GetRef(int fd)
161 {
162         std::map<int, unsigned int>::iterator it = fd_mappings.find(fd);
163         if (it == fd_mappings.end())
164                 return NULL;
165         return ref[it->second];
166 }
167
168 void PollEngine::OnSetEvent(EventHandler* eh, int old_mask, int new_mask)
169 {
170         std::map<int, unsigned int>::iterator it = fd_mappings.find(eh->GetFd());
171         if (it == fd_mappings.end())
172         {
173                 ServerInstance->Logs->Log("SOCKET",DEBUG,"SetEvents() on unknown fd: %d", eh->GetFd());
174                 return;
175         }
176
177         events[it->second].events = mask_to_poll(new_mask);
178 }
179
180 void PollEngine::DelFd(EventHandler* eh)
181 {
182         int fd = eh->GetFd();
183         if ((fd < 0) || (fd > MAX_DESCRIPTORS))
184         {
185                 ServerInstance->Logs->Log("SOCKET", DEBUG, "DelFd out of range: (fd: %d, max: %d)", fd, GetMaxFds());
186                 return;
187         }
188
189         std::map<int, unsigned int>::iterator it = fd_mappings.find(fd);
190         if (it == fd_mappings.end())
191         {
192                 ServerInstance->Logs->Log("SOCKET",DEBUG,"DelFd() on unknown fd: %d", fd);
193                 return;
194         }
195
196         unsigned int index = it->second;
197         unsigned int last_index = CurrentSetSize - 1;
198         int last_fd = events[last_index].fd;
199
200         if (index != last_index)
201         {
202                 // We need to move the last fd we got into this gap (gaps are evil!)
203
204                 // So update the mapping for the last fd to its new position
205                 fd_mappings[last_fd] = index;
206
207                 // move last_fd from last_index into index
208                 events[index].fd = last_fd;
209                 events[index].events = events[last_index].events;
210
211                 ref[index] = ref[last_index];
212         }
213
214         // Now remove all data for the last fd we got into out list.
215         // Above code made sure this always is right
216         fd_mappings.erase(it);
217         events[last_index].fd = 0;
218         events[last_index].events = 0;
219         ref[last_index] = NULL;
220
221         CurrentSetSize--;
222
223         ServerInstance->Logs->Log("SOCKET", DEBUG, "Remove file descriptor: %d (index: %d) "
224                         "(Filled gap with: %d (index: %d))", fd, index, last_fd, last_index);
225 }
226
227 int PollEngine::DispatchEvents()
228 {
229         int i = poll(events, CurrentSetSize, 1000);
230         int index;
231         socklen_t codesize = sizeof(int);
232         int errcode;
233         int processed = 0;
234         ServerInstance->UpdateTime();
235
236         if (i > 0)
237         {
238                 for (index = 0; index < CurrentSetSize && processed != i; index++)
239                 {
240                         if (events[index].revents)
241                                 processed++;
242                         EventHandler* eh = ref[index];
243                         if (!eh)
244                                 continue;
245
246                         if (events[index].revents & POLLHUP)
247                         {
248                                 eh->HandleEvent(EVENT_ERROR, 0);
249                                 continue;
250                         }
251
252                         if (events[index].revents & POLLERR)
253                         {
254                                 // Get fd
255                                 int fd = events[index].fd;
256
257                                 // Get error number
258                                 if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &errcode, &codesize) < 0)
259                                         errcode = errno;
260                                 eh->HandleEvent(EVENT_ERROR, errcode);
261                                 continue;
262                         }
263
264                         if (events[index].revents & POLLIN)
265                         {
266                                 SetEventMask(eh, eh->GetEventMask() & ~FD_READ_WILL_BLOCK);
267                                 eh->HandleEvent(EVENT_READ);
268                                 if (eh != ref[index])
269                                         // whoops, deleted out from under us
270                                         continue;
271                         }
272                         
273                         if (events[index].revents & POLLOUT)
274                         {
275                                 int mask = eh->GetEventMask();
276                                 mask &= ~(FD_WRITE_WILL_BLOCK | FD_WANT_SINGLE_WRITE);
277                                 SetEventMask(eh, mask);
278                                 events[index].events = mask_to_poll(mask);
279                                 eh->HandleEvent(EVENT_WRITE);
280                         }
281                 }
282         }
283
284         return i;
285 }
286
287 std::string PollEngine::GetName()
288 {
289         return "poll";
290 }
291
292 SocketEngine* CreateSocketEngine()
293 {
294         return new PollEngine;
295 }