]>
jfr.im git - solanum.git/blob - libcharybdis/kqueue.c
2 * ircd-ratbox: A slightly useful ircd.
3 * kqueue.c: FreeBSD kqueue compatible network routines.
5 * Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
6 * Copyright (C) 1996-2002 Hybrid Development Team
7 * Copyright (C) 2001 Adrian Chadd <adrian@creative.net.au>
8 * Copyright (C) 2002-2005 ircd-ratbox development team
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
25 * $Id: kqueue.c 3241 2007-03-05 17:52:28Z jilles $
29 #include <sys/event.h>
31 #include "libcharybdis.h"
33 #define KE_LENGTH MAX_CLIENTS
35 /* jlemon goofed up and didn't add EV_SET until fbsd 4.3 */
38 #define EV_SET(kevp, a, b, c, d, e, f) do { \
39 (kevp)->ident = (a); \
40 (kevp)->filter = (b); \
41 (kevp)->flags = (c); \
42 (kevp)->fflags = (d); \
44 (kevp)->udata = (f); \
48 static void kq_update_events(fde_t
*, short, PF
*);
50 static struct timespec zero_timespec
;
52 static struct kevent
*kqlst
; /* kevent buffer */
53 static int kqmax
; /* max structs to buffer */
54 static int kqoff
; /* offset into the buffer */
57 /* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */
58 /* Private functions */
61 kq_update_events(fde_t
* F
, short filter
, PF
* handler
)
69 cur_handler
= F
->read_handler
;
72 cur_handler
= F
->write_handler
;
75 /* XXX bad! -- adrian */
80 if((cur_handler
== NULL
&& handler
!= NULL
) || (cur_handler
!= NULL
&& handler
== NULL
))
88 if(filter
== EVFILT_WRITE
)
89 kep_flags
= (EV_ADD
| EV_ENABLE
| EV_ONESHOT
);
91 kep_flags
= (EV_ADD
| EV_ENABLE
);
95 /* lets definately not poll stuff that isn't real --
96 * some kqueue implementations hate doing this... and
97 * it's intended to delete AND disable at the same time.
99 * don't believe me? read kevent(4). --nenolod
101 kep_flags
= (EV_DELETE
| EV_DISABLE
);
104 EV_SET(kep
, (uintptr_t) F
->fd
, filter
, kep_flags
, 0, 0, (void *) F
);
110 ret
= kevent(kq
, kqlst
, kqoff
, NULL
, 0, &zero_timespec
);
111 /* jdc -- someone needs to do error checking... */
114 libcharybdis_log("kq_update_events(): kevent(): %s", strerror(errno
));
124 /* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */
125 /* Public functions */
131 * This is a needed exported function which will be called to initialise
132 * the network loop code.
140 libcharybdis_log("init_netio: Couldn't open kqueue fd!\n");
141 exit(115); /* Whee! */
143 kqmax
= getdtablesize();
144 kqlst
= MyMalloc(sizeof(struct kevent
) * kqmax
);
145 zero_timespec
.tv_sec
= 0;
146 zero_timespec
.tv_nsec
= 0;
152 * This is a needed exported function which will be called to register
153 * and deregister interest in a pending IO state for a given FD.
156 comm_setselect(int fd
, fdlist_t list
, unsigned int type
, PF
* handler
,
157 void *client_data
, time_t timeout
)
159 fde_t
*F
= comm_locate_fd(fd
);
161 s_assert(F
->flags
.open
);
163 /* Update the list, even though we're not using it .. */
166 if(type
& COMM_SELECT_READ
)
168 kq_update_events(F
, EVFILT_READ
, handler
);
169 F
->read_handler
= handler
;
170 F
->read_data
= client_data
;
172 if(type
& COMM_SELECT_WRITE
)
174 kq_update_events(F
, EVFILT_WRITE
, handler
);
175 F
->write_handler
= handler
;
176 F
->write_data
= client_data
;
179 F
->timeout
= CurrentTime
+ (timeout
/ 1000);
184 * Check all connections for new connections and input data that is to be
185 * processed. Also check for connections with data queued and whether we can
192 * Called to do the new-style IO, courtesy of squid (like most of this
193 * new IO code). This routine handles the stuff we've hidden in
194 * comm_setselect and fd_table[] and calls callbacks for IO ready
199 comm_select(unsigned long delay
)
202 static struct kevent ke
[KE_LENGTH
];
203 struct timespec poll_time
;
206 * remember we are doing NANOseconds here, not micro/milli. God knows
207 * why jlemon used a timespec, but hey, he wrote the interface, not I
211 poll_time
.tv_sec
= delay
/ 1000;
213 poll_time
.tv_nsec
= (delay
% 1000) * 1000000;
217 num
= kevent(kq
, kqlst
, kqoff
, ke
, KE_LENGTH
, &poll_time
);
223 if(ignoreErrno(errno
))
236 return COMM_OK
; /* No error.. */
238 for (i
= 0; i
< num
; i
++)
240 int fd
= (int) ke
[i
].ident
;
242 fde_t
*F
= comm_locate_fd(fd
);
244 if(ke
[i
].flags
& EV_ERROR
)
246 errno
= (int) ke
[i
].data
;
247 /* XXX error == bad! -- adrian */
252 /* XXX this is because of our "queueing" of
253 * kqueue changes so we may get ones for fds
254 * we have already closed? -- jilles */
258 switch (ke
[i
].filter
)
263 if((hdl
= F
->read_handler
) != NULL
)
265 F
->read_handler
= NULL
;
266 hdl(fd
, F
->read_data
);
273 if((hdl
= F
->write_handler
) != NULL
)
275 F
->write_handler
= NULL
;
276 hdl(fd
, F
->write_data
);