added SSL backend for IOMultiplexer
[TransparentIRC.git] / src / IOEngine_kevent.c
1 /* IOengine_kevent.c - TransparentIRC 0.1
2  * Copyright (C) 2011-2012  Philipp Kreil (pk910)
3  * 
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  * 
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  * 
14  * You should have received a copy of the GNU General Public License 
15  * along with this program. If not, see <http://www.gnu.org/licenses/>. 
16  */
17 #include "IOEngine.h"
18 #include "IOHandler.h"
19
20 #ifdef HAVE_SYS_EVENT_H
21 #include <sys/event.h>
22
23 #define MAX_EVENTS 32
24
25 static int kevent_fd;
26
27 static int engine_kevent_init() {
28     kevent_fd = kqueue();
29     if (kevent_fd < 0)
30         return 0;
31     return 1;
32 }
33
34 static void engine_kevent_add(struct IODescriptor *iofd) {
35     if(iofd->type == IOTYPE_TIMER) return;
36     //add descriptor to the kevent queue
37     struct kevent changes[2];
38     int nchanges = 0;
39     int res;
40
41     EV_SET(&changes[nchanges++], iofd->fd, EVFILT_READ, EV_ADD, 0, 0, iofd);
42     if (iohandler_wants_writes(iofd))
43         EV_SET(&changes[nchanges++], iofd->fd, EVFILT_WRITE, EV_ADD, 0, 0, iofd);
44     
45     res = kevent(kevent_fd, changes, nchanges, NULL, 0, NULL);
46     if(res < 0)
47         iohandler_log(IOLOG_ERROR, "could not add IODescriptor %d to kevent queue. (returned: %d)", res);
48     }
49 }
50
51 static void engine_kevent_remove(struct IODescriptor *iofd) {
52     if(iofd->type == IOTYPE_TIMER) return;
53     struct kevent changes[2];
54     int nchanges = 0;
55
56     EV_SET(&changes[nchanges++], iofd->fd, EVFILT_READ, EV_DELETE, 0, 0, iofd);
57     EV_SET(&changes[nchanges++], iofd->fd, EVFILT_WRITE, EV_DELETE, 0, 0, iofd);
58     kevent(kevent_fd, changes, nchanges, NULL, 0, NULL);
59 }
60
61 static void engine_kevent_update(struct IODescriptor *iofd) {
62     if(iofd->type == IOTYPE_TIMER) return;
63     struct kevent changes[2];
64     int nchanges = 0;
65     int res;
66
67     EV_SET(&changes[nchanges++], iofd->fd, EVFILT_READ, EV_ADD, 0, 0, iofd);
68     EV_SET(&changes[nchanges++], iofd->fd, EVFILT_WRITE, iohandler_wants_writes(iofd) ? EV_ADD : EV_DELETE, 0, 0, iofd);
69     
70     res = kevent(kevent_fd, changes, nchanges, NULL, 0, NULL);
71     if(res < 0) {
72         iohandler_log(IOLOG_ERROR, "could not update IODescriptor %d in kevent queue. (returned: %d)", res);
73     }
74 }
75
76 static void engine_kevent_loop(struct timeval *timeout) {
77     struct kevent evts[MAX_EVENTS];
78     struct timeval now, tdiff;
79     struct timespec ts, *ptr
80     int msec;
81     int events;
82     int kevent_result;
83     
84     gettimeofday(&now, NULL);
85     
86     while(timer_priority) {
87         tdiff.tv_sec = timer_priority->timeout.tv_sec - now.tv_sec;
88         tdiff.tv_usec = timer_priority->timeout.tv_usec - now.tv_usec;
89         if(tdiff.tv_sec < 0 || (tdiff.tv_sec == 0 && tdiff.tv_usec <= 0)) {
90             iohandler_events(timer_priority, 0, 0);
91             iohandler_close(timer_priority); //also sets timer_priority to the next timed element
92             continue;
93         } else if(tdiff.tv_usec < 0) {
94             tdiff.tv_sec--;
95             tdiff.tv_usec += 1000000; //1 sec
96         }
97         if(timeval_is_smaler((&tdiff), timeout)) {
98             timeout->tv_sec = tdiff.tv_sec;
99             timeout->tv_usec = tdiff.tv_usec;
100         }
101         break;
102     }
103     
104     if (timeout) {
105         ts.tv_sec = timeout->tv_sec;
106         ts.tv_nsec = timeout->tv_usec * 1000;
107         pts = &ts;
108     } else {
109         pts = NULL;
110     }
111     
112     //select system call
113     kevent_result = kevent(kq_fd, NULL, 0, events, MAX_EVENTS, pts);
114     
115     if (kevent_result < 0) {
116         if (errno != EINTR) {
117             iohandler_log(IOLOG_FATAL, "kevent() failed with errno %d: %s", errno, strerror(errno));
118             return;
119         }
120     } else {
121         int i;
122         for(i = 0; i < kevent_result; i++)
123             iohandler_events(evts[i].udata, (evts[i].filter == EVFILT_READ), (evts[i].filter == EVFILT_WRITE));
124     }
125     
126     //check timers
127     while(timer_priority) {
128         tdiff.tv_sec = timer_priority->timeout.tv_sec - now.tv_sec;
129         tdiff.tv_usec = timer_priority->timeout.tv_usec - now.tv_usec;
130         if(tdiff.tv_sec < 0 || (tdiff.tv_sec == 0 && tdiff.tv_usec <= 0)) {
131             iohandler_events(timer_priority, 0, 0);
132             iohandler_close(timer_priority); //also sets timer_priority to the next timed element
133             continue;
134         }
135         break;
136     }
137     
138 }
139
140 static void engine_kevent_cleanup() {
141     close(kevent_fd);
142 }
143
144 struct IOEngine engine_kevent = {
145     .name = "kevent",
146     .init = engine_kevent_init,
147     .add = engine_kevent_add,
148     .remove = engine_kevent_remove,
149     .update = engine_kevent_update,
150     .loop = engine_kevent_loop,
151     .cleanup = engine_kevent_cleanup,
152 };
153
154 #else
155
156 struct IOEngine engine_kevent = {
157     .name = "kevent",
158     .init = NULL,
159     .add = NULL,
160     .remove = NULL,
161     .update = NULL,
162     .loop = NULL,
163     .cleanup = NULL,
164 };
165
166 #endif