1 /* select - Module containing unix select(2) call.
2 Under Unix, the file descriptors are small integers.
3 Under Win32, select only exists for sockets, and sockets may
4 have any value except INVALID_SOCKET.
5 Under BeOS, we suffer the same dichotomy as Win32; sockets can be anything
6 >= 0.
7 */
8
9 #include "Python.h"
10 #include <structmember.h>
11
12 #ifdef __APPLE__
13 /* Perform runtime testing for a broken poll on OSX to make it easier
14 * to use the same binary on multiple releases of the OS.
15 */
16 #undef HAVE_BROKEN_POLL
17 #endif
18
19 /* Windows #defines FD_SETSIZE to 64 if FD_SETSIZE isn't already defined.
20 64 is too small (too many people have bumped into that limit).
21 Here we boost it.
22 Users who want even more than the boosted limit should #define
23 FD_SETSIZE higher before this; e.g., via compiler /D switch.
24 */
25 #if defined(MS_WINDOWS) && !defined(FD_SETSIZE)
26 #define FD_SETSIZE 512
27 #endif
28
29 #if defined(HAVE_POLL_H)
30 #include <poll.h>
31 #elif defined(HAVE_SYS_POLL_H)
32 #include <sys/poll.h>
33 #endif
34
35 #ifdef __sgi
36 /* This is missing from unistd.h */
37 extern void bzero(void *, int);
38 #endif
39
40 #ifdef HAVE_SYS_TYPES_H
41 #include <sys/types.h>
42 #endif
43
44 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
45 #include <sys/time.h>
46 #include <utils.h>
47 #endif
48
49 #ifdef MS_WINDOWS
50 # include <winsock2.h>
51 #else
52 # define SOCKET int
53 # ifdef __BEOS__
54 # include <net/socket.h>
55 # elif defined(__VMS)
56 # include <socket.h>
57 # endif
58 #endif
59
60 static PyObject *SelectError;
61
62 /* list of Python objects and their file descriptor */
63 typedef struct {
64 PyObject *obj; /* owned reference */
65 SOCKET fd;
66 int sentinel; /* -1 == sentinel */
67 } pylist;
68
69 static void
reap_obj(pylist fd2obj[FD_SETSIZE+1])70 reap_obj(pylist fd2obj[FD_SETSIZE + 1])
71 {
72 int i;
73 for (i = 0; i < FD_SETSIZE + 1 && fd2obj[i].sentinel >= 0; i++) {
74 Py_CLEAR(fd2obj[i].obj);
75 }
76 fd2obj[0].sentinel = -1;
77 }
78
79
80 /* returns -1 and sets the Python exception if an error occurred, otherwise
81 returns a number >= 0
82 */
83 static int
seq2set(PyObject * seq,fd_set * set,pylist fd2obj[FD_SETSIZE+1])84 seq2set(PyObject *seq, fd_set *set, pylist fd2obj[FD_SETSIZE + 1])
85 {
86 int i;
87 int max = -1;
88 int index = 0;
89 PyObject* fast_seq = NULL;
90 PyObject* o = NULL;
91
92 fd2obj[0].obj = (PyObject*)0; /* set list to zero size */
93 FD_ZERO(set);
94
95 fast_seq = PySequence_Fast(seq, "arguments 1-3 must be sequences");
96 if (!fast_seq)
97 return -1;
98
99 for (i = 0; i < PySequence_Fast_GET_SIZE(fast_seq); i++) {
100 SOCKET v;
101
102 /* any intervening fileno() calls could decr this refcnt */
103 if (!(o = PySequence_Fast_GET_ITEM(fast_seq, i)))
104 return -1;
105
106 Py_INCREF(o);
107 v = PyObject_AsFileDescriptor( o );
108 if (v == -1) goto finally;
109
110 #if defined(_MSC_VER)
111 max = 0; /* not used for Win32 */
112 #else /* !_MSC_VER */
113 if (!_PyIsSelectable_fd(v)) {
114 PyErr_SetString(PyExc_ValueError,
115 "filedescriptor out of range in select()");
116 goto finally;
117 }
118 if (v > max)
119 max = v;
120 #endif /* _MSC_VER */
121 FD_SET(v, set);
122
123 /* add object and its file descriptor to the list */
124 if (index >= FD_SETSIZE) {
125 PyErr_SetString(PyExc_ValueError,
126 "too many file descriptors in select()");
127 goto finally;
128 }
129 fd2obj[index].obj = o;
130 fd2obj[index].fd = v;
131 fd2obj[index].sentinel = 0;
132 fd2obj[++index].sentinel = -1;
133 }
134 Py_DECREF(fast_seq);
135 return max+1;
136
137 finally:
138 Py_XDECREF(o);
139 Py_DECREF(fast_seq);
140 return -1;
141 }
142
143 /* returns NULL and sets the Python exception if an error occurred */
144 static PyObject *
set2list(fd_set * set,pylist fd2obj[FD_SETSIZE+1])145 set2list(fd_set *set, pylist fd2obj[FD_SETSIZE + 1])
146 {
147 int i, j, count=0;
148 PyObject *list, *o;
149 SOCKET fd;
150
151 for (j = 0; fd2obj[j].sentinel >= 0; j++) {
152 if (FD_ISSET(fd2obj[j].fd, set))
153 count++;
154 }
155 list = PyList_New(count);
156 if (!list)
157 return NULL;
158
159 i = 0;
160 for (j = 0; fd2obj[j].sentinel >= 0; j++) {
161 fd = fd2obj[j].fd;
162 if (FD_ISSET(fd, set)) {
163 o = fd2obj[j].obj;
164 fd2obj[j].obj = NULL;
165 /* transfer ownership */
166 if (PyList_SetItem(list, i, o) < 0)
167 goto finally;
168
169 i++;
170 }
171 }
172 return list;
173 finally:
174 Py_DECREF(list);
175 return NULL;
176 }
177
178 #undef SELECT_USES_HEAP
179 #if FD_SETSIZE > 1024
180 #define SELECT_USES_HEAP
181 #endif /* FD_SETSIZE > 1024 */
182
183 static PyObject *
select_select(PyObject * self,PyObject * args)184 select_select(PyObject *self, PyObject *args)
185 {
186 #ifdef SELECT_USES_HEAP
187 pylist *rfd2obj, *wfd2obj, *efd2obj;
188 #else /* !SELECT_USES_HEAP */
189 /* XXX: All this should probably be implemented as follows:
190 * - find the highest descriptor we're interested in
191 * - add one
192 * - that's the size
193 * See: Stevens, APitUE, $12.5.1
194 */
195 pylist rfd2obj[FD_SETSIZE + 1];
196 pylist wfd2obj[FD_SETSIZE + 1];
197 pylist efd2obj[FD_SETSIZE + 1];
198 #endif /* SELECT_USES_HEAP */
199 PyObject *ifdlist, *ofdlist, *efdlist;
200 PyObject *ret = NULL;
201 PyObject *tout = Py_None;
202 fd_set ifdset, ofdset, efdset;
203 double timeout;
204 struct timeval tv, *tvp;
205 long seconds;
206 int imax, omax, emax, max;
207 int n;
208
209 /* convert arguments */
210 if (!PyArg_UnpackTuple(args, "select", 3, 4,
211 &ifdlist, &ofdlist, &efdlist, &tout))
212 return NULL;
213
214 if (tout == Py_None)
215 tvp = (struct timeval *)0;
216 else if (!PyNumber_Check(tout)) {
217 PyErr_SetString(PyExc_TypeError,
218 "timeout must be a float or None");
219 return NULL;
220 }
221 else {
222 timeout = PyFloat_AsDouble(tout);
223 if (timeout == -1 && PyErr_Occurred())
224 return NULL;
225 if (timeout > (double)LONG_MAX) {
226 PyErr_SetString(PyExc_OverflowError,
227 "timeout period too long");
228 return NULL;
229 }
230 seconds = (long)timeout;
231 timeout = timeout - (double)seconds;
232 tv.tv_sec = seconds;
233 tv.tv_usec = (long)(timeout * 1E6);
234 tvp = &tv;
235 }
236
237
238 #ifdef SELECT_USES_HEAP
239 /* Allocate memory for the lists */
240 rfd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1);
241 wfd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1);
242 efd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1);
243 if (rfd2obj == NULL || wfd2obj == NULL || efd2obj == NULL) {
244 if (rfd2obj) PyMem_DEL(rfd2obj);
245 if (wfd2obj) PyMem_DEL(wfd2obj);
246 if (efd2obj) PyMem_DEL(efd2obj);
247 return PyErr_NoMemory();
248 }
249 #endif /* SELECT_USES_HEAP */
250 /* Convert sequences to fd_sets, and get maximum fd number
251 * propagates the Python exception set in seq2set()
252 */
253 rfd2obj[0].sentinel = -1;
254 wfd2obj[0].sentinel = -1;
255 efd2obj[0].sentinel = -1;
256 if ((imax=seq2set(ifdlist, &ifdset, rfd2obj)) < 0)
257 goto finally;
258 if ((omax=seq2set(ofdlist, &ofdset, wfd2obj)) < 0)
259 goto finally;
260 if ((emax=seq2set(efdlist, &efdset, efd2obj)) < 0)
261 goto finally;
262 max = imax;
263 if (omax > max) max = omax;
264 if (emax > max) max = emax;
265
266 Py_BEGIN_ALLOW_THREADS
267 n = select(max, &ifdset, &ofdset, &efdset, tvp);
268 Py_END_ALLOW_THREADS
269
270 #ifdef MS_WINDOWS
271 if (n == SOCKET_ERROR) {
272 PyErr_SetExcFromWindowsErr(SelectError, WSAGetLastError());
273 }
274 #else
275 if (n < 0) {
276 PyErr_SetFromErrno(SelectError);
277 }
278 #endif
279 else {
280 /* any of these three calls can raise an exception. it's more
281 convenient to test for this after all three calls... but
282 is that acceptable?
283 */
284 ifdlist = set2list(&ifdset, rfd2obj);
285 ofdlist = set2list(&ofdset, wfd2obj);
286 efdlist = set2list(&efdset, efd2obj);
287 if (PyErr_Occurred())
288 ret = NULL;
289 else
290 ret = PyTuple_Pack(3, ifdlist, ofdlist, efdlist);
291
292 Py_DECREF(ifdlist);
293 Py_DECREF(ofdlist);
294 Py_DECREF(efdlist);
295 }
296
297 finally:
298 reap_obj(rfd2obj);
299 reap_obj(wfd2obj);
300 reap_obj(efd2obj);
301 #ifdef SELECT_USES_HEAP
302 PyMem_DEL(rfd2obj);
303 PyMem_DEL(wfd2obj);
304 PyMem_DEL(efd2obj);
305 #endif /* SELECT_USES_HEAP */
306 return ret;
307 }
308
309 #if defined(HAVE_POLL) && !defined(HAVE_BROKEN_POLL)
310 /*
311 * poll() support
312 */
313
314 typedef struct {
315 PyObject_HEAD
316 PyObject *dict;
317 int ufd_uptodate;
318 int ufd_len;
319 struct pollfd *ufds;
320 int poll_running;
321 } pollObject;
322
323 static PyTypeObject poll_Type;
324
325 /* Update the malloc'ed array of pollfds to match the dictionary
326 contained within a pollObject. Return 1 on success, 0 on an error.
327 */
328
329 static int
update_ufd_array(pollObject * self)330 update_ufd_array(pollObject *self)
331 {
332 Py_ssize_t i, pos;
333 PyObject *key, *value;
334 struct pollfd *old_ufds = self->ufds;
335
336 self->ufd_len = PyDict_Size(self->dict);
337 PyMem_RESIZE(self->ufds, struct pollfd, self->ufd_len);
338 if (self->ufds == NULL) {
339 self->ufds = old_ufds;
340 PyErr_NoMemory();
341 return 0;
342 }
343
344 i = pos = 0;
345 while (PyDict_Next(self->dict, &pos, &key, &value)) {
346 assert(i < self->ufd_len);
347 /* Never overflow */
348 self->ufds[i].fd = (int)PyInt_AsLong(key);
349 self->ufds[i].events = (short)(unsigned short)PyInt_AsLong(value);
350 i++;
351 }
352 assert(i == self->ufd_len);
353 self->ufd_uptodate = 1;
354 return 1;
355 }
356
357 static int
ushort_converter(PyObject * obj,void * ptr)358 ushort_converter(PyObject *obj, void *ptr)
359 {
360 unsigned long uval;
361
362 uval = PyLong_AsUnsignedLong(obj);
363 if (uval == (unsigned long)-1 && PyErr_Occurred())
364 return 0;
365 if (uval > USHRT_MAX) {
366 PyErr_SetString(PyExc_OverflowError,
367 "Python int too large for C unsigned short");
368 return 0;
369 }
370
371 *(unsigned short *)ptr = Py_SAFE_DOWNCAST(uval, unsigned long, unsigned short);
372 return 1;
373 }
374
375 PyDoc_STRVAR(poll_register_doc,
376 "register(fd [, eventmask] ) -> None\n\n\
377 Register a file descriptor with the polling object.\n\
378 fd -- either an integer, or an object with a fileno() method returning an\n\
379 int.\n\
380 events -- an optional bitmask describing the type of events to check for");
381
382 static PyObject *
poll_register(pollObject * self,PyObject * args)383 poll_register(pollObject *self, PyObject *args)
384 {
385 PyObject *o, *key, *value;
386 int fd;
387 unsigned short events = POLLIN | POLLPRI | POLLOUT;
388 int err;
389
390 if (!PyArg_ParseTuple(args, "O|O&:register", &o, ushort_converter, &events))
391 return NULL;
392
393 fd = PyObject_AsFileDescriptor(o);
394 if (fd == -1) return NULL;
395
396 /* Add entry to the internal dictionary: the key is the
397 file descriptor, and the value is the event mask. */
398 key = PyInt_FromLong(fd);
399 if (key == NULL)
400 return NULL;
401 value = PyInt_FromLong(events);
402 if (value == NULL) {
403 Py_DECREF(key);
404 return NULL;
405 }
406 err = PyDict_SetItem(self->dict, key, value);
407 Py_DECREF(key);
408 Py_DECREF(value);
409 if (err < 0)
410 return NULL;
411
412 self->ufd_uptodate = 0;
413
414 Py_INCREF(Py_None);
415 return Py_None;
416 }
417
418 PyDoc_STRVAR(poll_modify_doc,
419 "modify(fd, eventmask) -> None\n\n\
420 Modify an already registered file descriptor.\n\
421 fd -- either an integer, or an object with a fileno() method returning an\n\
422 int.\n\
423 events -- an optional bitmask describing the type of events to check for");
424
425 static PyObject *
poll_modify(pollObject * self,PyObject * args)426 poll_modify(pollObject *self, PyObject *args)
427 {
428 PyObject *o, *key, *value;
429 int fd;
430 unsigned short events;
431 int err;
432
433 if (!PyArg_ParseTuple(args, "OO&:modify", &o, ushort_converter, &events))
434 return NULL;
435
436 fd = PyObject_AsFileDescriptor(o);
437 if (fd == -1) return NULL;
438
439 /* Modify registered fd */
440 key = PyInt_FromLong(fd);
441 if (key == NULL)
442 return NULL;
443 if (PyDict_GetItem(self->dict, key) == NULL) {
444 errno = ENOENT;
445 PyErr_SetFromErrno(PyExc_IOError);
446 return NULL;
447 }
448 value = PyInt_FromLong(events);
449 if (value == NULL) {
450 Py_DECREF(key);
451 return NULL;
452 }
453 err = PyDict_SetItem(self->dict, key, value);
454 Py_DECREF(key);
455 Py_DECREF(value);
456 if (err < 0)
457 return NULL;
458
459 self->ufd_uptodate = 0;
460
461 Py_INCREF(Py_None);
462 return Py_None;
463 }
464
465
466 PyDoc_STRVAR(poll_unregister_doc,
467 "unregister(fd) -> None\n\n\
468 Remove a file descriptor being tracked by the polling object.");
469
470 static PyObject *
poll_unregister(pollObject * self,PyObject * o)471 poll_unregister(pollObject *self, PyObject *o)
472 {
473 PyObject *key;
474 int fd;
475
476 fd = PyObject_AsFileDescriptor( o );
477 if (fd == -1)
478 return NULL;
479
480 /* Check whether the fd is already in the array */
481 key = PyInt_FromLong(fd);
482 if (key == NULL)
483 return NULL;
484
485 if (PyDict_DelItem(self->dict, key) == -1) {
486 Py_DECREF(key);
487 /* This will simply raise the KeyError set by PyDict_DelItem
488 if the file descriptor isn't registered. */
489 return NULL;
490 }
491
492 Py_DECREF(key);
493 self->ufd_uptodate = 0;
494
495 Py_INCREF(Py_None);
496 return Py_None;
497 }
498
499 PyDoc_STRVAR(poll_poll_doc,
500 "poll( [timeout] ) -> list of (fd, event) 2-tuples\n\n\
501 Polls the set of registered file descriptors, returning a list containing \n\
502 any descriptors that have events or errors to report.");
503
504 static PyObject *
poll_poll(pollObject * self,PyObject * args)505 poll_poll(pollObject *self, PyObject *args)
506 {
507 PyObject *result_list = NULL, *tout = NULL;
508 int timeout = 0, poll_result, i, j;
509 PyObject *value = NULL, *num = NULL;
510
511 if (!PyArg_UnpackTuple(args, "poll", 0, 1, &tout)) {
512 return NULL;
513 }
514
515 /* Check values for timeout */
516 if (tout == NULL || tout == Py_None)
517 timeout = -1;
518 else if (!PyNumber_Check(tout)) {
519 PyErr_SetString(PyExc_TypeError,
520 "timeout must be an integer or None");
521 return NULL;
522 }
523 else {
524 tout = PyNumber_Int(tout);
525 if (!tout)
526 return NULL;
527 timeout = _PyInt_AsInt(tout);
528 Py_DECREF(tout);
529 if (timeout == -1 && PyErr_Occurred())
530 return NULL;
531 }
532
533 /* Avoid concurrent poll() invocation, issue 8865 */
534 if (self->poll_running) {
535 PyErr_SetString(PyExc_RuntimeError,
536 "concurrent poll() invocation");
537 return NULL;
538 }
539
540 /* Ensure the ufd array is up to date */
541 if (!self->ufd_uptodate)
542 if (update_ufd_array(self) == 0)
543 return NULL;
544
545 self->poll_running = 1;
546
547 /* call poll() */
548 Py_BEGIN_ALLOW_THREADS
549 poll_result = poll(self->ufds, self->ufd_len, timeout);
550 Py_END_ALLOW_THREADS
551
552 self->poll_running = 0;
553
554 if (poll_result < 0) {
555 PyErr_SetFromErrno(SelectError);
556 return NULL;
557 }
558
559 /* build the result list */
560
561 result_list = PyList_New(poll_result);
562 if (!result_list)
563 return NULL;
564 else {
565 for (i = 0, j = 0; j < poll_result; j++) {
566 /* skip to the next fired descriptor */
567 while (!self->ufds[i].revents) {
568 i++;
569 }
570 /* if we hit a NULL return, set value to NULL
571 and break out of loop; code at end will
572 clean up result_list */
573 value = PyTuple_New(2);
574 if (value == NULL)
575 goto error;
576 num = PyInt_FromLong(self->ufds[i].fd);
577 if (num == NULL) {
578 Py_DECREF(value);
579 goto error;
580 }
581 PyTuple_SET_ITEM(value, 0, num);
582
583 /* The &0xffff is a workaround for AIX. 'revents'
584 is a 16-bit short, and IBM assigned POLLNVAL
585 to be 0x8000, so the conversion to int results
586 in a negative number. See SF bug #923315. */
587 num = PyInt_FromLong(self->ufds[i].revents & 0xffff);
588 if (num == NULL) {
589 Py_DECREF(value);
590 goto error;
591 }
592 PyTuple_SET_ITEM(value, 1, num);
593 if ((PyList_SetItem(result_list, j, value)) == -1) {
594 Py_DECREF(value);
595 goto error;
596 }
597 i++;
598 }
599 }
600 return result_list;
601
602 error:
603 Py_DECREF(result_list);
604 return NULL;
605 }
606
607 static PyMethodDef poll_methods[] = {
608 {"register", (PyCFunction)poll_register,
609 METH_VARARGS, poll_register_doc},
610 {"modify", (PyCFunction)poll_modify,
611 METH_VARARGS, poll_modify_doc},
612 {"unregister", (PyCFunction)poll_unregister,
613 METH_O, poll_unregister_doc},
614 {"poll", (PyCFunction)poll_poll,
615 METH_VARARGS, poll_poll_doc},
616 {NULL, NULL} /* sentinel */
617 };
618
619 static pollObject *
newPollObject(void)620 newPollObject(void)
621 {
622 pollObject *self;
623 self = PyObject_New(pollObject, &poll_Type);
624 if (self == NULL)
625 return NULL;
626 /* ufd_uptodate is a Boolean, denoting whether the
627 array pointed to by ufds matches the contents of the dictionary. */
628 self->ufd_uptodate = 0;
629 self->ufds = NULL;
630 self->poll_running = 0;
631 self->dict = PyDict_New();
632 if (self->dict == NULL) {
633 Py_DECREF(self);
634 return NULL;
635 }
636 return self;
637 }
638
639 static void
poll_dealloc(pollObject * self)640 poll_dealloc(pollObject *self)
641 {
642 if (self->ufds != NULL)
643 PyMem_DEL(self->ufds);
644 Py_XDECREF(self->dict);
645 PyObject_Del(self);
646 }
647
648 static PyObject *
poll_getattr(pollObject * self,char * name)649 poll_getattr(pollObject *self, char *name)
650 {
651 return Py_FindMethod(poll_methods, (PyObject *)self, name);
652 }
653
654 static PyTypeObject poll_Type = {
655 /* The ob_type field must be initialized in the module init function
656 * to be portable to Windows without using C++. */
657 PyVarObject_HEAD_INIT(NULL, 0)
658 "select.poll", /*tp_name*/
659 sizeof(pollObject), /*tp_basicsize*/
660 0, /*tp_itemsize*/
661 /* methods */
662 (destructor)poll_dealloc, /*tp_dealloc*/
663 0, /*tp_print*/
664 (getattrfunc)poll_getattr, /*tp_getattr*/
665 0, /*tp_setattr*/
666 0, /*tp_compare*/
667 0, /*tp_repr*/
668 0, /*tp_as_number*/
669 0, /*tp_as_sequence*/
670 0, /*tp_as_mapping*/
671 0, /*tp_hash*/
672 };
673
674 PyDoc_STRVAR(poll_doc,
675 "Returns a polling object, which supports registering and\n\
676 unregistering file descriptors, and then polling them for I/O events.");
677
678 static PyObject *
select_poll(PyObject * self,PyObject * unused)679 select_poll(PyObject *self, PyObject *unused)
680 {
681 return (PyObject *)newPollObject();
682 }
683
684 #ifdef __APPLE__
685 /*
686 * On some systems poll() sets errno on invalid file descriptors. We test
687 * for this at runtime because this bug may be fixed or introduced between
688 * OS releases.
689 */
select_have_broken_poll(void)690 static int select_have_broken_poll(void)
691 {
692 int poll_test;
693 int filedes[2];
694
695 struct pollfd poll_struct = { 0, POLLIN|POLLPRI|POLLOUT, 0 };
696
697 /* Create a file descriptor to make invalid */
698 if (pipe(filedes) < 0) {
699 return 1;
700 }
701 poll_struct.fd = filedes[0];
702 close(filedes[0]);
703 close(filedes[1]);
704 poll_test = poll(&poll_struct, 1, 0);
705 if (poll_test < 0) {
706 return 1;
707 } else if (poll_test == 0 && poll_struct.revents != POLLNVAL) {
708 return 1;
709 }
710 return 0;
711 }
712 #endif /* __APPLE__ */
713
714 #endif /* HAVE_POLL */
715
716 #ifdef HAVE_EPOLL
717 /* **************************************************************************
718 * epoll interface for Linux 2.6
719 *
720 * Written by Christian Heimes
721 * Inspired by Twisted's _epoll.pyx and select.poll()
722 */
723
724 #ifdef HAVE_SYS_EPOLL_H
725 #include <sys/epoll.h>
726 #endif
727
728 typedef struct {
729 PyObject_HEAD
730 SOCKET epfd; /* epoll control file descriptor */
731 } pyEpoll_Object;
732
733 static PyTypeObject pyEpoll_Type;
734 #define pyepoll_CHECK(op) (PyObject_TypeCheck((op), &pyEpoll_Type))
735
736 static PyObject *
pyepoll_err_closed(void)737 pyepoll_err_closed(void)
738 {
739 PyErr_SetString(PyExc_ValueError, "I/O operation on closed epoll fd");
740 return NULL;
741 }
742
743 static int
pyepoll_internal_close(pyEpoll_Object * self)744 pyepoll_internal_close(pyEpoll_Object *self)
745 {
746 int save_errno = 0;
747 if (self->epfd >= 0) {
748 int epfd = self->epfd;
749 self->epfd = -1;
750 Py_BEGIN_ALLOW_THREADS
751 if (close(epfd) < 0)
752 save_errno = errno;
753 Py_END_ALLOW_THREADS
754 }
755 return save_errno;
756 }
757
758 static PyObject *
newPyEpoll_Object(PyTypeObject * type,int sizehint,SOCKET fd)759 newPyEpoll_Object(PyTypeObject *type, int sizehint, SOCKET fd)
760 {
761 pyEpoll_Object *self;
762
763 if (sizehint == -1) {
764 sizehint = FD_SETSIZE-1;
765 }
766 else if (sizehint < 1) {
767 PyErr_Format(PyExc_ValueError,
768 "sizehint must be greater zero, got %d",
769 sizehint);
770 return NULL;
771 }
772
773 assert(type != NULL && type->tp_alloc != NULL);
774 self = (pyEpoll_Object *) type->tp_alloc(type, 0);
775 if (self == NULL)
776 return NULL;
777
778 if (fd == -1) {
779 Py_BEGIN_ALLOW_THREADS
780 self->epfd = epoll_create(sizehint);
781 Py_END_ALLOW_THREADS
782 }
783 else {
784 self->epfd = fd;
785 }
786 if (self->epfd < 0) {
787 Py_DECREF(self);
788 PyErr_SetFromErrno(PyExc_IOError);
789 return NULL;
790 }
791 return (PyObject *)self;
792 }
793
794
795 static PyObject *
pyepoll_new(PyTypeObject * type,PyObject * args,PyObject * kwds)796 pyepoll_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
797 {
798 int sizehint = -1;
799 static char *kwlist[] = {"sizehint", NULL};
800
801 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|i:epoll", kwlist,
802 &sizehint))
803 return NULL;
804
805 return newPyEpoll_Object(type, sizehint, -1);
806 }
807
808
809 static void
pyepoll_dealloc(pyEpoll_Object * self)810 pyepoll_dealloc(pyEpoll_Object *self)
811 {
812 (void)pyepoll_internal_close(self);
813 Py_TYPE(self)->tp_free(self);
814 }
815
816 static PyObject*
pyepoll_close(pyEpoll_Object * self)817 pyepoll_close(pyEpoll_Object *self)
818 {
819 errno = pyepoll_internal_close(self);
820 if (errno < 0) {
821 PyErr_SetFromErrno(PyExc_IOError);
822 return NULL;
823 }
824 Py_RETURN_NONE;
825 }
826
827 PyDoc_STRVAR(pyepoll_close_doc,
828 "close() -> None\n\
829 \n\
830 Close the epoll control file descriptor. Further operations on the epoll\n\
831 object will raise an exception.");
832
833 static PyObject*
pyepoll_get_closed(pyEpoll_Object * self)834 pyepoll_get_closed(pyEpoll_Object *self)
835 {
836 if (self->epfd < 0)
837 Py_RETURN_TRUE;
838 else
839 Py_RETURN_FALSE;
840 }
841
842 static PyObject*
pyepoll_fileno(pyEpoll_Object * self)843 pyepoll_fileno(pyEpoll_Object *self)
844 {
845 if (self->epfd < 0)
846 return pyepoll_err_closed();
847 return PyInt_FromLong(self->epfd);
848 }
849
850 PyDoc_STRVAR(pyepoll_fileno_doc,
851 "fileno() -> int\n\
852 \n\
853 Return the epoll control file descriptor.");
854
855 static PyObject*
pyepoll_fromfd(PyObject * cls,PyObject * args)856 pyepoll_fromfd(PyObject *cls, PyObject *args)
857 {
858 SOCKET fd;
859
860 if (!PyArg_ParseTuple(args, "i:fromfd", &fd))
861 return NULL;
862
863 return newPyEpoll_Object((PyTypeObject*)cls, -1, fd);
864 }
865
866 PyDoc_STRVAR(pyepoll_fromfd_doc,
867 "fromfd(fd) -> epoll\n\
868 \n\
869 Create an epoll object from a given control fd.");
870
871 static PyObject *
pyepoll_internal_ctl(int epfd,int op,PyObject * pfd,unsigned int events)872 pyepoll_internal_ctl(int epfd, int op, PyObject *pfd, unsigned int events)
873 {
874 struct epoll_event ev;
875 int result;
876 int fd;
877
878 if (epfd < 0)
879 return pyepoll_err_closed();
880
881 fd = PyObject_AsFileDescriptor(pfd);
882 if (fd == -1) {
883 return NULL;
884 }
885
886 switch(op) {
887 case EPOLL_CTL_ADD:
888 case EPOLL_CTL_MOD:
889 ev.events = events;
890 ev.data.fd = fd;
891 Py_BEGIN_ALLOW_THREADS
892 result = epoll_ctl(epfd, op, fd, &ev);
893 Py_END_ALLOW_THREADS
894 break;
895 case EPOLL_CTL_DEL:
896 /* In kernel versions before 2.6.9, the EPOLL_CTL_DEL
897 * operation required a non-NULL pointer in event, even
898 * though this argument is ignored. */
899 Py_BEGIN_ALLOW_THREADS
900 result = epoll_ctl(epfd, op, fd, &ev);
901 if (errno == EBADF) {
902 /* fd already closed */
903 result = 0;
904 errno = 0;
905 }
906 Py_END_ALLOW_THREADS
907 break;
908 default:
909 result = -1;
910 errno = EINVAL;
911 }
912
913 if (result < 0) {
914 PyErr_SetFromErrno(PyExc_IOError);
915 return NULL;
916 }
917 Py_RETURN_NONE;
918 }
919
920 static PyObject *
pyepoll_register(pyEpoll_Object * self,PyObject * args,PyObject * kwds)921 pyepoll_register(pyEpoll_Object *self, PyObject *args, PyObject *kwds)
922 {
923 PyObject *pfd;
924 unsigned int events = EPOLLIN | EPOLLOUT | EPOLLPRI;
925 static char *kwlist[] = {"fd", "eventmask", NULL};
926
927 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|I:register", kwlist,
928 &pfd, &events)) {
929 return NULL;
930 }
931
932 return pyepoll_internal_ctl(self->epfd, EPOLL_CTL_ADD, pfd, events);
933 }
934
935 PyDoc_STRVAR(pyepoll_register_doc,
936 "register(fd[, eventmask]) -> None\n\
937 \n\
938 Registers a new fd or raises an IOError if the fd is already registered.\n\
939 fd is the target file descriptor of the operation.\n\
940 events is a bit set composed of the various EPOLL constants; the default\n\
941 is EPOLL_IN | EPOLL_OUT | EPOLL_PRI.\n\
942 \n\
943 The epoll interface supports all file descriptors that support poll.");
944
945 static PyObject *
pyepoll_modify(pyEpoll_Object * self,PyObject * args,PyObject * kwds)946 pyepoll_modify(pyEpoll_Object *self, PyObject *args, PyObject *kwds)
947 {
948 PyObject *pfd;
949 unsigned int events;
950 static char *kwlist[] = {"fd", "eventmask", NULL};
951
952 if (!PyArg_ParseTupleAndKeywords(args, kwds, "OI:modify", kwlist,
953 &pfd, &events)) {
954 return NULL;
955 }
956
957 return pyepoll_internal_ctl(self->epfd, EPOLL_CTL_MOD, pfd, events);
958 }
959
960 PyDoc_STRVAR(pyepoll_modify_doc,
961 "modify(fd, eventmask) -> None\n\
962 \n\
963 fd is the target file descriptor of the operation\n\
964 events is a bit set composed of the various EPOLL constants");
965
966 static PyObject *
pyepoll_unregister(pyEpoll_Object * self,PyObject * args,PyObject * kwds)967 pyepoll_unregister(pyEpoll_Object *self, PyObject *args, PyObject *kwds)
968 {
969 PyObject *pfd;
970 static char *kwlist[] = {"fd", NULL};
971
972 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:unregister", kwlist,
973 &pfd)) {
974 return NULL;
975 }
976
977 return pyepoll_internal_ctl(self->epfd, EPOLL_CTL_DEL, pfd, 0);
978 }
979
980 PyDoc_STRVAR(pyepoll_unregister_doc,
981 "unregister(fd) -> None\n\
982 \n\
983 fd is the target file descriptor of the operation.");
984
985 static PyObject *
pyepoll_poll(pyEpoll_Object * self,PyObject * args,PyObject * kwds)986 pyepoll_poll(pyEpoll_Object *self, PyObject *args, PyObject *kwds)
987 {
988 double dtimeout = -1.;
989 int timeout;
990 int maxevents = -1;
991 int nfds, i;
992 PyObject *elist = NULL, *etuple = NULL;
993 struct epoll_event *evs = NULL;
994 static char *kwlist[] = {"timeout", "maxevents", NULL};
995
996 if (self->epfd < 0)
997 return pyepoll_err_closed();
998
999 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|di:poll", kwlist,
1000 &dtimeout, &maxevents)) {
1001 return NULL;
1002 }
1003
1004 if (dtimeout < 0) {
1005 timeout = -1;
1006 }
1007 else if (dtimeout * 1000.0 > INT_MAX) {
1008 PyErr_SetString(PyExc_OverflowError,
1009 "timeout is too large");
1010 return NULL;
1011 }
1012 else {
1013 timeout = (int)(dtimeout * 1000.0);
1014 }
1015
1016 if (maxevents == -1) {
1017 maxevents = FD_SETSIZE-1;
1018 }
1019 else if (maxevents < 1) {
1020 PyErr_Format(PyExc_ValueError,
1021 "maxevents must be greater than 0, got %d",
1022 maxevents);
1023 return NULL;
1024 }
1025
1026 evs = PyMem_New(struct epoll_event, maxevents);
1027 if (evs == NULL) {
1028 Py_DECREF(self);
1029 PyErr_NoMemory();
1030 return NULL;
1031 }
1032
1033 Py_BEGIN_ALLOW_THREADS
1034 nfds = epoll_wait(self->epfd, evs, maxevents, timeout);
1035 Py_END_ALLOW_THREADS
1036 if (nfds < 0) {
1037 PyErr_SetFromErrno(PyExc_IOError);
1038 goto error;
1039 }
1040
1041 elist = PyList_New(nfds);
1042 if (elist == NULL) {
1043 goto error;
1044 }
1045
1046 for (i = 0; i < nfds; i++) {
1047 etuple = Py_BuildValue("iI", evs[i].data.fd, evs[i].events);
1048 if (etuple == NULL) {
1049 Py_CLEAR(elist);
1050 goto error;
1051 }
1052 PyList_SET_ITEM(elist, i, etuple);
1053 }
1054
1055 error:
1056 PyMem_Free(evs);
1057 return elist;
1058 }
1059
1060 PyDoc_STRVAR(pyepoll_poll_doc,
1061 "poll([timeout=-1[, maxevents=-1]]) -> [(fd, events), (...)]\n\
1062 \n\
1063 Wait for events on the epoll file descriptor for a maximum time of timeout\n\
1064 in seconds (as float). -1 makes poll wait indefinitely.\n\
1065 Up to maxevents are returned to the caller.");
1066
1067 static PyMethodDef pyepoll_methods[] = {
1068 {"fromfd", (PyCFunction)pyepoll_fromfd,
1069 METH_VARARGS | METH_CLASS, pyepoll_fromfd_doc},
1070 {"close", (PyCFunction)pyepoll_close, METH_NOARGS,
1071 pyepoll_close_doc},
1072 {"fileno", (PyCFunction)pyepoll_fileno, METH_NOARGS,
1073 pyepoll_fileno_doc},
1074 {"modify", (PyCFunction)pyepoll_modify,
1075 METH_VARARGS | METH_KEYWORDS, pyepoll_modify_doc},
1076 {"register", (PyCFunction)pyepoll_register,
1077 METH_VARARGS | METH_KEYWORDS, pyepoll_register_doc},
1078 {"unregister", (PyCFunction)pyepoll_unregister,
1079 METH_VARARGS | METH_KEYWORDS, pyepoll_unregister_doc},
1080 {"poll", (PyCFunction)pyepoll_poll,
1081 METH_VARARGS | METH_KEYWORDS, pyepoll_poll_doc},
1082 {NULL, NULL},
1083 };
1084
1085 static PyGetSetDef pyepoll_getsetlist[] = {
1086 {"closed", (getter)pyepoll_get_closed, NULL,
1087 "True if the epoll handler is closed"},
1088 {0},
1089 };
1090
1091 PyDoc_STRVAR(pyepoll_doc,
1092 "select.epoll([sizehint=-1])\n\
1093 \n\
1094 Returns an epolling object\n\
1095 \n\
1096 sizehint must be a positive integer or -1 for the default size. The\n\
1097 sizehint is used to optimize internal data structures. It doesn't limit\n\
1098 the maximum number of monitored events.");
1099
1100 static PyTypeObject pyEpoll_Type = {
1101 PyVarObject_HEAD_INIT(NULL, 0)
1102 "select.epoll", /* tp_name */
1103 sizeof(pyEpoll_Object), /* tp_basicsize */
1104 0, /* tp_itemsize */
1105 (destructor)pyepoll_dealloc, /* tp_dealloc */
1106 0, /* tp_print */
1107 0, /* tp_getattr */
1108 0, /* tp_setattr */
1109 0, /* tp_compare */
1110 0, /* tp_repr */
1111 0, /* tp_as_number */
1112 0, /* tp_as_sequence */
1113 0, /* tp_as_mapping */
1114 0, /* tp_hash */
1115 0, /* tp_call */
1116 0, /* tp_str */
1117 PyObject_GenericGetAttr, /* tp_getattro */
1118 0, /* tp_setattro */
1119 0, /* tp_as_buffer */
1120 Py_TPFLAGS_DEFAULT, /* tp_flags */
1121 pyepoll_doc, /* tp_doc */
1122 0, /* tp_traverse */
1123 0, /* tp_clear */
1124 0, /* tp_richcompare */
1125 0, /* tp_weaklistoffset */
1126 0, /* tp_iter */
1127 0, /* tp_iternext */
1128 pyepoll_methods, /* tp_methods */
1129 0, /* tp_members */
1130 pyepoll_getsetlist, /* tp_getset */
1131 0, /* tp_base */
1132 0, /* tp_dict */
1133 0, /* tp_descr_get */
1134 0, /* tp_descr_set */
1135 0, /* tp_dictoffset */
1136 0, /* tp_init */
1137 0, /* tp_alloc */
1138 pyepoll_new, /* tp_new */
1139 0, /* tp_free */
1140 };
1141
1142 #endif /* HAVE_EPOLL */
1143
1144 #ifdef HAVE_KQUEUE
1145 /* **************************************************************************
1146 * kqueue interface for BSD
1147 *
1148 * Copyright (c) 2000 Doug White, 2006 James Knight, 2007 Christian Heimes
1149 * All rights reserved.
1150 *
1151 * Redistribution and use in source and binary forms, with or without
1152 * modification, are permitted provided that the following conditions
1153 * are met:
1154 * 1. Redistributions of source code must retain the above copyright
1155 * notice, this list of conditions and the following disclaimer.
1156 * 2. Redistributions in binary form must reproduce the above copyright
1157 * notice, this list of conditions and the following disclaimer in the
1158 * documentation and/or other materials provided with the distribution.
1159 *
1160 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
1161 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1162 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1163 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
1164 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1165 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1166 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1167 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1168 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1169 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1170 * SUCH DAMAGE.
1171 */
1172
1173 #ifdef HAVE_SYS_EVENT_H
1174 #include <sys/event.h>
1175 #endif
1176
1177 PyDoc_STRVAR(kqueue_event_doc,
1178 "kevent(ident, filter=KQ_FILTER_READ, flags=KQ_EV_ADD, fflags=0, data=0, udata=0)\n\
1179 \n\
1180 This object is the equivalent of the struct kevent for the C API.\n\
1181 \n\
1182 See the kqueue manpage for more detailed information about the meaning\n\
1183 of the arguments.\n\
1184 \n\
1185 One minor note: while you might hope that udata could store a\n\
1186 reference to a python object, it cannot, because it is impossible to\n\
1187 keep a proper reference count of the object once it's passed into the\n\
1188 kernel. Therefore, I have restricted it to only storing an integer. I\n\
1189 recommend ignoring it and simply using the 'ident' field to key off\n\
1190 of. You could also set up a dictionary on the python side to store a\n\
1191 udata->object mapping.");
1192
1193 typedef struct {
1194 PyObject_HEAD
1195 struct kevent e;
1196 } kqueue_event_Object;
1197
1198 static PyTypeObject kqueue_event_Type;
1199
1200 #define kqueue_event_Check(op) (PyObject_TypeCheck((op), &kqueue_event_Type))
1201
1202 typedef struct {
1203 PyObject_HEAD
1204 SOCKET kqfd; /* kqueue control fd */
1205 } kqueue_queue_Object;
1206
1207 static PyTypeObject kqueue_queue_Type;
1208
1209 #define kqueue_queue_Check(op) (PyObject_TypeCheck((op), &kqueue_queue_Type))
1210
1211 #if (SIZEOF_UINTPTR_T != SIZEOF_VOID_P)
1212 # error uintptr_t does not match void *!
1213 #elif (SIZEOF_UINTPTR_T == SIZEOF_LONG_LONG)
1214 # define T_UINTPTRT T_ULONGLONG
1215 # define T_INTPTRT T_LONGLONG
1216 # define PyLong_AsUintptr_t PyLong_AsUnsignedLongLong
1217 # define UINTPTRT_FMT_UNIT "K"
1218 # define INTPTRT_FMT_UNIT "L"
1219 #elif (SIZEOF_UINTPTR_T == SIZEOF_LONG)
1220 # define T_UINTPTRT T_ULONG
1221 # define T_INTPTRT T_LONG
1222 # define PyLong_AsUintptr_t PyLong_AsUnsignedLong
1223 # define UINTPTRT_FMT_UNIT "k"
1224 # define INTPTRT_FMT_UNIT "l"
1225 #elif (SIZEOF_UINTPTR_T == SIZEOF_INT)
1226 # define T_UINTPTRT T_UINT
1227 # define T_INTPTRT T_INT
1228 # define PyLong_AsUintptr_t PyLong_AsUnsignedLong
1229 # define UINTPTRT_FMT_UNIT "I"
1230 # define INTPTRT_FMT_UNIT "i"
1231 #else
1232 # error uintptr_t does not match int, long, or long long!
1233 #endif
1234
1235 /*
1236 * kevent is not standard and its members vary across BSDs.
1237 */
1238 #if !defined(__OpenBSD__)
1239 # define IDENT_TYPE T_UINTPTRT
1240 # define IDENT_CAST Py_intptr_t
1241 # define DATA_TYPE T_INTPTRT
1242 # define DATA_FMT_UNIT INTPTRT_FMT_UNIT
1243 # define IDENT_AsType PyLong_AsUintptr_t
1244 #else
1245 # define IDENT_TYPE T_UINT
1246 # define IDENT_CAST int
1247 # define DATA_TYPE T_INT
1248 # define DATA_FMT_UNIT "i"
1249 # define IDENT_AsType PyLong_AsUnsignedLong
1250 #endif
1251
1252 /* Unfortunately, we can't store python objects in udata, because
1253 * kevents in the kernel can be removed without warning, which would
1254 * forever lose the refcount on the object stored with it.
1255 */
1256
1257 #define KQ_OFF(x) offsetof(kqueue_event_Object, x)
1258 static struct PyMemberDef kqueue_event_members[] = {
1259 {"ident", IDENT_TYPE, KQ_OFF(e.ident)},
1260 {"filter", T_SHORT, KQ_OFF(e.filter)},
1261 {"flags", T_USHORT, KQ_OFF(e.flags)},
1262 {"fflags", T_UINT, KQ_OFF(e.fflags)},
1263 {"data", DATA_TYPE, KQ_OFF(e.data)},
1264 {"udata", T_UINTPTRT, KQ_OFF(e.udata)},
1265 {NULL} /* Sentinel */
1266 };
1267 #undef KQ_OFF
1268
1269 static PyObject *
1270
kqueue_event_repr(kqueue_event_Object * s)1271 kqueue_event_repr(kqueue_event_Object *s)
1272 {
1273 char buf[1024];
1274 PyOS_snprintf(
1275 buf, sizeof(buf),
1276 "<select.kevent ident=%zu filter=%d flags=0x%x fflags=0x%x "
1277 "data=0x%zd udata=%p>",
1278 (size_t)(s->e.ident), s->e.filter, s->e.flags,
1279 s->e.fflags, (Py_ssize_t)(s->e.data), s->e.udata);
1280 return PyString_FromString(buf);
1281 }
1282
1283 static int
kqueue_event_init(kqueue_event_Object * self,PyObject * args,PyObject * kwds)1284 kqueue_event_init(kqueue_event_Object *self, PyObject *args, PyObject *kwds)
1285 {
1286 PyObject *pfd;
1287 static char *kwlist[] = {"ident", "filter", "flags", "fflags",
1288 "data", "udata", NULL};
1289 static char *fmt = "O|hHI" DATA_FMT_UNIT UINTPTRT_FMT_UNIT ":kevent";
1290
1291 EV_SET(&(self->e), 0, EVFILT_READ, EV_ADD, 0, 0, 0); /* defaults */
1292
1293 if (!PyArg_ParseTupleAndKeywords(args, kwds, fmt, kwlist,
1294 &pfd, &(self->e.filter), &(self->e.flags),
1295 &(self->e.fflags), &(self->e.data), &(self->e.udata))) {
1296 return -1;
1297 }
1298
1299 if (PyLong_Check(pfd)
1300 #if IDENT_TYPE == T_UINT
1301 && PyLong_AsUnsignedLong(pfd) <= UINT_MAX
1302 #endif
1303 ) {
1304 self->e.ident = IDENT_AsType(pfd);
1305 }
1306 else {
1307 self->e.ident = PyObject_AsFileDescriptor(pfd);
1308 }
1309 if (PyErr_Occurred()) {
1310 return -1;
1311 }
1312 return 0;
1313 }
1314
1315 static PyObject *
kqueue_event_richcompare(kqueue_event_Object * s,kqueue_event_Object * o,int op)1316 kqueue_event_richcompare(kqueue_event_Object *s, kqueue_event_Object *o,
1317 int op)
1318 {
1319 Py_intptr_t result = 0;
1320
1321 if (!kqueue_event_Check(o)) {
1322 if (op == Py_EQ || op == Py_NE) {
1323 PyObject *res = op == Py_EQ ? Py_False : Py_True;
1324 Py_INCREF(res);
1325 return res;
1326 }
1327 PyErr_Format(PyExc_TypeError,
1328 "can't compare %.200s to %.200s",
1329 Py_TYPE(s)->tp_name, Py_TYPE(o)->tp_name);
1330 return NULL;
1331 }
1332 if (((result = (IDENT_CAST)(s->e.ident - o->e.ident)) == 0) &&
1333 ((result = s->e.filter - o->e.filter) == 0) &&
1334 ((result = s->e.flags - o->e.flags) == 0) &&
1335 ((result = (int)(s->e.fflags - o->e.fflags)) == 0) &&
1336 ((result = s->e.data - o->e.data) == 0) &&
1337 ((result = s->e.udata - o->e.udata) == 0)
1338 ) {
1339 result = 0;
1340 }
1341
1342 switch (op) {
1343 case Py_EQ:
1344 result = (result == 0);
1345 break;
1346 case Py_NE:
1347 result = (result != 0);
1348 break;
1349 case Py_LE:
1350 result = (result <= 0);
1351 break;
1352 case Py_GE:
1353 result = (result >= 0);
1354 break;
1355 case Py_LT:
1356 result = (result < 0);
1357 break;
1358 case Py_GT:
1359 result = (result > 0);
1360 break;
1361 }
1362 return PyBool_FromLong((long)result);
1363 }
1364
1365 static PyTypeObject kqueue_event_Type = {
1366 PyVarObject_HEAD_INIT(NULL, 0)
1367 "select.kevent", /* tp_name */
1368 sizeof(kqueue_event_Object), /* tp_basicsize */
1369 0, /* tp_itemsize */
1370 0, /* tp_dealloc */
1371 0, /* tp_print */
1372 0, /* tp_getattr */
1373 0, /* tp_setattr */
1374 0, /* tp_compare */
1375 (reprfunc)kqueue_event_repr, /* tp_repr */
1376 0, /* tp_as_number */
1377 0, /* tp_as_sequence */
1378 0, /* tp_as_mapping */
1379 0, /* tp_hash */
1380 0, /* tp_call */
1381 0, /* tp_str */
1382 0, /* tp_getattro */
1383 0, /* tp_setattro */
1384 0, /* tp_as_buffer */
1385 Py_TPFLAGS_DEFAULT, /* tp_flags */
1386 kqueue_event_doc, /* tp_doc */
1387 0, /* tp_traverse */
1388 0, /* tp_clear */
1389 (richcmpfunc)kqueue_event_richcompare, /* tp_richcompare */
1390 0, /* tp_weaklistoffset */
1391 0, /* tp_iter */
1392 0, /* tp_iternext */
1393 0, /* tp_methods */
1394 kqueue_event_members, /* tp_members */
1395 0, /* tp_getset */
1396 0, /* tp_base */
1397 0, /* tp_dict */
1398 0, /* tp_descr_get */
1399 0, /* tp_descr_set */
1400 0, /* tp_dictoffset */
1401 (initproc)kqueue_event_init, /* tp_init */
1402 0, /* tp_alloc */
1403 0, /* tp_new */
1404 0, /* tp_free */
1405 };
1406
1407 static PyObject *
kqueue_queue_err_closed(void)1408 kqueue_queue_err_closed(void)
1409 {
1410 PyErr_SetString(PyExc_ValueError, "I/O operation on closed kqueue fd");
1411 return NULL;
1412 }
1413
1414 static int
kqueue_queue_internal_close(kqueue_queue_Object * self)1415 kqueue_queue_internal_close(kqueue_queue_Object *self)
1416 {
1417 int save_errno = 0;
1418 if (self->kqfd >= 0) {
1419 int kqfd = self->kqfd;
1420 self->kqfd = -1;
1421 Py_BEGIN_ALLOW_THREADS
1422 if (close(kqfd) < 0)
1423 save_errno = errno;
1424 Py_END_ALLOW_THREADS
1425 }
1426 return save_errno;
1427 }
1428
1429 static PyObject *
newKqueue_Object(PyTypeObject * type,SOCKET fd)1430 newKqueue_Object(PyTypeObject *type, SOCKET fd)
1431 {
1432 kqueue_queue_Object *self;
1433 assert(type != NULL && type->tp_alloc != NULL);
1434 self = (kqueue_queue_Object *) type->tp_alloc(type, 0);
1435 if (self == NULL) {
1436 return NULL;
1437 }
1438
1439 if (fd == -1) {
1440 Py_BEGIN_ALLOW_THREADS
1441 self->kqfd = kqueue();
1442 Py_END_ALLOW_THREADS
1443 }
1444 else {
1445 self->kqfd = fd;
1446 }
1447 if (self->kqfd < 0) {
1448 Py_DECREF(self);
1449 PyErr_SetFromErrno(PyExc_IOError);
1450 return NULL;
1451 }
1452 return (PyObject *)self;
1453 }
1454
1455 static PyObject *
kqueue_queue_new(PyTypeObject * type,PyObject * args,PyObject * kwds)1456 kqueue_queue_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1457 {
1458
1459 if ((args != NULL && PyObject_Size(args)) ||
1460 (kwds != NULL && PyObject_Size(kwds))) {
1461 PyErr_SetString(PyExc_ValueError,
1462 "select.kqueue doesn't accept arguments");
1463 return NULL;
1464 }
1465
1466 return newKqueue_Object(type, -1);
1467 }
1468
1469 static void
kqueue_queue_dealloc(kqueue_queue_Object * self)1470 kqueue_queue_dealloc(kqueue_queue_Object *self)
1471 {
1472 kqueue_queue_internal_close(self);
1473 Py_TYPE(self)->tp_free(self);
1474 }
1475
1476 static PyObject*
kqueue_queue_close(kqueue_queue_Object * self)1477 kqueue_queue_close(kqueue_queue_Object *self)
1478 {
1479 errno = kqueue_queue_internal_close(self);
1480 if (errno < 0) {
1481 PyErr_SetFromErrno(PyExc_IOError);
1482 return NULL;
1483 }
1484 Py_RETURN_NONE;
1485 }
1486
1487 PyDoc_STRVAR(kqueue_queue_close_doc,
1488 "close() -> None\n\
1489 \n\
1490 Close the kqueue control file descriptor. Further operations on the kqueue\n\
1491 object will raise an exception.");
1492
1493 static PyObject*
kqueue_queue_get_closed(kqueue_queue_Object * self)1494 kqueue_queue_get_closed(kqueue_queue_Object *self)
1495 {
1496 if (self->kqfd < 0)
1497 Py_RETURN_TRUE;
1498 else
1499 Py_RETURN_FALSE;
1500 }
1501
1502 static PyObject*
kqueue_queue_fileno(kqueue_queue_Object * self)1503 kqueue_queue_fileno(kqueue_queue_Object *self)
1504 {
1505 if (self->kqfd < 0)
1506 return kqueue_queue_err_closed();
1507 return PyInt_FromLong(self->kqfd);
1508 }
1509
1510 PyDoc_STRVAR(kqueue_queue_fileno_doc,
1511 "fileno() -> int\n\
1512 \n\
1513 Return the kqueue control file descriptor.");
1514
1515 static PyObject*
kqueue_queue_fromfd(PyObject * cls,PyObject * args)1516 kqueue_queue_fromfd(PyObject *cls, PyObject *args)
1517 {
1518 SOCKET fd;
1519
1520 if (!PyArg_ParseTuple(args, "i:fromfd", &fd))
1521 return NULL;
1522
1523 return newKqueue_Object((PyTypeObject*)cls, fd);
1524 }
1525
1526 PyDoc_STRVAR(kqueue_queue_fromfd_doc,
1527 "fromfd(fd) -> kqueue\n\
1528 \n\
1529 Create a kqueue object from a given control fd.");
1530
1531 static PyObject *
kqueue_queue_control(kqueue_queue_Object * self,PyObject * args)1532 kqueue_queue_control(kqueue_queue_Object *self, PyObject *args)
1533 {
1534 int nevents = 0;
1535 int gotevents = 0;
1536 int nchanges = 0;
1537 int i = 0;
1538 PyObject *otimeout = NULL;
1539 PyObject *ch = NULL;
1540 PyObject *it = NULL, *ei = NULL;
1541 PyObject *result = NULL;
1542 struct kevent *evl = NULL;
1543 struct kevent *chl = NULL;
1544 struct timespec timeoutspec;
1545 struct timespec *ptimeoutspec;
1546
1547 if (self->kqfd < 0)
1548 return kqueue_queue_err_closed();
1549
1550 if (!PyArg_ParseTuple(args, "Oi|O:control", &ch, &nevents, &otimeout))
1551 return NULL;
1552
1553 if (nevents < 0) {
1554 PyErr_Format(PyExc_ValueError,
1555 "Length of eventlist must be 0 or positive, got %d",
1556 nevents);
1557 return NULL;
1558 }
1559
1560 if (otimeout == Py_None || otimeout == NULL) {
1561 ptimeoutspec = NULL;
1562 }
1563 else if (PyNumber_Check(otimeout)) {
1564 double timeout;
1565 long seconds;
1566
1567 timeout = PyFloat_AsDouble(otimeout);
1568 if (timeout == -1 && PyErr_Occurred())
1569 return NULL;
1570 if (timeout > (double)LONG_MAX) {
1571 PyErr_SetString(PyExc_OverflowError,
1572 "timeout period too long");
1573 return NULL;
1574 }
1575 if (timeout < 0) {
1576 PyErr_SetString(PyExc_ValueError,
1577 "timeout must be positive or None");
1578 return NULL;
1579 }
1580
1581 seconds = (long)timeout;
1582 timeout = timeout - (double)seconds;
1583 timeoutspec.tv_sec = seconds;
1584 timeoutspec.tv_nsec = (long)(timeout * 1E9);
1585 ptimeoutspec = &timeoutspec;
1586 }
1587 else {
1588 PyErr_Format(PyExc_TypeError,
1589 "timeout argument must be an number "
1590 "or None, got %.200s",
1591 Py_TYPE(otimeout)->tp_name);
1592 return NULL;
1593 }
1594
1595 if (ch != NULL && ch != Py_None) {
1596 it = PyObject_GetIter(ch);
1597 if (it == NULL) {
1598 PyErr_SetString(PyExc_TypeError,
1599 "changelist is not iterable");
1600 return NULL;
1601 }
1602 nchanges = PyObject_Size(ch);
1603 if (nchanges < 0) {
1604 goto error;
1605 }
1606
1607 chl = PyMem_New(struct kevent, nchanges);
1608 if (chl == NULL) {
1609 PyErr_NoMemory();
1610 goto error;
1611 }
1612 i = 0;
1613 while ((ei = PyIter_Next(it)) != NULL) {
1614 if (!kqueue_event_Check(ei)) {
1615 Py_DECREF(ei);
1616 PyErr_SetString(PyExc_TypeError,
1617 "changelist must be an iterable of "
1618 "select.kevent objects");
1619 goto error;
1620 } else {
1621 chl[i++] = ((kqueue_event_Object *)ei)->e;
1622 }
1623 Py_DECREF(ei);
1624 }
1625 }
1626 Py_CLEAR(it);
1627
1628 /* event list */
1629 if (nevents) {
1630 evl = PyMem_New(struct kevent, nevents);
1631 if (evl == NULL) {
1632 PyErr_NoMemory();
1633 goto error;
1634 }
1635 }
1636
1637 Py_BEGIN_ALLOW_THREADS
1638 gotevents = kevent(self->kqfd, chl, nchanges,
1639 evl, nevents, ptimeoutspec);
1640 Py_END_ALLOW_THREADS
1641
1642 if (gotevents == -1) {
1643 PyErr_SetFromErrno(PyExc_OSError);
1644 goto error;
1645 }
1646
1647 result = PyList_New(gotevents);
1648 if (result == NULL) {
1649 goto error;
1650 }
1651
1652 for (i = 0; i < gotevents; i++) {
1653 kqueue_event_Object *ch;
1654
1655 ch = PyObject_New(kqueue_event_Object, &kqueue_event_Type);
1656 if (ch == NULL) {
1657 goto error;
1658 }
1659 ch->e = evl[i];
1660 PyList_SET_ITEM(result, i, (PyObject *)ch);
1661 }
1662 PyMem_Free(chl);
1663 PyMem_Free(evl);
1664 return result;
1665
1666 error:
1667 PyMem_Free(chl);
1668 PyMem_Free(evl);
1669 Py_XDECREF(result);
1670 Py_XDECREF(it);
1671 return NULL;
1672 }
1673
1674 PyDoc_STRVAR(kqueue_queue_control_doc,
1675 "control(changelist, max_events[, timeout=None]) -> eventlist\n\
1676 \n\
1677 Calls the kernel kevent function.\n\
1678 - changelist must be a list of kevent objects describing the changes\n\
1679 to be made to the kernel's watch list or None.\n\
1680 - max_events lets you specify the maximum number of events that the\n\
1681 kernel will return.\n\
1682 - timeout is the maximum time to wait in seconds, or else None,\n\
1683 to wait forever. timeout accepts floats for smaller timeouts, too.");
1684
1685
1686 static PyMethodDef kqueue_queue_methods[] = {
1687 {"fromfd", (PyCFunction)kqueue_queue_fromfd,
1688 METH_VARARGS | METH_CLASS, kqueue_queue_fromfd_doc},
1689 {"close", (PyCFunction)kqueue_queue_close, METH_NOARGS,
1690 kqueue_queue_close_doc},
1691 {"fileno", (PyCFunction)kqueue_queue_fileno, METH_NOARGS,
1692 kqueue_queue_fileno_doc},
1693 {"control", (PyCFunction)kqueue_queue_control,
1694 METH_VARARGS , kqueue_queue_control_doc},
1695 {NULL, NULL},
1696 };
1697
1698 static PyGetSetDef kqueue_queue_getsetlist[] = {
1699 {"closed", (getter)kqueue_queue_get_closed, NULL,
1700 "True if the kqueue handler is closed"},
1701 {0},
1702 };
1703
1704 PyDoc_STRVAR(kqueue_queue_doc,
1705 "Kqueue syscall wrapper.\n\
1706 \n\
1707 For example, to start watching a socket for input:\n\
1708 >>> kq = kqueue()\n\
1709 >>> sock = socket()\n\
1710 >>> sock.connect((host, port))\n\
1711 >>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_ADD)], 0)\n\
1712 \n\
1713 To wait one second for it to become writeable:\n\
1714 >>> kq.control(None, 1, 1000)\n\
1715 \n\
1716 To stop listening:\n\
1717 >>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_DELETE)], 0)");
1718
1719 static PyTypeObject kqueue_queue_Type = {
1720 PyVarObject_HEAD_INIT(NULL, 0)
1721 "select.kqueue", /* tp_name */
1722 sizeof(kqueue_queue_Object), /* tp_basicsize */
1723 0, /* tp_itemsize */
1724 (destructor)kqueue_queue_dealloc, /* tp_dealloc */
1725 0, /* tp_print */
1726 0, /* tp_getattr */
1727 0, /* tp_setattr */
1728 0, /* tp_compare */
1729 0, /* tp_repr */
1730 0, /* tp_as_number */
1731 0, /* tp_as_sequence */
1732 0, /* tp_as_mapping */
1733 0, /* tp_hash */
1734 0, /* tp_call */
1735 0, /* tp_str */
1736 0, /* tp_getattro */
1737 0, /* tp_setattro */
1738 0, /* tp_as_buffer */
1739 Py_TPFLAGS_DEFAULT, /* tp_flags */
1740 kqueue_queue_doc, /* tp_doc */
1741 0, /* tp_traverse */
1742 0, /* tp_clear */
1743 0, /* tp_richcompare */
1744 0, /* tp_weaklistoffset */
1745 0, /* tp_iter */
1746 0, /* tp_iternext */
1747 kqueue_queue_methods, /* tp_methods */
1748 0, /* tp_members */
1749 kqueue_queue_getsetlist, /* tp_getset */
1750 0, /* tp_base */
1751 0, /* tp_dict */
1752 0, /* tp_descr_get */
1753 0, /* tp_descr_set */
1754 0, /* tp_dictoffset */
1755 0, /* tp_init */
1756 0, /* tp_alloc */
1757 kqueue_queue_new, /* tp_new */
1758 0, /* tp_free */
1759 };
1760
1761 #endif /* HAVE_KQUEUE */
1762 /* ************************************************************************ */
1763
1764 PyDoc_STRVAR(select_doc,
1765 "select(rlist, wlist, xlist[, timeout]) -> (rlist, wlist, xlist)\n\
1766 \n\
1767 Wait until one or more file descriptors are ready for some kind of I/O.\n\
1768 The first three arguments are sequences of file descriptors to be waited for:\n\
1769 rlist -- wait until ready for reading\n\
1770 wlist -- wait until ready for writing\n\
1771 xlist -- wait for an ``exceptional condition''\n\
1772 If only one kind of condition is required, pass [] for the other lists.\n\
1773 A file descriptor is either a socket or file object, or a small integer\n\
1774 gotten from a fileno() method call on one of those.\n\
1775 \n\
1776 The optional 4th argument specifies a timeout in seconds; it may be\n\
1777 a floating point number to specify fractions of seconds. If it is absent\n\
1778 or None, the call will never time out.\n\
1779 \n\
1780 The return value is a tuple of three lists corresponding to the first three\n\
1781 arguments; each contains the subset of the corresponding file descriptors\n\
1782 that are ready.\n\
1783 \n\
1784 *** IMPORTANT NOTICE ***\n\
1785 On Windows and OpenVMS, only sockets are supported; on Unix, all file\n\
1786 descriptors can be used.");
1787
1788 static PyMethodDef select_methods[] = {
1789 {"select", select_select, METH_VARARGS, select_doc},
1790 #if defined(HAVE_POLL) && !defined(HAVE_BROKEN_POLL)
1791 {"poll", select_poll, METH_NOARGS, poll_doc},
1792 #endif /* HAVE_POLL */
1793 {0, 0}, /* sentinel */
1794 };
1795
1796 PyDoc_STRVAR(module_doc,
1797 "This module supports asynchronous I/O on multiple file descriptors.\n\
1798 \n\
1799 *** IMPORTANT NOTICE ***\n\
1800 On Windows and OpenVMS, only sockets are supported; on Unix, all file descriptors.");
1801
1802 PyMODINIT_FUNC
initselect(void)1803 initselect(void)
1804 {
1805 PyObject *m;
1806 m = Py_InitModule3("select", select_methods, module_doc);
1807 if (m == NULL)
1808 return;
1809
1810 SelectError = PyErr_NewException("select.error", NULL, NULL);
1811 Py_INCREF(SelectError);
1812 PyModule_AddObject(m, "error", SelectError);
1813
1814 #ifdef PIPE_BUF
1815 #ifdef HAVE_BROKEN_PIPE_BUF
1816 #undef PIPE_BUF
1817 #define PIPE_BUF 512
1818 #endif
1819 PyModule_AddIntConstant(m, "PIPE_BUF", PIPE_BUF);
1820 #endif
1821
1822 #if defined(HAVE_POLL) && !defined(HAVE_BROKEN_POLL)
1823 #ifdef __APPLE__
1824 if (select_have_broken_poll()) {
1825 if (PyObject_DelAttrString(m, "poll") == -1) {
1826 PyErr_Clear();
1827 }
1828 } else {
1829 #else
1830 {
1831 #endif
1832 Py_TYPE(&poll_Type) = &PyType_Type;
1833 PyModule_AddIntConstant(m, "POLLIN", POLLIN);
1834 PyModule_AddIntConstant(m, "POLLPRI", POLLPRI);
1835 PyModule_AddIntConstant(m, "POLLOUT", POLLOUT);
1836 PyModule_AddIntConstant(m, "POLLERR", POLLERR);
1837 PyModule_AddIntConstant(m, "POLLHUP", POLLHUP);
1838 PyModule_AddIntConstant(m, "POLLNVAL", POLLNVAL);
1839
1840 #ifdef POLLRDNORM
1841 PyModule_AddIntConstant(m, "POLLRDNORM", POLLRDNORM);
1842 #endif
1843 #ifdef POLLRDBAND
1844 PyModule_AddIntConstant(m, "POLLRDBAND", POLLRDBAND);
1845 #endif
1846 #ifdef POLLWRNORM
1847 PyModule_AddIntConstant(m, "POLLWRNORM", POLLWRNORM);
1848 #endif
1849 #ifdef POLLWRBAND
1850 PyModule_AddIntConstant(m, "POLLWRBAND", POLLWRBAND);
1851 #endif
1852 #ifdef POLLMSG
1853 PyModule_AddIntConstant(m, "POLLMSG", POLLMSG);
1854 #endif
1855 }
1856 #endif /* HAVE_POLL */
1857
1858 #ifdef HAVE_EPOLL
1859 Py_TYPE(&pyEpoll_Type) = &PyType_Type;
1860 if (PyType_Ready(&pyEpoll_Type) < 0)
1861 return;
1862
1863 Py_INCREF(&pyEpoll_Type);
1864 PyModule_AddObject(m, "epoll", (PyObject *) &pyEpoll_Type);
1865
1866 PyModule_AddIntConstant(m, "EPOLLIN", EPOLLIN);
1867 PyModule_AddIntConstant(m, "EPOLLOUT", EPOLLOUT);
1868 PyModule_AddIntConstant(m, "EPOLLPRI", EPOLLPRI);
1869 PyModule_AddIntConstant(m, "EPOLLERR", EPOLLERR);
1870 PyModule_AddIntConstant(m, "EPOLLHUP", EPOLLHUP);
1871 PyModule_AddIntConstant(m, "EPOLLET", EPOLLET);
1872 #ifdef EPOLLONESHOT
1873 /* Kernel 2.6.2+ */
1874 PyModule_AddIntConstant(m, "EPOLLONESHOT", EPOLLONESHOT);
1875 #endif
1876 /* PyModule_AddIntConstant(m, "EPOLL_RDHUP", EPOLLRDHUP); */
1877 #ifdef EPOLLRDNORM
1878 PyModule_AddIntConstant(m, "EPOLLRDNORM", EPOLLRDNORM);
1879 #endif
1880 #ifdef EPOLLRDBAND
1881 PyModule_AddIntConstant(m, "EPOLLRDBAND", EPOLLRDBAND);
1882 #endif
1883 #ifdef EPOLLWRNORM
1884 PyModule_AddIntConstant(m, "EPOLLWRNORM", EPOLLWRNORM);
1885 #endif
1886 #ifdef EPOLLWRBAND
1887 PyModule_AddIntConstant(m, "EPOLLWRBAND", EPOLLWRBAND);
1888 #endif
1889 #ifdef EPOLLMSG
1890 PyModule_AddIntConstant(m, "EPOLLMSG", EPOLLMSG);
1891 #endif
1892 #endif /* HAVE_EPOLL */
1893
1894 #ifdef HAVE_KQUEUE
1895 kqueue_event_Type.tp_new = PyType_GenericNew;
1896 Py_TYPE(&kqueue_event_Type) = &PyType_Type;
1897 if(PyType_Ready(&kqueue_event_Type) < 0)
1898 return;
1899
1900 Py_INCREF(&kqueue_event_Type);
1901 PyModule_AddObject(m, "kevent", (PyObject *)&kqueue_event_Type);
1902
1903 Py_TYPE(&kqueue_queue_Type) = &PyType_Type;
1904 if(PyType_Ready(&kqueue_queue_Type) < 0)
1905 return;
1906 Py_INCREF(&kqueue_queue_Type);
1907 PyModule_AddObject(m, "kqueue", (PyObject *)&kqueue_queue_Type);
1908
1909 /* event filters */
1910 PyModule_AddIntConstant(m, "KQ_FILTER_READ", EVFILT_READ);
1911 PyModule_AddIntConstant(m, "KQ_FILTER_WRITE", EVFILT_WRITE);
1912 PyModule_AddIntConstant(m, "KQ_FILTER_AIO", EVFILT_AIO);
1913 PyModule_AddIntConstant(m, "KQ_FILTER_VNODE", EVFILT_VNODE);
1914 PyModule_AddIntConstant(m, "KQ_FILTER_PROC", EVFILT_PROC);
1915 #ifdef EVFILT_NETDEV
1916 PyModule_AddIntConstant(m, "KQ_FILTER_NETDEV", EVFILT_NETDEV);
1917 #endif
1918 PyModule_AddIntConstant(m, "KQ_FILTER_SIGNAL", EVFILT_SIGNAL);
1919 PyModule_AddIntConstant(m, "KQ_FILTER_TIMER", EVFILT_TIMER);
1920
1921 /* event flags */
1922 PyModule_AddIntConstant(m, "KQ_EV_ADD", EV_ADD);
1923 PyModule_AddIntConstant(m, "KQ_EV_DELETE", EV_DELETE);
1924 PyModule_AddIntConstant(m, "KQ_EV_ENABLE", EV_ENABLE);
1925 PyModule_AddIntConstant(m, "KQ_EV_DISABLE", EV_DISABLE);
1926 PyModule_AddIntConstant(m, "KQ_EV_ONESHOT", EV_ONESHOT);
1927 PyModule_AddIntConstant(m, "KQ_EV_CLEAR", EV_CLEAR);
1928
1929 PyModule_AddIntConstant(m, "KQ_EV_SYSFLAGS", EV_SYSFLAGS);
1930 PyModule_AddIntConstant(m, "KQ_EV_FLAG1", EV_FLAG1);
1931
1932 PyModule_AddIntConstant(m, "KQ_EV_EOF", EV_EOF);
1933 PyModule_AddIntConstant(m, "KQ_EV_ERROR", EV_ERROR);
1934
1935 /* READ WRITE filter flag */
1936 PyModule_AddIntConstant(m, "KQ_NOTE_LOWAT", NOTE_LOWAT);
1937
1938 /* VNODE filter flags */
1939 PyModule_AddIntConstant(m, "KQ_NOTE_DELETE", NOTE_DELETE);
1940 PyModule_AddIntConstant(m, "KQ_NOTE_WRITE", NOTE_WRITE);
1941 PyModule_AddIntConstant(m, "KQ_NOTE_EXTEND", NOTE_EXTEND);
1942 PyModule_AddIntConstant(m, "KQ_NOTE_ATTRIB", NOTE_ATTRIB);
1943 PyModule_AddIntConstant(m, "KQ_NOTE_LINK", NOTE_LINK);
1944 PyModule_AddIntConstant(m, "KQ_NOTE_RENAME", NOTE_RENAME);
1945 PyModule_AddIntConstant(m, "KQ_NOTE_REVOKE", NOTE_REVOKE);
1946
1947 /* PROC filter flags */
1948 PyModule_AddIntConstant(m, "KQ_NOTE_EXIT", NOTE_EXIT);
1949 PyModule_AddIntConstant(m, "KQ_NOTE_FORK", NOTE_FORK);
1950 PyModule_AddIntConstant(m, "KQ_NOTE_EXEC", NOTE_EXEC);
1951 PyModule_AddIntConstant(m, "KQ_NOTE_PCTRLMASK", NOTE_PCTRLMASK);
1952 PyModule_AddIntConstant(m, "KQ_NOTE_PDATAMASK", NOTE_PDATAMASK);
1953
1954 PyModule_AddIntConstant(m, "KQ_NOTE_TRACK", NOTE_TRACK);
1955 PyModule_AddIntConstant(m, "KQ_NOTE_CHILD", NOTE_CHILD);
1956 PyModule_AddIntConstant(m, "KQ_NOTE_TRACKERR", NOTE_TRACKERR);
1957
1958 /* NETDEV filter flags */
1959 #ifdef EVFILT_NETDEV
1960 PyModule_AddIntConstant(m, "KQ_NOTE_LINKUP", NOTE_LINKUP);
1961 PyModule_AddIntConstant(m, "KQ_NOTE_LINKDOWN", NOTE_LINKDOWN);
1962 PyModule_AddIntConstant(m, "KQ_NOTE_LINKINV", NOTE_LINKINV);
1963 #endif
1964
1965 #endif /* HAVE_KQUEUE */
1966 }
1967