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
10 #include <structmember.h>
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.
16 #undef HAVE_BROKEN_POLL
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).
22 Users who want even more than the boosted limit should #define
23 FD_SETSIZE higher before this; e.g., via compiler /D switch.
25 #if defined(MS_WINDOWS) && !defined(FD_SETSIZE)
26 #define FD_SETSIZE 512
29 #if defined(HAVE_POLL_H)
31 #elif defined(HAVE_SYS_POLL_H)
36 /* This is missing from unistd.h */
37 extern void bzero(void *, int);
40 #ifdef HAVE_SYS_TYPES_H
41 #include <sys/types.h>
44 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
54 # include <net/socket.h>
60 static PyObject
*SelectError
;
62 /* list of Python objects and their file descriptor */
64 PyObject
*obj
; /* owned reference */
66 int sentinel
; /* -1 == sentinel */
70 reap_obj(pylist fd2obj
[FD_SETSIZE
+ 1])
73 for (i
= 0; i
< FD_SETSIZE
+ 1 && fd2obj
[i
].sentinel
>= 0; i
++) {
74 Py_XDECREF(fd2obj
[i
].obj
);
77 fd2obj
[0].sentinel
= -1;
81 /* returns -1 and sets the Python exception if an error occurred, otherwise
85 seq2set(PyObject
*seq
, fd_set
*set
, pylist fd2obj
[FD_SETSIZE
+ 1])
91 PyObject
* fast_seq
= NULL
;
94 fd2obj
[0].obj
= (PyObject
*)0; /* set list to zero size */
97 fast_seq
=PySequence_Fast(seq
, "arguments 1-3 must be sequences");
101 len
= PySequence_Fast_GET_SIZE(fast_seq
);
103 for (i
= 0; i
< len
; i
++) {
106 /* any intervening fileno() calls could decr this refcnt */
107 if (!(o
= PySequence_Fast_GET_ITEM(fast_seq
, i
)))
111 v
= PyObject_AsFileDescriptor( o
);
112 if (v
== -1) goto finally
;
114 #if defined(_MSC_VER)
115 max
= 0; /* not used for Win32 */
116 #else /* !_MSC_VER */
117 if (v
< 0 || v
>= FD_SETSIZE
) {
118 PyErr_SetString(PyExc_ValueError
,
119 "filedescriptor out of range in select()");
124 #endif /* _MSC_VER */
127 /* add object and its file descriptor to the list */
128 if (index
>= FD_SETSIZE
) {
129 PyErr_SetString(PyExc_ValueError
,
130 "too many file descriptors in select()");
133 fd2obj
[index
].obj
= o
;
134 fd2obj
[index
].fd
= v
;
135 fd2obj
[index
].sentinel
= 0;
136 fd2obj
[++index
].sentinel
= -1;
147 /* returns NULL and sets the Python exception if an error occurred */
149 set2list(fd_set
*set
, pylist fd2obj
[FD_SETSIZE
+ 1])
155 for (j
= 0; fd2obj
[j
].sentinel
>= 0; j
++) {
156 if (FD_ISSET(fd2obj
[j
].fd
, set
))
159 list
= PyList_New(count
);
164 for (j
= 0; fd2obj
[j
].sentinel
>= 0; j
++) {
166 if (FD_ISSET(fd
, set
)) {
168 if (fd
> FD_SETSIZE
) {
169 PyErr_SetString(PyExc_SystemError
,
170 "filedescriptor out of range returned in select()");
175 fd2obj
[j
].obj
= NULL
;
176 /* transfer ownership */
177 if (PyList_SetItem(list
, i
, o
) < 0)
189 #undef SELECT_USES_HEAP
190 #if FD_SETSIZE > 1024
191 #define SELECT_USES_HEAP
192 #endif /* FD_SETSIZE > 1024 */
195 select_select(PyObject
*self
, PyObject
*args
)
197 #ifdef SELECT_USES_HEAP
198 pylist
*rfd2obj
, *wfd2obj
, *efd2obj
;
199 #else /* !SELECT_USES_HEAP */
200 /* XXX: All this should probably be implemented as follows:
201 * - find the highest descriptor we're interested in
204 * See: Stevens, APitUE, $12.5.1
206 pylist rfd2obj
[FD_SETSIZE
+ 1];
207 pylist wfd2obj
[FD_SETSIZE
+ 1];
208 pylist efd2obj
[FD_SETSIZE
+ 1];
209 #endif /* SELECT_USES_HEAP */
210 PyObject
*ifdlist
, *ofdlist
, *efdlist
;
211 PyObject
*ret
= NULL
;
212 PyObject
*tout
= Py_None
;
213 fd_set ifdset
, ofdset
, efdset
;
215 struct timeval tv
, *tvp
;
217 int imax
, omax
, emax
, max
;
220 /* convert arguments */
221 if (!PyArg_UnpackTuple(args
, "select", 3, 4,
222 &ifdlist
, &ofdlist
, &efdlist
, &tout
))
226 tvp
= (struct timeval
*)0;
227 else if (!PyNumber_Check(tout
)) {
228 PyErr_SetString(PyExc_TypeError
,
229 "timeout must be a float or None");
233 timeout
= PyFloat_AsDouble(tout
);
234 if (timeout
== -1 && PyErr_Occurred())
236 if (timeout
> (double)LONG_MAX
) {
237 PyErr_SetString(PyExc_OverflowError
,
238 "timeout period too long");
241 seconds
= (long)timeout
;
242 timeout
= timeout
- (double)seconds
;
244 tv
.tv_usec
= (long)(timeout
* 1E6
);
249 #ifdef SELECT_USES_HEAP
250 /* Allocate memory for the lists */
251 rfd2obj
= PyMem_NEW(pylist
, FD_SETSIZE
+ 1);
252 wfd2obj
= PyMem_NEW(pylist
, FD_SETSIZE
+ 1);
253 efd2obj
= PyMem_NEW(pylist
, FD_SETSIZE
+ 1);
254 if (rfd2obj
== NULL
|| wfd2obj
== NULL
|| efd2obj
== NULL
) {
255 if (rfd2obj
) PyMem_DEL(rfd2obj
);
256 if (wfd2obj
) PyMem_DEL(wfd2obj
);
257 if (efd2obj
) PyMem_DEL(efd2obj
);
258 return PyErr_NoMemory();
260 #endif /* SELECT_USES_HEAP */
261 /* Convert sequences to fd_sets, and get maximum fd number
262 * propagates the Python exception set in seq2set()
264 rfd2obj
[0].sentinel
= -1;
265 wfd2obj
[0].sentinel
= -1;
266 efd2obj
[0].sentinel
= -1;
267 if ((imax
=seq2set(ifdlist
, &ifdset
, rfd2obj
)) < 0)
269 if ((omax
=seq2set(ofdlist
, &ofdset
, wfd2obj
)) < 0)
271 if ((emax
=seq2set(efdlist
, &efdset
, efd2obj
)) < 0)
274 if (omax
> max
) max
= omax
;
275 if (emax
> max
) max
= emax
;
277 Py_BEGIN_ALLOW_THREADS
278 n
= select(max
, &ifdset
, &ofdset
, &efdset
, tvp
);
282 if (n
== SOCKET_ERROR
) {
283 PyErr_SetExcFromWindowsErr(SelectError
, WSAGetLastError());
287 PyErr_SetFromErrno(SelectError
);
292 ifdlist
= PyList_New(0);
294 ret
= PyTuple_Pack(3, ifdlist
, ifdlist
, ifdlist
);
299 /* any of these three calls can raise an exception. it's more
300 convenient to test for this after all three calls... but
303 ifdlist
= set2list(&ifdset
, rfd2obj
);
304 ofdlist
= set2list(&ofdset
, wfd2obj
);
305 efdlist
= set2list(&efdset
, efd2obj
);
306 if (PyErr_Occurred())
309 ret
= PyTuple_Pack(3, ifdlist
, ofdlist
, efdlist
);
320 #ifdef SELECT_USES_HEAP
324 #endif /* SELECT_USES_HEAP */
328 #if defined(HAVE_POLL) && !defined(HAVE_BROKEN_POLL)
341 static PyTypeObject poll_Type
;
343 /* Update the malloc'ed array of pollfds to match the dictionary
344 contained within a pollObject. Return 1 on success, 0 on an error.
348 update_ufd_array(pollObject
*self
)
351 PyObject
*key
, *value
;
353 self
->ufd_len
= PyDict_Size(self
->dict
);
354 PyMem_Resize(self
->ufds
, struct pollfd
, self
->ufd_len
);
355 if (self
->ufds
== NULL
) {
361 while (PyDict_Next(self
->dict
, &pos
, &key
, &value
)) {
362 self
->ufds
[i
].fd
= PyInt_AsLong(key
);
363 self
->ufds
[i
].events
= (short)PyInt_AsLong(value
);
366 self
->ufd_uptodate
= 1;
370 PyDoc_STRVAR(poll_register_doc
,
371 "register(fd [, eventmask] ) -> None\n\n\
372 Register a file descriptor with the polling object.\n\
373 fd -- either an integer, or an object with a fileno() method returning an\n\
375 events -- an optional bitmask describing the type of events to check for");
378 poll_register(pollObject
*self
, PyObject
*args
)
380 PyObject
*o
, *key
, *value
;
381 int fd
, events
= POLLIN
| POLLPRI
| POLLOUT
;
384 if (!PyArg_ParseTuple(args
, "O|i:register", &o
, &events
)) {
388 fd
= PyObject_AsFileDescriptor(o
);
389 if (fd
== -1) return NULL
;
391 /* Add entry to the internal dictionary: the key is the
392 file descriptor, and the value is the event mask. */
393 key
= PyInt_FromLong(fd
);
396 value
= PyInt_FromLong(events
);
401 err
= PyDict_SetItem(self
->dict
, key
, value
);
407 self
->ufd_uptodate
= 0;
413 PyDoc_STRVAR(poll_modify_doc
,
414 "modify(fd, eventmask) -> None\n\n\
415 Modify an already registered file descriptor.\n\
416 fd -- either an integer, or an object with a fileno() method returning an\n\
418 events -- an optional bitmask describing the type of events to check for");
421 poll_modify(pollObject
*self
, PyObject
*args
)
423 PyObject
*o
, *key
, *value
;
427 if (!PyArg_ParseTuple(args
, "Oi:modify", &o
, &events
)) {
431 fd
= PyObject_AsFileDescriptor(o
);
432 if (fd
== -1) return NULL
;
434 /* Modify registered fd */
435 key
= PyInt_FromLong(fd
);
438 if (PyDict_GetItem(self
->dict
, key
) == NULL
) {
440 PyErr_SetFromErrno(PyExc_IOError
);
443 value
= PyInt_FromLong(events
);
448 err
= PyDict_SetItem(self
->dict
, key
, value
);
454 self
->ufd_uptodate
= 0;
461 PyDoc_STRVAR(poll_unregister_doc
,
462 "unregister(fd) -> None\n\n\
463 Remove a file descriptor being tracked by the polling object.");
466 poll_unregister(pollObject
*self
, PyObject
*o
)
471 fd
= PyObject_AsFileDescriptor( o
);
475 /* Check whether the fd is already in the array */
476 key
= PyInt_FromLong(fd
);
480 if (PyDict_DelItem(self
->dict
, key
) == -1) {
482 /* This will simply raise the KeyError set by PyDict_DelItem
483 if the file descriptor isn't registered. */
488 self
->ufd_uptodate
= 0;
494 PyDoc_STRVAR(poll_poll_doc
,
495 "poll( [timeout] ) -> list of (fd, event) 2-tuples\n\n\
496 Polls the set of registered file descriptors, returning a list containing \n\
497 any descriptors that have events or errors to report.");
500 poll_poll(pollObject
*self
, PyObject
*args
)
502 PyObject
*result_list
= NULL
, *tout
= NULL
;
503 int timeout
= 0, poll_result
, i
, j
;
504 PyObject
*value
= NULL
, *num
= NULL
;
506 if (!PyArg_UnpackTuple(args
, "poll", 0, 1, &tout
)) {
510 /* Check values for timeout */
511 if (tout
== NULL
|| tout
== Py_None
)
513 else if (!PyNumber_Check(tout
)) {
514 PyErr_SetString(PyExc_TypeError
,
515 "timeout must be an integer or None");
519 tout
= PyNumber_Int(tout
);
522 timeout
= PyInt_AsLong(tout
);
524 if (timeout
== -1 && PyErr_Occurred())
528 /* Ensure the ufd array is up to date */
529 if (!self
->ufd_uptodate
)
530 if (update_ufd_array(self
) == 0)
534 Py_BEGIN_ALLOW_THREADS
535 poll_result
= poll(self
->ufds
, self
->ufd_len
, timeout
);
538 if (poll_result
< 0) {
539 PyErr_SetFromErrno(SelectError
);
543 /* build the result list */
545 result_list
= PyList_New(poll_result
);
549 for (i
= 0, j
= 0; j
< poll_result
; j
++) {
550 /* skip to the next fired descriptor */
551 while (!self
->ufds
[i
].revents
) {
554 /* if we hit a NULL return, set value to NULL
555 and break out of loop; code at end will
556 clean up result_list */
557 value
= PyTuple_New(2);
560 num
= PyInt_FromLong(self
->ufds
[i
].fd
);
565 PyTuple_SET_ITEM(value
, 0, num
);
567 /* The &0xffff is a workaround for AIX. 'revents'
568 is a 16-bit short, and IBM assigned POLLNVAL
569 to be 0x8000, so the conversion to int results
570 in a negative number. See SF bug #923315. */
571 num
= PyInt_FromLong(self
->ufds
[i
].revents
& 0xffff);
576 PyTuple_SET_ITEM(value
, 1, num
);
577 if ((PyList_SetItem(result_list
, j
, value
)) == -1) {
587 Py_DECREF(result_list
);
591 static PyMethodDef poll_methods
[] = {
592 {"register", (PyCFunction
)poll_register
,
593 METH_VARARGS
, poll_register_doc
},
594 {"modify", (PyCFunction
)poll_modify
,
595 METH_VARARGS
, poll_modify_doc
},
596 {"unregister", (PyCFunction
)poll_unregister
,
597 METH_O
, poll_unregister_doc
},
598 {"poll", (PyCFunction
)poll_poll
,
599 METH_VARARGS
, poll_poll_doc
},
600 {NULL
, NULL
} /* sentinel */
607 self
= PyObject_New(pollObject
, &poll_Type
);
610 /* ufd_uptodate is a Boolean, denoting whether the
611 array pointed to by ufds matches the contents of the dictionary. */
612 self
->ufd_uptodate
= 0;
614 self
->dict
= PyDict_New();
615 if (self
->dict
== NULL
) {
623 poll_dealloc(pollObject
*self
)
625 if (self
->ufds
!= NULL
)
626 PyMem_DEL(self
->ufds
);
627 Py_XDECREF(self
->dict
);
632 poll_getattr(pollObject
*self
, char *name
)
634 return Py_FindMethod(poll_methods
, (PyObject
*)self
, name
);
637 static PyTypeObject poll_Type
= {
638 /* The ob_type field must be initialized in the module init function
639 * to be portable to Windows without using C++. */
640 PyVarObject_HEAD_INIT(NULL
, 0)
641 "select.poll", /*tp_name*/
642 sizeof(pollObject
), /*tp_basicsize*/
645 (destructor
)poll_dealloc
, /*tp_dealloc*/
647 (getattrfunc
)poll_getattr
, /*tp_getattr*/
652 0, /*tp_as_sequence*/
657 PyDoc_STRVAR(poll_doc
,
658 "Returns a polling object, which supports registering and\n\
659 unregistering file descriptors, and then polling them for I/O events.");
662 select_poll(PyObject
*self
, PyObject
*unused
)
664 return (PyObject
*)newPollObject();
669 * On some systems poll() sets errno on invalid file descriptors. We test
670 * for this at runtime because this bug may be fixed or introduced between
673 static int select_have_broken_poll(void)
678 struct pollfd poll_struct
= { 0, POLLIN
|POLLPRI
|POLLOUT
, 0 };
680 /* Create a file descriptor to make invalid */
681 if (pipe(filedes
) < 0) {
684 poll_struct
.fd
= filedes
[0];
687 poll_test
= poll(&poll_struct
, 1, 0);
690 } else if (poll_test
== 0 && poll_struct
.revents
!= POLLNVAL
) {
695 #endif /* __APPLE__ */
697 #endif /* HAVE_POLL */
700 /* **************************************************************************
701 * epoll interface for Linux 2.6
703 * Written by Christian Heimes
704 * Inspired by Twisted's _epoll.pyx and select.poll()
707 #ifdef HAVE_SYS_EPOLL_H
708 #include <sys/epoll.h>
713 SOCKET epfd
; /* epoll control file descriptor */
716 static PyTypeObject pyEpoll_Type
;
717 #define pyepoll_CHECK(op) (PyObject_TypeCheck((op), &pyEpoll_Type))
720 pyepoll_err_closed(void)
722 PyErr_SetString(PyExc_ValueError
, "I/O operation on closed epoll fd");
727 pyepoll_internal_close(pyEpoll_Object
*self
)
730 if (self
->epfd
>= 0) {
731 int epfd
= self
->epfd
;
733 Py_BEGIN_ALLOW_THREADS
742 newPyEpoll_Object(PyTypeObject
*type
, int sizehint
, SOCKET fd
)
744 pyEpoll_Object
*self
;
746 if (sizehint
== -1) {
747 sizehint
= FD_SETSIZE
-1;
749 else if (sizehint
< 1) {
750 PyErr_Format(PyExc_ValueError
,
751 "sizehint must be greater zero, got %d",
756 assert(type
!= NULL
&& type
->tp_alloc
!= NULL
);
757 self
= (pyEpoll_Object
*) type
->tp_alloc(type
, 0);
762 Py_BEGIN_ALLOW_THREADS
763 self
->epfd
= epoll_create(sizehint
);
769 if (self
->epfd
< 0) {
771 PyErr_SetFromErrno(PyExc_IOError
);
774 return (PyObject
*)self
;
779 pyepoll_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
782 static char *kwlist
[] = {"sizehint", NULL
};
784 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "|i:epoll", kwlist
,
788 return newPyEpoll_Object(type
, sizehint
, -1);
793 pyepoll_dealloc(pyEpoll_Object
*self
)
795 (void)pyepoll_internal_close(self
);
796 Py_TYPE(self
)->tp_free(self
);
800 pyepoll_close(pyEpoll_Object
*self
)
802 errno
= pyepoll_internal_close(self
);
804 PyErr_SetFromErrno(PyExc_IOError
);
810 PyDoc_STRVAR(pyepoll_close_doc
,
813 Close the epoll control file descriptor. Further operations on the epoll\n\
814 object will raise an exception.");
817 pyepoll_get_closed(pyEpoll_Object
*self
)
826 pyepoll_fileno(pyEpoll_Object
*self
)
829 return pyepoll_err_closed();
830 return PyInt_FromLong(self
->epfd
);
833 PyDoc_STRVAR(pyepoll_fileno_doc
,
836 Return the epoll control file descriptor.");
839 pyepoll_fromfd(PyObject
*cls
, PyObject
*args
)
843 if (!PyArg_ParseTuple(args
, "i:fromfd", &fd
))
846 return newPyEpoll_Object((PyTypeObject
*)cls
, -1, fd
);
849 PyDoc_STRVAR(pyepoll_fromfd_doc
,
850 "fromfd(fd) -> epoll\n\
852 Create an epoll object from a given control fd.");
855 pyepoll_internal_ctl(int epfd
, int op
, PyObject
*pfd
, unsigned int events
)
857 struct epoll_event ev
;
862 return pyepoll_err_closed();
864 fd
= PyObject_AsFileDescriptor(pfd
);
874 Py_BEGIN_ALLOW_THREADS
875 result
= epoll_ctl(epfd
, op
, fd
, &ev
);
879 /* In kernel versions before 2.6.9, the EPOLL_CTL_DEL
880 * operation required a non-NULL pointer in event, even
881 * though this argument is ignored. */
882 Py_BEGIN_ALLOW_THREADS
883 result
= epoll_ctl(epfd
, op
, fd
, &ev
);
884 if (errno
== EBADF
) {
885 /* fd already closed */
897 PyErr_SetFromErrno(PyExc_IOError
);
904 pyepoll_register(pyEpoll_Object
*self
, PyObject
*args
, PyObject
*kwds
)
907 unsigned int events
= EPOLLIN
| EPOLLOUT
| EPOLLPRI
;
908 static char *kwlist
[] = {"fd", "eventmask", NULL
};
910 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "O|I:register", kwlist
,
915 return pyepoll_internal_ctl(self
->epfd
, EPOLL_CTL_ADD
, pfd
, events
);
918 PyDoc_STRVAR(pyepoll_register_doc
,
919 "register(fd[, eventmask]) -> bool\n\
921 Registers a new fd or modifies an already registered fd. register() returns\n\
922 True if a new fd was registered or False if the event mask for fd was modified.\n\
923 fd is the target file descriptor of the operation.\n\
924 events is a bit set composed of the various EPOLL constants; the default\n\
925 is EPOLL_IN | EPOLL_OUT | EPOLL_PRI.\n\
927 The epoll interface supports all file descriptors that support poll.");
930 pyepoll_modify(pyEpoll_Object
*self
, PyObject
*args
, PyObject
*kwds
)
934 static char *kwlist
[] = {"fd", "eventmask", NULL
};
936 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "OI:modify", kwlist
,
941 return pyepoll_internal_ctl(self
->epfd
, EPOLL_CTL_MOD
, pfd
, events
);
944 PyDoc_STRVAR(pyepoll_modify_doc
,
945 "modify(fd, eventmask) -> None\n\
947 fd is the target file descriptor of the operation\n\
948 events is a bit set composed of the various EPOLL constants");
951 pyepoll_unregister(pyEpoll_Object
*self
, PyObject
*args
, PyObject
*kwds
)
954 static char *kwlist
[] = {"fd", NULL
};
956 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "O:unregister", kwlist
,
961 return pyepoll_internal_ctl(self
->epfd
, EPOLL_CTL_DEL
, pfd
, 0);
964 PyDoc_STRVAR(pyepoll_unregister_doc
,
965 "unregister(fd) -> None\n\
967 fd is the target file descriptor of the operation.");
970 pyepoll_poll(pyEpoll_Object
*self
, PyObject
*args
, PyObject
*kwds
)
972 double dtimeout
= -1.;
976 PyObject
*elist
= NULL
, *etuple
= NULL
;
977 struct epoll_event
*evs
= NULL
;
978 static char *kwlist
[] = {"timeout", "maxevents", NULL
};
981 return pyepoll_err_closed();
983 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "|di:poll", kwlist
,
984 &dtimeout
, &maxevents
)) {
991 else if (dtimeout
* 1000.0 > INT_MAX
) {
992 PyErr_SetString(PyExc_OverflowError
,
993 "timeout is too large");
997 timeout
= (int)(dtimeout
* 1000.0);
1000 if (maxevents
== -1) {
1001 maxevents
= FD_SETSIZE
-1;
1003 else if (maxevents
< 1) {
1004 PyErr_Format(PyExc_ValueError
,
1005 "maxevents must be greater than 0, got %d",
1010 evs
= PyMem_New(struct epoll_event
, maxevents
);
1017 Py_BEGIN_ALLOW_THREADS
1018 nfds
= epoll_wait(self
->epfd
, evs
, maxevents
, timeout
);
1019 Py_END_ALLOW_THREADS
1021 PyErr_SetFromErrno(PyExc_IOError
);
1025 elist
= PyList_New(nfds
);
1026 if (elist
== NULL
) {
1030 for (i
= 0; i
< nfds
; i
++) {
1031 etuple
= Py_BuildValue("iI", evs
[i
].data
.fd
, evs
[i
].events
);
1032 if (etuple
== NULL
) {
1036 PyList_SET_ITEM(elist
, i
, etuple
);
1044 PyDoc_STRVAR(pyepoll_poll_doc
,
1045 "poll([timeout=-1[, maxevents=-1]]) -> [(fd, events), (...)]\n\
1047 Wait for events on the epoll file descriptor for a maximum time of timeout\n\
1048 in seconds (as float). -1 makes poll wait indefinitely.\n\
1049 Up to maxevents are returned to the caller.");
1051 static PyMethodDef pyepoll_methods
[] = {
1052 {"fromfd", (PyCFunction
)pyepoll_fromfd
,
1053 METH_VARARGS
| METH_CLASS
, pyepoll_fromfd_doc
},
1054 {"close", (PyCFunction
)pyepoll_close
, METH_NOARGS
,
1056 {"fileno", (PyCFunction
)pyepoll_fileno
, METH_NOARGS
,
1057 pyepoll_fileno_doc
},
1058 {"modify", (PyCFunction
)pyepoll_modify
,
1059 METH_VARARGS
| METH_KEYWORDS
, pyepoll_modify_doc
},
1060 {"register", (PyCFunction
)pyepoll_register
,
1061 METH_VARARGS
| METH_KEYWORDS
, pyepoll_register_doc
},
1062 {"unregister", (PyCFunction
)pyepoll_unregister
,
1063 METH_VARARGS
| METH_KEYWORDS
, pyepoll_unregister_doc
},
1064 {"poll", (PyCFunction
)pyepoll_poll
,
1065 METH_VARARGS
| METH_KEYWORDS
, pyepoll_poll_doc
},
1069 static PyGetSetDef pyepoll_getsetlist
[] = {
1070 {"closed", (getter
)pyepoll_get_closed
, NULL
,
1071 "True if the epoll handler is closed"},
1075 PyDoc_STRVAR(pyepoll_doc
,
1076 "select.epoll([sizehint=-1])\n\
1078 Returns an epolling object\n\
1080 sizehint must be a positive integer or -1 for the default size. The\n\
1081 sizehint is used to optimize internal data structures. It doesn't limit\n\
1082 the maximum number of monitored events.");
1084 static PyTypeObject pyEpoll_Type
= {
1085 PyVarObject_HEAD_INIT(NULL
, 0)
1086 "select.epoll", /* tp_name */
1087 sizeof(pyEpoll_Object
), /* tp_basicsize */
1088 0, /* tp_itemsize */
1089 (destructor
)pyepoll_dealloc
, /* tp_dealloc */
1095 0, /* tp_as_number */
1096 0, /* tp_as_sequence */
1097 0, /* tp_as_mapping */
1101 PyObject_GenericGetAttr
, /* tp_getattro */
1102 0, /* tp_setattro */
1103 0, /* tp_as_buffer */
1104 Py_TPFLAGS_DEFAULT
, /* tp_flags */
1105 pyepoll_doc
, /* tp_doc */
1106 0, /* tp_traverse */
1108 0, /* tp_richcompare */
1109 0, /* tp_weaklistoffset */
1111 0, /* tp_iternext */
1112 pyepoll_methods
, /* tp_methods */
1114 pyepoll_getsetlist
, /* tp_getset */
1117 0, /* tp_descr_get */
1118 0, /* tp_descr_set */
1119 0, /* tp_dictoffset */
1122 pyepoll_new
, /* tp_new */
1126 #endif /* HAVE_EPOLL */
1129 /* **************************************************************************
1130 * kqueue interface for BSD
1132 * Copyright (c) 2000 Doug White, 2006 James Knight, 2007 Christian Heimes
1133 * All rights reserved.
1135 * Redistribution and use in source and binary forms, with or without
1136 * modification, are permitted provided that the following conditions
1138 * 1. Redistributions of source code must retain the above copyright
1139 * notice, this list of conditions and the following disclaimer.
1140 * 2. Redistributions in binary form must reproduce the above copyright
1141 * notice, this list of conditions and the following disclaimer in the
1142 * documentation and/or other materials provided with the distribution.
1144 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
1145 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1146 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1147 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
1148 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1149 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1150 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1151 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1152 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1153 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1157 #ifdef HAVE_SYS_EVENT_H
1158 #include <sys/event.h>
1161 PyDoc_STRVAR(kqueue_event_doc
,
1162 "kevent(ident, filter=KQ_FILTER_READ, flags=KQ_ADD, fflags=0, data=0, udata=0)\n\
1164 This object is the equivalent of the struct kevent for the C API.\n\
1166 See the kqueue manpage for more detailed information about the meaning\n\
1167 of the arguments.\n\
1169 One minor note: while you might hope that udata could store a\n\
1170 reference to a python object, it cannot, because it is impossible to\n\
1171 keep a proper reference count of the object once it's passed into the\n\
1172 kernel. Therefore, I have restricted it to only storing an integer. I\n\
1173 recommend ignoring it and simply using the 'ident' field to key off\n\
1174 of. You could also set up a dictionary on the python side to store a\n\
1175 udata->object mapping.");
1180 } kqueue_event_Object
;
1182 static PyTypeObject kqueue_event_Type
;
1184 #define kqueue_event_Check(op) (PyObject_TypeCheck((op), &kqueue_event_Type))
1188 SOCKET kqfd
; /* kqueue control fd */
1189 } kqueue_queue_Object
;
1191 static PyTypeObject kqueue_queue_Type
;
1193 #define kqueue_queue_Check(op) (PyObject_TypeCheck((op), &kqueue_queue_Type))
1195 /* Unfortunately, we can't store python objects in udata, because
1196 * kevents in the kernel can be removed without warning, which would
1197 * forever lose the refcount on the object stored with it.
1200 #define KQ_OFF(x) offsetof(kqueue_event_Object, x)
1201 static struct PyMemberDef kqueue_event_members
[] = {
1202 {"ident", T_UINT
, KQ_OFF(e
.ident
)},
1203 {"filter", T_SHORT
, KQ_OFF(e
.filter
)},
1204 {"flags", T_USHORT
, KQ_OFF(e
.flags
)},
1205 {"fflags", T_UINT
, KQ_OFF(e
.fflags
)},
1206 {"data", T_INT
, KQ_OFF(e
.data
)},
1207 {"udata", T_INT
, KQ_OFF(e
.udata
)},
1208 {NULL
} /* Sentinel */
1213 kqueue_event_repr(kqueue_event_Object
*s
)
1218 "<select.kevent ident=%lu filter=%d flags=0x%x fflags=0x%x "
1219 "data=0x%lx udata=%p>",
1220 (unsigned long)(s
->e
.ident
), s
->e
.filter
, s
->e
.flags
,
1221 s
->e
.fflags
, (long)(s
->e
.data
), s
->e
.udata
);
1222 return PyString_FromString(buf
);
1226 kqueue_event_init(kqueue_event_Object
*self
, PyObject
*args
, PyObject
*kwds
)
1229 static char *kwlist
[] = {"ident", "filter", "flags", "fflags",
1230 "data", "udata", NULL
};
1232 EV_SET(&(self
->e
), 0, EVFILT_READ
, EV_ADD
, 0, 0, 0); /* defaults */
1234 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "O|hhiii:kevent", kwlist
,
1235 &pfd
, &(self
->e
.filter
), &(self
->e
.flags
),
1236 &(self
->e
.fflags
), &(self
->e
.data
), &(self
->e
.udata
))) {
1240 self
->e
.ident
= PyObject_AsFileDescriptor(pfd
);
1241 if (self
->e
.ident
== -1) {
1248 kqueue_event_richcompare(kqueue_event_Object
*s
, kqueue_event_Object
*o
,
1253 if (!kqueue_event_Check(o
)) {
1254 if (op
== Py_EQ
|| op
== Py_NE
) {
1255 PyObject
*res
= op
== Py_EQ
? Py_False
: Py_True
;
1259 PyErr_Format(PyExc_TypeError
,
1260 "can't compare %.200s to %.200s",
1261 Py_TYPE(s
)->tp_name
, Py_TYPE(o
)->tp_name
);
1264 if (((result
= s
->e
.ident
- o
->e
.ident
) == 0) &&
1265 ((result
= s
->e
.filter
- o
->e
.filter
) == 0) &&
1266 ((result
= s
->e
.flags
- o
->e
.flags
) == 0) &&
1267 ((result
= s
->e
.fflags
- o
->e
.fflags
) == 0) &&
1268 ((result
= s
->e
.data
- o
->e
.data
) == 0) &&
1269 ((result
= s
->e
.udata
- o
->e
.udata
) == 0)
1276 result
= (result
== 0);
1279 result
= (result
!= 0);
1282 result
= (result
<= 0);
1285 result
= (result
>= 0);
1288 result
= (result
< 0);
1291 result
= (result
> 0);
1294 return PyBool_FromLong(result
);
1297 static PyTypeObject kqueue_event_Type
= {
1298 PyVarObject_HEAD_INIT(NULL
, 0)
1299 "select.kevent", /* tp_name */
1300 sizeof(kqueue_event_Object
), /* tp_basicsize */
1301 0, /* tp_itemsize */
1307 (reprfunc
)kqueue_event_repr
, /* tp_repr */
1308 0, /* tp_as_number */
1309 0, /* tp_as_sequence */
1310 0, /* tp_as_mapping */
1314 0, /* tp_getattro */
1315 0, /* tp_setattro */
1316 0, /* tp_as_buffer */
1317 Py_TPFLAGS_DEFAULT
, /* tp_flags */
1318 kqueue_event_doc
, /* tp_doc */
1319 0, /* tp_traverse */
1321 (richcmpfunc
)kqueue_event_richcompare
, /* tp_richcompare */
1322 0, /* tp_weaklistoffset */
1324 0, /* tp_iternext */
1326 kqueue_event_members
, /* tp_members */
1330 0, /* tp_descr_get */
1331 0, /* tp_descr_set */
1332 0, /* tp_dictoffset */
1333 (initproc
)kqueue_event_init
, /* tp_init */
1340 kqueue_queue_err_closed(void)
1342 PyErr_SetString(PyExc_ValueError
, "I/O operation on closed kqueue fd");
1347 kqueue_queue_internal_close(kqueue_queue_Object
*self
)
1350 if (self
->kqfd
>= 0) {
1351 int kqfd
= self
->kqfd
;
1353 Py_BEGIN_ALLOW_THREADS
1354 if (close(kqfd
) < 0)
1356 Py_END_ALLOW_THREADS
1362 newKqueue_Object(PyTypeObject
*type
, SOCKET fd
)
1364 kqueue_queue_Object
*self
;
1365 assert(type
!= NULL
&& type
->tp_alloc
!= NULL
);
1366 self
= (kqueue_queue_Object
*) type
->tp_alloc(type
, 0);
1372 Py_BEGIN_ALLOW_THREADS
1373 self
->kqfd
= kqueue();
1374 Py_END_ALLOW_THREADS
1379 if (self
->kqfd
< 0) {
1381 PyErr_SetFromErrno(PyExc_IOError
);
1384 return (PyObject
*)self
;
1388 kqueue_queue_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
1391 if ((args
!= NULL
&& PyObject_Size(args
)) ||
1392 (kwds
!= NULL
&& PyObject_Size(kwds
))) {
1393 PyErr_SetString(PyExc_ValueError
,
1394 "select.kqueue doesn't accept arguments");
1398 return newKqueue_Object(type
, -1);
1402 kqueue_queue_dealloc(kqueue_queue_Object
*self
)
1404 kqueue_queue_internal_close(self
);
1405 Py_TYPE(self
)->tp_free(self
);
1409 kqueue_queue_close(kqueue_queue_Object
*self
)
1411 errno
= kqueue_queue_internal_close(self
);
1413 PyErr_SetFromErrno(PyExc_IOError
);
1419 PyDoc_STRVAR(kqueue_queue_close_doc
,
1422 Close the kqueue control file descriptor. Further operations on the kqueue\n\
1423 object will raise an exception.");
1426 kqueue_queue_get_closed(kqueue_queue_Object
*self
)
1435 kqueue_queue_fileno(kqueue_queue_Object
*self
)
1438 return kqueue_queue_err_closed();
1439 return PyInt_FromLong(self
->kqfd
);
1442 PyDoc_STRVAR(kqueue_queue_fileno_doc
,
1445 Return the kqueue control file descriptor.");
1448 kqueue_queue_fromfd(PyObject
*cls
, PyObject
*args
)
1452 if (!PyArg_ParseTuple(args
, "i:fromfd", &fd
))
1455 return newKqueue_Object((PyTypeObject
*)cls
, fd
);
1458 PyDoc_STRVAR(kqueue_queue_fromfd_doc
,
1459 "fromfd(fd) -> kqueue\n\
1461 Create a kqueue object from a given control fd.");
1464 kqueue_queue_control(kqueue_queue_Object
*self
, PyObject
*args
)
1470 PyObject
*otimeout
= NULL
;
1471 PyObject
*ch
= NULL
;
1472 PyObject
*it
= NULL
, *ei
= NULL
;
1473 PyObject
*result
= NULL
;
1474 struct kevent
*evl
= NULL
;
1475 struct kevent
*chl
= NULL
;
1476 struct timespec timeoutspec
;
1477 struct timespec
*ptimeoutspec
;
1480 return kqueue_queue_err_closed();
1482 if (!PyArg_ParseTuple(args
, "Oi|O:control", &ch
, &nevents
, &otimeout
))
1486 PyErr_Format(PyExc_ValueError
,
1487 "Length of eventlist must be 0 or positive, got %d",
1492 if (ch
!= NULL
&& ch
!= Py_None
) {
1493 it
= PyObject_GetIter(ch
);
1495 PyErr_SetString(PyExc_TypeError
,
1496 "changelist is not iterable");
1499 nchanges
= PyObject_Size(ch
);
1505 if (otimeout
== Py_None
|| otimeout
== NULL
) {
1506 ptimeoutspec
= NULL
;
1508 else if (PyNumber_Check(otimeout
)) {
1512 timeout
= PyFloat_AsDouble(otimeout
);
1513 if (timeout
== -1 && PyErr_Occurred())
1515 if (timeout
> (double)LONG_MAX
) {
1516 PyErr_SetString(PyExc_OverflowError
,
1517 "timeout period too long");
1521 PyErr_SetString(PyExc_ValueError
,
1522 "timeout must be positive or None");
1526 seconds
= (long)timeout
;
1527 timeout
= timeout
- (double)seconds
;
1528 timeoutspec
.tv_sec
= seconds
;
1529 timeoutspec
.tv_nsec
= (long)(timeout
* 1E9
);
1530 ptimeoutspec
= &timeoutspec
;
1533 PyErr_Format(PyExc_TypeError
,
1534 "timeout argument must be an number "
1535 "or None, got %.200s",
1536 Py_TYPE(otimeout
)->tp_name
);
1541 chl
= PyMem_New(struct kevent
, nchanges
);
1546 while ((ei
= PyIter_Next(it
)) != NULL
) {
1547 if (!kqueue_event_Check(ei
)) {
1549 PyErr_SetString(PyExc_TypeError
,
1550 "changelist must be an iterable of "
1551 "select.kevent objects");
1554 chl
[i
] = ((kqueue_event_Object
*)ei
)->e
;
1563 evl
= PyMem_New(struct kevent
, nevents
);
1570 Py_BEGIN_ALLOW_THREADS
1571 gotevents
= kevent(self
->kqfd
, chl
, nchanges
,
1572 evl
, nevents
, ptimeoutspec
);
1573 Py_END_ALLOW_THREADS
1575 if (gotevents
== -1) {
1576 PyErr_SetFromErrno(PyExc_OSError
);
1580 result
= PyList_New(gotevents
);
1581 if (result
== NULL
) {
1585 for (i
=0; i
< gotevents
; i
++) {
1586 kqueue_event_Object
*ch
;
1588 ch
= PyObject_New(kqueue_event_Object
, &kqueue_event_Type
);
1593 PyList_SET_ITEM(result
, i
, (PyObject
*)ch
);
1607 PyDoc_STRVAR(kqueue_queue_control_doc
,
1608 "control(changelist, max_events=0[, timeout=None]) -> eventlist\n\
1610 Calls the kernel kevent function.\n\
1611 - changelist must be a list of kevent objects describing the changes\n\
1612 to be made to the kernel's watch list or None.\n\
1613 - max_events lets you specify the maximum number of events that the\n\
1614 kernel will return.\n\
1615 - timeout is the maximum time to wait in seconds, or else None,\n\
1616 to wait forever. timeout accepts floats for smaller timeouts, too.");
1619 static PyMethodDef kqueue_queue_methods
[] = {
1620 {"fromfd", (PyCFunction
)kqueue_queue_fromfd
,
1621 METH_VARARGS
| METH_CLASS
, kqueue_queue_fromfd_doc
},
1622 {"close", (PyCFunction
)kqueue_queue_close
, METH_NOARGS
,
1623 kqueue_queue_close_doc
},
1624 {"fileno", (PyCFunction
)kqueue_queue_fileno
, METH_NOARGS
,
1625 kqueue_queue_fileno_doc
},
1626 {"control", (PyCFunction
)kqueue_queue_control
,
1627 METH_VARARGS
, kqueue_queue_control_doc
},
1631 static PyGetSetDef kqueue_queue_getsetlist
[] = {
1632 {"closed", (getter
)kqueue_queue_get_closed
, NULL
,
1633 "True if the kqueue handler is closed"},
1637 PyDoc_STRVAR(kqueue_queue_doc
,
1638 "Kqueue syscall wrapper.\n\
1640 For example, to start watching a socket for input:\n\
1641 >>> kq = kqueue()\n\
1642 >>> sock = socket()\n\
1643 >>> sock.connect((host, port))\n\
1644 >>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_ADD)], 0)\n\
1646 To wait one second for it to become writeable:\n\
1647 >>> kq.control(None, 1, 1000)\n\
1649 To stop listening:\n\
1650 >>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_DELETE)], 0)");
1652 static PyTypeObject kqueue_queue_Type
= {
1653 PyVarObject_HEAD_INIT(NULL
, 0)
1654 "select.kqueue", /* tp_name */
1655 sizeof(kqueue_queue_Object
), /* tp_basicsize */
1656 0, /* tp_itemsize */
1657 (destructor
)kqueue_queue_dealloc
, /* tp_dealloc */
1663 0, /* tp_as_number */
1664 0, /* tp_as_sequence */
1665 0, /* tp_as_mapping */
1669 0, /* tp_getattro */
1670 0, /* tp_setattro */
1671 0, /* tp_as_buffer */
1672 Py_TPFLAGS_DEFAULT
, /* tp_flags */
1673 kqueue_queue_doc
, /* tp_doc */
1674 0, /* tp_traverse */
1676 0, /* tp_richcompare */
1677 0, /* tp_weaklistoffset */
1679 0, /* tp_iternext */
1680 kqueue_queue_methods
, /* tp_methods */
1682 kqueue_queue_getsetlist
, /* tp_getset */
1685 0, /* tp_descr_get */
1686 0, /* tp_descr_set */
1687 0, /* tp_dictoffset */
1690 kqueue_queue_new
, /* tp_new */
1694 #endif /* HAVE_KQUEUE */
1695 /* ************************************************************************ */
1697 PyDoc_STRVAR(select_doc
,
1698 "select(rlist, wlist, xlist[, timeout]) -> (rlist, wlist, xlist)\n\
1700 Wait until one or more file descriptors are ready for some kind of I/O.\n\
1701 The first three arguments are sequences of file descriptors to be waited for:\n\
1702 rlist -- wait until ready for reading\n\
1703 wlist -- wait until ready for writing\n\
1704 xlist -- wait for an ``exceptional condition''\n\
1705 If only one kind of condition is required, pass [] for the other lists.\n\
1706 A file descriptor is either a socket or file object, or a small integer\n\
1707 gotten from a fileno() method call on one of those.\n\
1709 The optional 4th argument specifies a timeout in seconds; it may be\n\
1710 a floating point number to specify fractions of seconds. If it is absent\n\
1711 or None, the call will never time out.\n\
1713 The return value is a tuple of three lists corresponding to the first three\n\
1714 arguments; each contains the subset of the corresponding file descriptors\n\
1717 *** IMPORTANT NOTICE ***\n\
1718 On Windows and OpenVMS, only sockets are supported; on Unix, all file\n\
1719 descriptors can be used.");
1721 static PyMethodDef select_methods
[] = {
1722 {"select", select_select
, METH_VARARGS
, select_doc
},
1724 {"poll", select_poll
, METH_NOARGS
, poll_doc
},
1725 #endif /* HAVE_POLL */
1726 {0, 0}, /* sentinel */
1729 PyDoc_STRVAR(module_doc
,
1730 "This module supports asynchronous I/O on multiple file descriptors.\n\
1732 *** IMPORTANT NOTICE ***\n\
1733 On Windows and OpenVMS, only sockets are supported; on Unix, all file descriptors.");
1739 m
= Py_InitModule3("select", select_methods
, module_doc
);
1743 SelectError
= PyErr_NewException("select.error", NULL
, NULL
);
1744 Py_INCREF(SelectError
);
1745 PyModule_AddObject(m
, "error", SelectError
);
1747 #if defined(HAVE_POLL)
1749 if (select_have_broken_poll()) {
1750 if (PyObject_DelAttrString(m
, "poll") == -1) {
1757 Py_TYPE(&poll_Type
) = &PyType_Type
;
1758 PyModule_AddIntConstant(m
, "POLLIN", POLLIN
);
1759 PyModule_AddIntConstant(m
, "POLLPRI", POLLPRI
);
1760 PyModule_AddIntConstant(m
, "POLLOUT", POLLOUT
);
1761 PyModule_AddIntConstant(m
, "POLLERR", POLLERR
);
1762 PyModule_AddIntConstant(m
, "POLLHUP", POLLHUP
);
1763 PyModule_AddIntConstant(m
, "POLLNVAL", POLLNVAL
);
1766 PyModule_AddIntConstant(m
, "POLLRDNORM", POLLRDNORM
);
1769 PyModule_AddIntConstant(m
, "POLLRDBAND", POLLRDBAND
);
1772 PyModule_AddIntConstant(m
, "POLLWRNORM", POLLWRNORM
);
1775 PyModule_AddIntConstant(m
, "POLLWRBAND", POLLWRBAND
);
1778 PyModule_AddIntConstant(m
, "POLLMSG", POLLMSG
);
1781 #endif /* HAVE_POLL */
1784 Py_TYPE(&pyEpoll_Type
) = &PyType_Type
;
1785 if (PyType_Ready(&pyEpoll_Type
) < 0)
1788 Py_INCREF(&pyEpoll_Type
);
1789 PyModule_AddObject(m
, "epoll", (PyObject
*) &pyEpoll_Type
);
1791 PyModule_AddIntConstant(m
, "EPOLLIN", EPOLLIN
);
1792 PyModule_AddIntConstant(m
, "EPOLLOUT", EPOLLOUT
);
1793 PyModule_AddIntConstant(m
, "EPOLLPRI", EPOLLPRI
);
1794 PyModule_AddIntConstant(m
, "EPOLLERR", EPOLLERR
);
1795 PyModule_AddIntConstant(m
, "EPOLLHUP", EPOLLHUP
);
1796 PyModule_AddIntConstant(m
, "EPOLLET", EPOLLET
);
1799 PyModule_AddIntConstant(m
, "EPOLLONESHOT", EPOLLONESHOT
);
1801 /* PyModule_AddIntConstant(m, "EPOLL_RDHUP", EPOLLRDHUP); */
1802 PyModule_AddIntConstant(m
, "EPOLLRDNORM", EPOLLRDNORM
);
1803 PyModule_AddIntConstant(m
, "EPOLLRDBAND", EPOLLRDBAND
);
1804 PyModule_AddIntConstant(m
, "EPOLLWRNORM", EPOLLWRNORM
);
1805 PyModule_AddIntConstant(m
, "EPOLLWRBAND", EPOLLWRBAND
);
1806 PyModule_AddIntConstant(m
, "EPOLLMSG", EPOLLMSG
);
1807 #endif /* HAVE_EPOLL */
1810 kqueue_event_Type
.tp_new
= PyType_GenericNew
;
1811 Py_TYPE(&kqueue_event_Type
) = &PyType_Type
;
1812 if(PyType_Ready(&kqueue_event_Type
) < 0)
1815 Py_INCREF(&kqueue_event_Type
);
1816 PyModule_AddObject(m
, "kevent", (PyObject
*)&kqueue_event_Type
);
1818 Py_TYPE(&kqueue_queue_Type
) = &PyType_Type
;
1819 if(PyType_Ready(&kqueue_queue_Type
) < 0)
1821 Py_INCREF(&kqueue_queue_Type
);
1822 PyModule_AddObject(m
, "kqueue", (PyObject
*)&kqueue_queue_Type
);
1825 PyModule_AddIntConstant(m
, "KQ_FILTER_READ", EVFILT_READ
);
1826 PyModule_AddIntConstant(m
, "KQ_FILTER_WRITE", EVFILT_WRITE
);
1827 PyModule_AddIntConstant(m
, "KQ_FILTER_AIO", EVFILT_AIO
);
1828 PyModule_AddIntConstant(m
, "KQ_FILTER_VNODE", EVFILT_VNODE
);
1829 PyModule_AddIntConstant(m
, "KQ_FILTER_PROC", EVFILT_PROC
);
1830 #ifdef EVFILT_NETDEV
1831 PyModule_AddIntConstant(m
, "KQ_FILTER_NETDEV", EVFILT_NETDEV
);
1833 PyModule_AddIntConstant(m
, "KQ_FILTER_SIGNAL", EVFILT_SIGNAL
);
1834 PyModule_AddIntConstant(m
, "KQ_FILTER_TIMER", EVFILT_TIMER
);
1837 PyModule_AddIntConstant(m
, "KQ_EV_ADD", EV_ADD
);
1838 PyModule_AddIntConstant(m
, "KQ_EV_DELETE", EV_DELETE
);
1839 PyModule_AddIntConstant(m
, "KQ_EV_ENABLE", EV_ENABLE
);
1840 PyModule_AddIntConstant(m
, "KQ_EV_DISABLE", EV_DISABLE
);
1841 PyModule_AddIntConstant(m
, "KQ_EV_ONESHOT", EV_ONESHOT
);
1842 PyModule_AddIntConstant(m
, "KQ_EV_CLEAR", EV_CLEAR
);
1844 PyModule_AddIntConstant(m
, "KQ_EV_SYSFLAGS", EV_SYSFLAGS
);
1845 PyModule_AddIntConstant(m
, "KQ_EV_FLAG1", EV_FLAG1
);
1847 PyModule_AddIntConstant(m
, "KQ_EV_EOF", EV_EOF
);
1848 PyModule_AddIntConstant(m
, "KQ_EV_ERROR", EV_ERROR
);
1850 /* READ WRITE filter flag */
1851 PyModule_AddIntConstant(m
, "KQ_NOTE_LOWAT", NOTE_LOWAT
);
1853 /* VNODE filter flags */
1854 PyModule_AddIntConstant(m
, "KQ_NOTE_DELETE", NOTE_DELETE
);
1855 PyModule_AddIntConstant(m
, "KQ_NOTE_WRITE", NOTE_WRITE
);
1856 PyModule_AddIntConstant(m
, "KQ_NOTE_EXTEND", NOTE_EXTEND
);
1857 PyModule_AddIntConstant(m
, "KQ_NOTE_ATTRIB", NOTE_ATTRIB
);
1858 PyModule_AddIntConstant(m
, "KQ_NOTE_LINK", NOTE_LINK
);
1859 PyModule_AddIntConstant(m
, "KQ_NOTE_RENAME", NOTE_RENAME
);
1860 PyModule_AddIntConstant(m
, "KQ_NOTE_REVOKE", NOTE_REVOKE
);
1862 /* PROC filter flags */
1863 PyModule_AddIntConstant(m
, "KQ_NOTE_EXIT", NOTE_EXIT
);
1864 PyModule_AddIntConstant(m
, "KQ_NOTE_FORK", NOTE_FORK
);
1865 PyModule_AddIntConstant(m
, "KQ_NOTE_EXEC", NOTE_EXEC
);
1866 PyModule_AddIntConstant(m
, "KQ_NOTE_PCTRLMASK", NOTE_PCTRLMASK
);
1867 PyModule_AddIntConstant(m
, "KQ_NOTE_PDATAMASK", NOTE_PDATAMASK
);
1869 PyModule_AddIntConstant(m
, "KQ_NOTE_TRACK", NOTE_TRACK
);
1870 PyModule_AddIntConstant(m
, "KQ_NOTE_CHILD", NOTE_CHILD
);
1871 PyModule_AddIntConstant(m
, "KQ_NOTE_TRACKERR", NOTE_TRACKERR
);
1873 /* NETDEV filter flags */
1874 #ifdef EVFILT_NETDEV
1875 PyModule_AddIntConstant(m
, "KQ_NOTE_LINKUP", NOTE_LINKUP
);
1876 PyModule_AddIntConstant(m
, "KQ_NOTE_LINKDOWN", NOTE_LINKDOWN
);
1877 PyModule_AddIntConstant(m
, "KQ_NOTE_LINKINV", NOTE_LINKINV
);
1880 #endif /* HAVE_KQUEUE */