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)
50 # include <winsock2.h>
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) && !defined(UEFI_ENV)
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
)) {
167 #if !defined(_MSC_VER) || defined(UEFI_ENV)
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
);
291 /* any of these three calls can raise an exception. it's more
292 convenient to test for this after all three calls... but
295 ifdlist
= set2list(&ifdset
, rfd2obj
);
296 ofdlist
= set2list(&ofdset
, wfd2obj
);
297 efdlist
= set2list(&efdset
, efd2obj
);
298 if (PyErr_Occurred())
301 ret
= PyTuple_Pack(3, ifdlist
, ofdlist
, efdlist
);
312 #ifdef SELECT_USES_HEAP
316 #endif /* SELECT_USES_HEAP */
320 #if defined(HAVE_POLL) && !defined(HAVE_BROKEN_POLL)
333 static PyTypeObject poll_Type
;
335 /* Update the malloc'ed array of pollfds to match the dictionary
336 contained within a pollObject. Return 1 on success, 0 on an error.
340 update_ufd_array(pollObject
*self
)
343 PyObject
*key
, *value
;
344 struct pollfd
*old_ufds
= self
->ufds
;
346 self
->ufd_len
= PyDict_Size(self
->dict
);
347 PyMem_RESIZE(self
->ufds
, struct pollfd
, self
->ufd_len
);
348 if (self
->ufds
== NULL
) {
349 self
->ufds
= old_ufds
;
355 while (PyDict_Next(self
->dict
, &pos
, &key
, &value
)) {
356 self
->ufds
[i
].fd
= PyInt_AsLong(key
);
357 self
->ufds
[i
].events
= (short)PyInt_AsLong(value
);
360 self
->ufd_uptodate
= 1;
364 PyDoc_STRVAR(poll_register_doc
,
365 "register(fd [, eventmask] ) -> None\n\n\
366 Register a file descriptor with the polling object.\n\
367 fd -- either an integer, or an object with a fileno() method returning an\n\
369 events -- an optional bitmask describing the type of events to check for");
372 poll_register(pollObject
*self
, PyObject
*args
)
374 PyObject
*o
, *key
, *value
;
375 int fd
, events
= POLLIN
| POLLPRI
| POLLOUT
;
378 if (!PyArg_ParseTuple(args
, "O|i:register", &o
, &events
)) {
382 fd
= PyObject_AsFileDescriptor(o
);
383 if (fd
== -1) return NULL
;
385 /* Add entry to the internal dictionary: the key is the
386 file descriptor, and the value is the event mask. */
387 key
= PyInt_FromLong(fd
);
390 value
= PyInt_FromLong(events
);
395 err
= PyDict_SetItem(self
->dict
, key
, value
);
401 self
->ufd_uptodate
= 0;
407 PyDoc_STRVAR(poll_modify_doc
,
408 "modify(fd, eventmask) -> None\n\n\
409 Modify an already registered file descriptor.\n\
410 fd -- either an integer, or an object with a fileno() method returning an\n\
412 events -- an optional bitmask describing the type of events to check for");
415 poll_modify(pollObject
*self
, PyObject
*args
)
417 PyObject
*o
, *key
, *value
;
421 if (!PyArg_ParseTuple(args
, "Oi:modify", &o
, &events
)) {
425 fd
= PyObject_AsFileDescriptor(o
);
426 if (fd
== -1) return NULL
;
428 /* Modify registered fd */
429 key
= PyInt_FromLong(fd
);
432 if (PyDict_GetItem(self
->dict
, key
) == NULL
) {
434 PyErr_SetFromErrno(PyExc_IOError
);
437 value
= PyInt_FromLong(events
);
442 err
= PyDict_SetItem(self
->dict
, key
, value
);
448 self
->ufd_uptodate
= 0;
455 PyDoc_STRVAR(poll_unregister_doc
,
456 "unregister(fd) -> None\n\n\
457 Remove a file descriptor being tracked by the polling object.");
460 poll_unregister(pollObject
*self
, PyObject
*o
)
465 fd
= PyObject_AsFileDescriptor( o
);
469 /* Check whether the fd is already in the array */
470 key
= PyInt_FromLong(fd
);
474 if (PyDict_DelItem(self
->dict
, key
) == -1) {
476 /* This will simply raise the KeyError set by PyDict_DelItem
477 if the file descriptor isn't registered. */
482 self
->ufd_uptodate
= 0;
488 PyDoc_STRVAR(poll_poll_doc
,
489 "poll( [timeout] ) -> list of (fd, event) 2-tuples\n\n\
490 Polls the set of registered file descriptors, returning a list containing \n\
491 any descriptors that have events or errors to report.");
494 poll_poll(pollObject
*self
, PyObject
*args
)
496 PyObject
*result_list
= NULL
, *tout
= NULL
;
497 int timeout
= 0, poll_result
, i
, j
;
498 PyObject
*value
= NULL
, *num
= NULL
;
500 if (!PyArg_UnpackTuple(args
, "poll", 0, 1, &tout
)) {
504 /* Check values for timeout */
505 if (tout
== NULL
|| tout
== Py_None
)
507 else if (!PyNumber_Check(tout
)) {
508 PyErr_SetString(PyExc_TypeError
,
509 "timeout must be an integer or None");
513 tout
= PyNumber_Int(tout
);
516 timeout
= PyInt_AsLong(tout
);
518 if (timeout
== -1 && PyErr_Occurred())
522 /* Ensure the ufd array is up to date */
523 if (!self
->ufd_uptodate
)
524 if (update_ufd_array(self
) == 0)
528 Py_BEGIN_ALLOW_THREADS
529 poll_result
= poll(self
->ufds
, self
->ufd_len
, timeout
);
532 if (poll_result
< 0) {
533 PyErr_SetFromErrno(SelectError
);
537 /* build the result list */
539 result_list
= PyList_New(poll_result
);
543 for (i
= 0, j
= 0; j
< poll_result
; j
++) {
544 /* skip to the next fired descriptor */
545 while (!self
->ufds
[i
].revents
) {
548 /* if we hit a NULL return, set value to NULL
549 and break out of loop; code at end will
550 clean up result_list */
551 value
= PyTuple_New(2);
554 num
= PyInt_FromLong(self
->ufds
[i
].fd
);
559 PyTuple_SET_ITEM(value
, 0, num
);
561 /* The &0xffff is a workaround for AIX. 'revents'
562 is a 16-bit short, and IBM assigned POLLNVAL
563 to be 0x8000, so the conversion to int results
564 in a negative number. See SF bug #923315. */
565 num
= PyInt_FromLong(self
->ufds
[i
].revents
& 0xffff);
570 PyTuple_SET_ITEM(value
, 1, num
);
571 if ((PyList_SetItem(result_list
, j
, value
)) == -1) {
581 Py_DECREF(result_list
);
585 static PyMethodDef poll_methods
[] = {
586 {"register", (PyCFunction
)poll_register
,
587 METH_VARARGS
, poll_register_doc
},
588 {"modify", (PyCFunction
)poll_modify
,
589 METH_VARARGS
, poll_modify_doc
},
590 {"unregister", (PyCFunction
)poll_unregister
,
591 METH_O
, poll_unregister_doc
},
592 {"poll", (PyCFunction
)poll_poll
,
593 METH_VARARGS
, poll_poll_doc
},
594 {NULL
, NULL
} /* sentinel */
601 self
= PyObject_New(pollObject
, &poll_Type
);
604 /* ufd_uptodate is a Boolean, denoting whether the
605 array pointed to by ufds matches the contents of the dictionary. */
606 self
->ufd_uptodate
= 0;
608 self
->dict
= PyDict_New();
609 if (self
->dict
== NULL
) {
617 poll_dealloc(pollObject
*self
)
619 if (self
->ufds
!= NULL
)
620 PyMem_DEL(self
->ufds
);
621 Py_XDECREF(self
->dict
);
626 poll_getattr(pollObject
*self
, char *name
)
628 return Py_FindMethod(poll_methods
, (PyObject
*)self
, name
);
631 static PyTypeObject poll_Type
= {
632 /* The ob_type field must be initialized in the module init function
633 * to be portable to Windows without using C++. */
634 PyVarObject_HEAD_INIT(NULL
, 0)
635 "select.poll", /*tp_name*/
636 sizeof(pollObject
), /*tp_basicsize*/
639 (destructor
)poll_dealloc
, /*tp_dealloc*/
641 (getattrfunc
)poll_getattr
, /*tp_getattr*/
646 0, /*tp_as_sequence*/
651 PyDoc_STRVAR(poll_doc
,
652 "Returns a polling object, which supports registering and\n\
653 unregistering file descriptors, and then polling them for I/O events.");
656 select_poll(PyObject
*self
, PyObject
*unused
)
658 return (PyObject
*)newPollObject();
663 * On some systems poll() sets errno on invalid file descriptors. We test
664 * for this at runtime because this bug may be fixed or introduced between
667 static int select_have_broken_poll(void)
672 struct pollfd poll_struct
= { 0, POLLIN
|POLLPRI
|POLLOUT
, 0 };
674 /* Create a file descriptor to make invalid */
675 if (pipe(filedes
) < 0) {
678 poll_struct
.fd
= filedes
[0];
681 poll_test
= poll(&poll_struct
, 1, 0);
684 } else if (poll_test
== 0 && poll_struct
.revents
!= POLLNVAL
) {
689 #endif /* __APPLE__ */
691 #endif /* HAVE_POLL */
694 /* **************************************************************************
695 * epoll interface for Linux 2.6
697 * Written by Christian Heimes
698 * Inspired by Twisted's _epoll.pyx and select.poll()
701 #ifdef HAVE_SYS_EPOLL_H
702 #include <sys/epoll.h>
707 SOCKET epfd
; /* epoll control file descriptor */
710 static PyTypeObject pyEpoll_Type
;
711 #define pyepoll_CHECK(op) (PyObject_TypeCheck((op), &pyEpoll_Type))
714 pyepoll_err_closed(void)
716 PyErr_SetString(PyExc_ValueError
, "I/O operation on closed epoll fd");
721 pyepoll_internal_close(pyEpoll_Object
*self
)
724 if (self
->epfd
>= 0) {
725 int epfd
= self
->epfd
;
727 Py_BEGIN_ALLOW_THREADS
736 newPyEpoll_Object(PyTypeObject
*type
, int sizehint
, SOCKET fd
)
738 pyEpoll_Object
*self
;
740 if (sizehint
== -1) {
741 sizehint
= FD_SETSIZE
-1;
743 else if (sizehint
< 1) {
744 PyErr_Format(PyExc_ValueError
,
745 "sizehint must be greater zero, got %d",
750 assert(type
!= NULL
&& type
->tp_alloc
!= NULL
);
751 self
= (pyEpoll_Object
*) type
->tp_alloc(type
, 0);
756 Py_BEGIN_ALLOW_THREADS
757 self
->epfd
= epoll_create(sizehint
);
763 if (self
->epfd
< 0) {
765 PyErr_SetFromErrno(PyExc_IOError
);
768 return (PyObject
*)self
;
773 pyepoll_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
776 static char *kwlist
[] = {"sizehint", NULL
};
778 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "|i:epoll", kwlist
,
782 return newPyEpoll_Object(type
, sizehint
, -1);
787 pyepoll_dealloc(pyEpoll_Object
*self
)
789 (void)pyepoll_internal_close(self
);
790 Py_TYPE(self
)->tp_free(self
);
794 pyepoll_close(pyEpoll_Object
*self
)
796 errno
= pyepoll_internal_close(self
);
798 PyErr_SetFromErrno(PyExc_IOError
);
804 PyDoc_STRVAR(pyepoll_close_doc
,
807 Close the epoll control file descriptor. Further operations on the epoll\n\
808 object will raise an exception.");
811 pyepoll_get_closed(pyEpoll_Object
*self
)
820 pyepoll_fileno(pyEpoll_Object
*self
)
823 return pyepoll_err_closed();
824 return PyInt_FromLong(self
->epfd
);
827 PyDoc_STRVAR(pyepoll_fileno_doc
,
830 Return the epoll control file descriptor.");
833 pyepoll_fromfd(PyObject
*cls
, PyObject
*args
)
837 if (!PyArg_ParseTuple(args
, "i:fromfd", &fd
))
840 return newPyEpoll_Object((PyTypeObject
*)cls
, -1, fd
);
843 PyDoc_STRVAR(pyepoll_fromfd_doc
,
844 "fromfd(fd) -> epoll\n\
846 Create an epoll object from a given control fd.");
849 pyepoll_internal_ctl(int epfd
, int op
, PyObject
*pfd
, unsigned int events
)
851 struct epoll_event ev
;
856 return pyepoll_err_closed();
858 fd
= PyObject_AsFileDescriptor(pfd
);
868 Py_BEGIN_ALLOW_THREADS
869 result
= epoll_ctl(epfd
, op
, fd
, &ev
);
873 /* In kernel versions before 2.6.9, the EPOLL_CTL_DEL
874 * operation required a non-NULL pointer in event, even
875 * though this argument is ignored. */
876 Py_BEGIN_ALLOW_THREADS
877 result
= epoll_ctl(epfd
, op
, fd
, &ev
);
878 if (errno
== EBADF
) {
879 /* fd already closed */
891 PyErr_SetFromErrno(PyExc_IOError
);
898 pyepoll_register(pyEpoll_Object
*self
, PyObject
*args
, PyObject
*kwds
)
901 unsigned int events
= EPOLLIN
| EPOLLOUT
| EPOLLPRI
;
902 static char *kwlist
[] = {"fd", "eventmask", NULL
};
904 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "O|I:register", kwlist
,
909 return pyepoll_internal_ctl(self
->epfd
, EPOLL_CTL_ADD
, pfd
, events
);
912 PyDoc_STRVAR(pyepoll_register_doc
,
913 "register(fd[, eventmask]) -> None\n\
915 Registers a new fd or modifies an already registered fd.\n\
916 fd is the target file descriptor of the operation.\n\
917 events is a bit set composed of the various EPOLL constants; the default\n\
918 is EPOLL_IN | EPOLL_OUT | EPOLL_PRI.\n\
920 The epoll interface supports all file descriptors that support poll.");
923 pyepoll_modify(pyEpoll_Object
*self
, PyObject
*args
, PyObject
*kwds
)
927 static char *kwlist
[] = {"fd", "eventmask", NULL
};
929 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "OI:modify", kwlist
,
934 return pyepoll_internal_ctl(self
->epfd
, EPOLL_CTL_MOD
, pfd
, events
);
937 PyDoc_STRVAR(pyepoll_modify_doc
,
938 "modify(fd, eventmask) -> None\n\
940 fd is the target file descriptor of the operation\n\
941 events is a bit set composed of the various EPOLL constants");
944 pyepoll_unregister(pyEpoll_Object
*self
, PyObject
*args
, PyObject
*kwds
)
947 static char *kwlist
[] = {"fd", NULL
};
949 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "O:unregister", kwlist
,
954 return pyepoll_internal_ctl(self
->epfd
, EPOLL_CTL_DEL
, pfd
, 0);
957 PyDoc_STRVAR(pyepoll_unregister_doc
,
958 "unregister(fd) -> None\n\
960 fd is the target file descriptor of the operation.");
963 pyepoll_poll(pyEpoll_Object
*self
, PyObject
*args
, PyObject
*kwds
)
965 double dtimeout
= -1.;
969 PyObject
*elist
= NULL
, *etuple
= NULL
;
970 struct epoll_event
*evs
= NULL
;
971 static char *kwlist
[] = {"timeout", "maxevents", NULL
};
974 return pyepoll_err_closed();
976 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "|di:poll", kwlist
,
977 &dtimeout
, &maxevents
)) {
984 else if (dtimeout
* 1000.0 > INT_MAX
) {
985 PyErr_SetString(PyExc_OverflowError
,
986 "timeout is too large");
990 timeout
= (int)(dtimeout
* 1000.0);
993 if (maxevents
== -1) {
994 maxevents
= FD_SETSIZE
-1;
996 else if (maxevents
< 1) {
997 PyErr_Format(PyExc_ValueError
,
998 "maxevents must be greater than 0, got %d",
1003 evs
= PyMem_New(struct epoll_event
, maxevents
);
1010 Py_BEGIN_ALLOW_THREADS
1011 nfds
= epoll_wait(self
->epfd
, evs
, maxevents
, timeout
);
1012 Py_END_ALLOW_THREADS
1014 PyErr_SetFromErrno(PyExc_IOError
);
1018 elist
= PyList_New(nfds
);
1019 if (elist
== NULL
) {
1023 for (i
= 0; i
< nfds
; i
++) {
1024 etuple
= Py_BuildValue("iI", evs
[i
].data
.fd
, evs
[i
].events
);
1025 if (etuple
== NULL
) {
1029 PyList_SET_ITEM(elist
, i
, etuple
);
1037 PyDoc_STRVAR(pyepoll_poll_doc
,
1038 "poll([timeout=-1[, maxevents=-1]]) -> [(fd, events), (...)]\n\
1040 Wait for events on the epoll file descriptor for a maximum time of timeout\n\
1041 in seconds (as float). -1 makes poll wait indefinitely.\n\
1042 Up to maxevents are returned to the caller.");
1044 static PyMethodDef pyepoll_methods
[] = {
1045 {"fromfd", (PyCFunction
)pyepoll_fromfd
,
1046 METH_VARARGS
| METH_CLASS
, pyepoll_fromfd_doc
},
1047 {"close", (PyCFunction
)pyepoll_close
, METH_NOARGS
,
1049 {"fileno", (PyCFunction
)pyepoll_fileno
, METH_NOARGS
,
1050 pyepoll_fileno_doc
},
1051 {"modify", (PyCFunction
)pyepoll_modify
,
1052 METH_VARARGS
| METH_KEYWORDS
, pyepoll_modify_doc
},
1053 {"register", (PyCFunction
)pyepoll_register
,
1054 METH_VARARGS
| METH_KEYWORDS
, pyepoll_register_doc
},
1055 {"unregister", (PyCFunction
)pyepoll_unregister
,
1056 METH_VARARGS
| METH_KEYWORDS
, pyepoll_unregister_doc
},
1057 {"poll", (PyCFunction
)pyepoll_poll
,
1058 METH_VARARGS
| METH_KEYWORDS
, pyepoll_poll_doc
},
1062 static PyGetSetDef pyepoll_getsetlist
[] = {
1063 {"closed", (getter
)pyepoll_get_closed
, NULL
,
1064 "True if the epoll handler is closed"},
1068 PyDoc_STRVAR(pyepoll_doc
,
1069 "select.epoll([sizehint=-1])\n\
1071 Returns an epolling object\n\
1073 sizehint must be a positive integer or -1 for the default size. The\n\
1074 sizehint is used to optimize internal data structures. It doesn't limit\n\
1075 the maximum number of monitored events.");
1077 static PyTypeObject pyEpoll_Type
= {
1078 PyVarObject_HEAD_INIT(NULL
, 0)
1079 "select.epoll", /* tp_name */
1080 sizeof(pyEpoll_Object
), /* tp_basicsize */
1081 0, /* tp_itemsize */
1082 (destructor
)pyepoll_dealloc
, /* tp_dealloc */
1088 0, /* tp_as_number */
1089 0, /* tp_as_sequence */
1090 0, /* tp_as_mapping */
1094 PyObject_GenericGetAttr
, /* tp_getattro */
1095 0, /* tp_setattro */
1096 0, /* tp_as_buffer */
1097 Py_TPFLAGS_DEFAULT
, /* tp_flags */
1098 pyepoll_doc
, /* tp_doc */
1099 0, /* tp_traverse */
1101 0, /* tp_richcompare */
1102 0, /* tp_weaklistoffset */
1104 0, /* tp_iternext */
1105 pyepoll_methods
, /* tp_methods */
1107 pyepoll_getsetlist
, /* tp_getset */
1110 0, /* tp_descr_get */
1111 0, /* tp_descr_set */
1112 0, /* tp_dictoffset */
1115 pyepoll_new
, /* tp_new */
1119 #endif /* HAVE_EPOLL */
1122 /* **************************************************************************
1123 * kqueue interface for BSD
1125 * Copyright (c) 2000 Doug White, 2006 James Knight, 2007 Christian Heimes
1126 * All rights reserved.
1128 * Redistribution and use in source and binary forms, with or without
1129 * modification, are permitted provided that the following conditions
1131 * 1. Redistributions of source code must retain the above copyright
1132 * notice, this list of conditions and the following disclaimer.
1133 * 2. Redistributions in binary form must reproduce the above copyright
1134 * notice, this list of conditions and the following disclaimer in the
1135 * documentation and/or other materials provided with the distribution.
1137 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
1138 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1139 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1140 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
1141 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1142 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1143 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1144 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1145 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1146 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1150 #ifdef HAVE_SYS_EVENT_H
1151 #include <sys/event.h>
1154 PyDoc_STRVAR(kqueue_event_doc
,
1155 "kevent(ident, filter=KQ_FILTER_READ, flags=KQ_EV_ADD, fflags=0, data=0, udata=0)\n\
1157 This object is the equivalent of the struct kevent for the C API.\n\
1159 See the kqueue manpage for more detailed information about the meaning\n\
1160 of the arguments.\n\
1162 One minor note: while you might hope that udata could store a\n\
1163 reference to a python object, it cannot, because it is impossible to\n\
1164 keep a proper reference count of the object once it's passed into the\n\
1165 kernel. Therefore, I have restricted it to only storing an integer. I\n\
1166 recommend ignoring it and simply using the 'ident' field to key off\n\
1167 of. You could also set up a dictionary on the python side to store a\n\
1168 udata->object mapping.");
1173 } kqueue_event_Object
;
1175 static PyTypeObject kqueue_event_Type
;
1177 #define kqueue_event_Check(op) (PyObject_TypeCheck((op), &kqueue_event_Type))
1181 SOCKET kqfd
; /* kqueue control fd */
1182 } kqueue_queue_Object
;
1184 static PyTypeObject kqueue_queue_Type
;
1186 #define kqueue_queue_Check(op) (PyObject_TypeCheck((op), &kqueue_queue_Type))
1188 #if (SIZEOF_UINTPTR_T != SIZEOF_VOID_P)
1189 # error uintptr_t does not match void *!
1190 #elif (SIZEOF_UINTPTR_T == SIZEOF_LONG_LONG)
1191 # define T_UINTPTRT T_ULONGLONG
1192 # define T_INTPTRT T_LONGLONG
1193 # define PyLong_AsUintptr_t PyLong_AsUnsignedLongLong
1194 # define UINTPTRT_FMT_UNIT "K"
1195 # define INTPTRT_FMT_UNIT "L"
1196 #elif (SIZEOF_UINTPTR_T == SIZEOF_LONG)
1197 # define T_UINTPTRT T_ULONG
1198 # define T_INTPTRT T_LONG
1199 # define PyLong_AsUintptr_t PyLong_AsUnsignedLong
1200 # define UINTPTRT_FMT_UNIT "k"
1201 # define INTPTRT_FMT_UNIT "l"
1202 #elif (SIZEOF_UINTPTR_T == SIZEOF_INT)
1203 # define T_UINTPTRT T_UINT
1204 # define T_INTPTRT T_INT
1205 # define PyLong_AsUintptr_t PyLong_AsUnsignedLong
1206 # define UINTPTRT_FMT_UNIT "I"
1207 # define INTPTRT_FMT_UNIT "i"
1209 # error uintptr_t does not match int, long, or long long!
1212 /* Unfortunately, we can't store python objects in udata, because
1213 * kevents in the kernel can be removed without warning, which would
1214 * forever lose the refcount on the object stored with it.
1217 #define KQ_OFF(x) offsetof(kqueue_event_Object, x)
1218 static struct PyMemberDef kqueue_event_members
[] = {
1219 {"ident", T_UINTPTRT
, KQ_OFF(e
.ident
)},
1220 {"filter", T_SHORT
, KQ_OFF(e
.filter
)},
1221 {"flags", T_USHORT
, KQ_OFF(e
.flags
)},
1222 {"fflags", T_UINT
, KQ_OFF(e
.fflags
)},
1223 {"data", T_INTPTRT
, KQ_OFF(e
.data
)},
1224 {"udata", T_UINTPTRT
, KQ_OFF(e
.udata
)},
1225 {NULL
} /* Sentinel */
1231 kqueue_event_repr(kqueue_event_Object
*s
)
1236 "<select.kevent ident=%zu filter=%d flags=0x%x fflags=0x%x "
1237 "data=0x%zd udata=%p>",
1238 (size_t)(s
->e
.ident
), s
->e
.filter
, s
->e
.flags
,
1239 s
->e
.fflags
, (Py_ssize_t
)(s
->e
.data
), s
->e
.udata
);
1240 return PyString_FromString(buf
);
1244 kqueue_event_init(kqueue_event_Object
*self
, PyObject
*args
, PyObject
*kwds
)
1247 static char *kwlist
[] = {"ident", "filter", "flags", "fflags",
1248 "data", "udata", NULL
};
1249 static char *fmt
= "O|hhi" INTPTRT_FMT_UNIT UINTPTRT_FMT_UNIT
":kevent";
1251 EV_SET(&(self
->e
), 0, EVFILT_READ
, EV_ADD
, 0, 0, 0); /* defaults */
1253 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, fmt
, kwlist
,
1254 &pfd
, &(self
->e
.filter
), &(self
->e
.flags
),
1255 &(self
->e
.fflags
), &(self
->e
.data
), &(self
->e
.udata
))) {
1259 if (PyLong_Check(pfd
)) {
1260 self
->e
.ident
= PyLong_AsUintptr_t(pfd
);
1263 self
->e
.ident
= PyObject_AsFileDescriptor(pfd
);
1265 if (PyErr_Occurred()) {
1272 kqueue_event_richcompare(kqueue_event_Object
*s
, kqueue_event_Object
*o
,
1275 Py_intptr_t result
= 0;
1277 if (!kqueue_event_Check(o
)) {
1278 if (op
== Py_EQ
|| op
== Py_NE
) {
1279 PyObject
*res
= op
== Py_EQ
? Py_False
: Py_True
;
1283 PyErr_Format(PyExc_TypeError
,
1284 "can't compare %.200s to %.200s",
1285 Py_TYPE(s
)->tp_name
, Py_TYPE(o
)->tp_name
);
1288 if (((result
= s
->e
.ident
- o
->e
.ident
) == 0) &&
1289 ((result
= s
->e
.filter
- o
->e
.filter
) == 0) &&
1290 ((result
= s
->e
.flags
- o
->e
.flags
) == 0) &&
1291 ((result
= s
->e
.fflags
- o
->e
.fflags
) == 0) &&
1292 ((result
= s
->e
.data
- o
->e
.data
) == 0) &&
1293 ((result
= s
->e
.udata
- o
->e
.udata
) == 0)
1300 result
= (result
== 0);
1303 result
= (result
!= 0);
1306 result
= (result
<= 0);
1309 result
= (result
>= 0);
1312 result
= (result
< 0);
1315 result
= (result
> 0);
1318 return PyBool_FromLong((long)result
);
1321 static PyTypeObject kqueue_event_Type
= {
1322 PyVarObject_HEAD_INIT(NULL
, 0)
1323 "select.kevent", /* tp_name */
1324 sizeof(kqueue_event_Object
), /* tp_basicsize */
1325 0, /* tp_itemsize */
1331 (reprfunc
)kqueue_event_repr
, /* tp_repr */
1332 0, /* tp_as_number */
1333 0, /* tp_as_sequence */
1334 0, /* tp_as_mapping */
1338 0, /* tp_getattro */
1339 0, /* tp_setattro */
1340 0, /* tp_as_buffer */
1341 Py_TPFLAGS_DEFAULT
, /* tp_flags */
1342 kqueue_event_doc
, /* tp_doc */
1343 0, /* tp_traverse */
1345 (richcmpfunc
)kqueue_event_richcompare
, /* tp_richcompare */
1346 0, /* tp_weaklistoffset */
1348 0, /* tp_iternext */
1350 kqueue_event_members
, /* tp_members */
1354 0, /* tp_descr_get */
1355 0, /* tp_descr_set */
1356 0, /* tp_dictoffset */
1357 (initproc
)kqueue_event_init
, /* tp_init */
1364 kqueue_queue_err_closed(void)
1366 PyErr_SetString(PyExc_ValueError
, "I/O operation on closed kqueue fd");
1371 kqueue_queue_internal_close(kqueue_queue_Object
*self
)
1374 if (self
->kqfd
>= 0) {
1375 int kqfd
= self
->kqfd
;
1377 Py_BEGIN_ALLOW_THREADS
1378 if (close(kqfd
) < 0)
1380 Py_END_ALLOW_THREADS
1386 newKqueue_Object(PyTypeObject
*type
, SOCKET fd
)
1388 kqueue_queue_Object
*self
;
1389 assert(type
!= NULL
&& type
->tp_alloc
!= NULL
);
1390 self
= (kqueue_queue_Object
*) type
->tp_alloc(type
, 0);
1396 Py_BEGIN_ALLOW_THREADS
1397 self
->kqfd
= kqueue();
1398 Py_END_ALLOW_THREADS
1403 if (self
->kqfd
< 0) {
1405 PyErr_SetFromErrno(PyExc_IOError
);
1408 return (PyObject
*)self
;
1412 kqueue_queue_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
1415 if ((args
!= NULL
&& PyObject_Size(args
)) ||
1416 (kwds
!= NULL
&& PyObject_Size(kwds
))) {
1417 PyErr_SetString(PyExc_ValueError
,
1418 "select.kqueue doesn't accept arguments");
1422 return newKqueue_Object(type
, -1);
1426 kqueue_queue_dealloc(kqueue_queue_Object
*self
)
1428 kqueue_queue_internal_close(self
);
1429 Py_TYPE(self
)->tp_free(self
);
1433 kqueue_queue_close(kqueue_queue_Object
*self
)
1435 errno
= kqueue_queue_internal_close(self
);
1437 PyErr_SetFromErrno(PyExc_IOError
);
1443 PyDoc_STRVAR(kqueue_queue_close_doc
,
1446 Close the kqueue control file descriptor. Further operations on the kqueue\n\
1447 object will raise an exception.");
1450 kqueue_queue_get_closed(kqueue_queue_Object
*self
)
1459 kqueue_queue_fileno(kqueue_queue_Object
*self
)
1462 return kqueue_queue_err_closed();
1463 return PyInt_FromLong(self
->kqfd
);
1466 PyDoc_STRVAR(kqueue_queue_fileno_doc
,
1469 Return the kqueue control file descriptor.");
1472 kqueue_queue_fromfd(PyObject
*cls
, PyObject
*args
)
1476 if (!PyArg_ParseTuple(args
, "i:fromfd", &fd
))
1479 return newKqueue_Object((PyTypeObject
*)cls
, fd
);
1482 PyDoc_STRVAR(kqueue_queue_fromfd_doc
,
1483 "fromfd(fd) -> kqueue\n\
1485 Create a kqueue object from a given control fd.");
1488 kqueue_queue_control(kqueue_queue_Object
*self
, PyObject
*args
)
1494 PyObject
*otimeout
= NULL
;
1495 PyObject
*ch
= NULL
;
1496 PyObject
*it
= NULL
, *ei
= NULL
;
1497 PyObject
*result
= NULL
;
1498 struct kevent
*evl
= NULL
;
1499 struct kevent
*chl
= NULL
;
1500 struct timespec timeoutspec
;
1501 struct timespec
*ptimeoutspec
;
1504 return kqueue_queue_err_closed();
1506 if (!PyArg_ParseTuple(args
, "Oi|O:control", &ch
, &nevents
, &otimeout
))
1510 PyErr_Format(PyExc_ValueError
,
1511 "Length of eventlist must be 0 or positive, got %d",
1516 if (otimeout
== Py_None
|| otimeout
== NULL
) {
1517 ptimeoutspec
= NULL
;
1519 else if (PyNumber_Check(otimeout
)) {
1523 timeout
= PyFloat_AsDouble(otimeout
);
1524 if (timeout
== -1 && PyErr_Occurred())
1526 if (timeout
> (double)LONG_MAX
) {
1527 PyErr_SetString(PyExc_OverflowError
,
1528 "timeout period too long");
1532 PyErr_SetString(PyExc_ValueError
,
1533 "timeout must be positive or None");
1537 seconds
= (long)timeout
;
1538 timeout
= timeout
- (double)seconds
;
1539 timeoutspec
.tv_sec
= seconds
;
1540 timeoutspec
.tv_nsec
= (long)(timeout
* 1E9
);
1541 ptimeoutspec
= &timeoutspec
;
1544 PyErr_Format(PyExc_TypeError
,
1545 "timeout argument must be an number "
1546 "or None, got %.200s",
1547 Py_TYPE(otimeout
)->tp_name
);
1551 if (ch
!= NULL
&& ch
!= Py_None
) {
1552 it
= PyObject_GetIter(ch
);
1554 PyErr_SetString(PyExc_TypeError
,
1555 "changelist is not iterable");
1558 nchanges
= PyObject_Size(ch
);
1563 chl
= PyMem_New(struct kevent
, nchanges
);
1569 while ((ei
= PyIter_Next(it
)) != NULL
) {
1570 if (!kqueue_event_Check(ei
)) {
1572 PyErr_SetString(PyExc_TypeError
,
1573 "changelist must be an iterable of "
1574 "select.kevent objects");
1577 chl
[i
++] = ((kqueue_event_Object
*)ei
)->e
;
1586 evl
= PyMem_New(struct kevent
, nevents
);
1593 Py_BEGIN_ALLOW_THREADS
1594 gotevents
= kevent(self
->kqfd
, chl
, nchanges
,
1595 evl
, nevents
, ptimeoutspec
);
1596 Py_END_ALLOW_THREADS
1598 if (gotevents
== -1) {
1599 PyErr_SetFromErrno(PyExc_OSError
);
1603 result
= PyList_New(gotevents
);
1604 if (result
== NULL
) {
1608 for (i
= 0; i
< gotevents
; i
++) {
1609 kqueue_event_Object
*ch
;
1611 ch
= PyObject_New(kqueue_event_Object
, &kqueue_event_Type
);
1616 PyList_SET_ITEM(result
, i
, (PyObject
*)ch
);
1630 PyDoc_STRVAR(kqueue_queue_control_doc
,
1631 "control(changelist, max_events[, timeout=None]) -> eventlist\n\
1633 Calls the kernel kevent function.\n\
1634 - changelist must be a list of kevent objects describing the changes\n\
1635 to be made to the kernel's watch list or None.\n\
1636 - max_events lets you specify the maximum number of events that the\n\
1637 kernel will return.\n\
1638 - timeout is the maximum time to wait in seconds, or else None,\n\
1639 to wait forever. timeout accepts floats for smaller timeouts, too.");
1642 static PyMethodDef kqueue_queue_methods
[] = {
1643 {"fromfd", (PyCFunction
)kqueue_queue_fromfd
,
1644 METH_VARARGS
| METH_CLASS
, kqueue_queue_fromfd_doc
},
1645 {"close", (PyCFunction
)kqueue_queue_close
, METH_NOARGS
,
1646 kqueue_queue_close_doc
},
1647 {"fileno", (PyCFunction
)kqueue_queue_fileno
, METH_NOARGS
,
1648 kqueue_queue_fileno_doc
},
1649 {"control", (PyCFunction
)kqueue_queue_control
,
1650 METH_VARARGS
, kqueue_queue_control_doc
},
1654 static PyGetSetDef kqueue_queue_getsetlist
[] = {
1655 {"closed", (getter
)kqueue_queue_get_closed
, NULL
,
1656 "True if the kqueue handler is closed"},
1660 PyDoc_STRVAR(kqueue_queue_doc
,
1661 "Kqueue syscall wrapper.\n\
1663 For example, to start watching a socket for input:\n\
1664 >>> kq = kqueue()\n\
1665 >>> sock = socket()\n\
1666 >>> sock.connect((host, port))\n\
1667 >>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_ADD)], 0)\n\
1669 To wait one second for it to become writeable:\n\
1670 >>> kq.control(None, 1, 1000)\n\
1672 To stop listening:\n\
1673 >>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_DELETE)], 0)");
1675 static PyTypeObject kqueue_queue_Type
= {
1676 PyVarObject_HEAD_INIT(NULL
, 0)
1677 "select.kqueue", /* tp_name */
1678 sizeof(kqueue_queue_Object
), /* tp_basicsize */
1679 0, /* tp_itemsize */
1680 (destructor
)kqueue_queue_dealloc
, /* tp_dealloc */
1686 0, /* tp_as_number */
1687 0, /* tp_as_sequence */
1688 0, /* tp_as_mapping */
1692 0, /* tp_getattro */
1693 0, /* tp_setattro */
1694 0, /* tp_as_buffer */
1695 Py_TPFLAGS_DEFAULT
, /* tp_flags */
1696 kqueue_queue_doc
, /* tp_doc */
1697 0, /* tp_traverse */
1699 0, /* tp_richcompare */
1700 0, /* tp_weaklistoffset */
1702 0, /* tp_iternext */
1703 kqueue_queue_methods
, /* tp_methods */
1705 kqueue_queue_getsetlist
, /* tp_getset */
1708 0, /* tp_descr_get */
1709 0, /* tp_descr_set */
1710 0, /* tp_dictoffset */
1713 kqueue_queue_new
, /* tp_new */
1717 #endif /* HAVE_KQUEUE */
1718 /* ************************************************************************ */
1720 PyDoc_STRVAR(select_doc
,
1721 "select(rlist, wlist, xlist[, timeout]) -> (rlist, wlist, xlist)\n\
1723 Wait until one or more file descriptors are ready for some kind of I/O.\n\
1724 The first three arguments are sequences of file descriptors to be waited for:\n\
1725 rlist -- wait until ready for reading\n\
1726 wlist -- wait until ready for writing\n\
1727 xlist -- wait for an ``exceptional condition''\n\
1728 If only one kind of condition is required, pass [] for the other lists.\n\
1729 A file descriptor is either a socket or file object, or a small integer\n\
1730 gotten from a fileno() method call on one of those.\n\
1732 The optional 4th argument specifies a timeout in seconds; it may be\n\
1733 a floating point number to specify fractions of seconds. If it is absent\n\
1734 or None, the call will never time out.\n\
1736 The return value is a tuple of three lists corresponding to the first three\n\
1737 arguments; each contains the subset of the corresponding file descriptors\n\
1740 *** IMPORTANT NOTICE ***\n\
1741 On Windows and OpenVMS, only sockets are supported; on Unix, all file\n\
1742 descriptors can be used.");
1744 static PyMethodDef select_methods
[] = {
1745 {"select", select_select
, METH_VARARGS
, select_doc
},
1747 {"poll", select_poll
, METH_NOARGS
, poll_doc
},
1748 #endif /* HAVE_POLL */
1749 {0, 0}, /* sentinel */
1752 PyDoc_STRVAR(module_doc
,
1753 "This module supports asynchronous I/O on multiple file descriptors.\n\
1755 *** IMPORTANT NOTICE ***\n\
1756 On Windows and OpenVMS, only sockets are supported; on Unix, all file descriptors.");
1762 m
= Py_InitModule3("select", select_methods
, module_doc
);
1766 SelectError
= PyErr_NewException("select.error", NULL
, NULL
);
1767 Py_INCREF(SelectError
);
1768 PyModule_AddObject(m
, "error", SelectError
);
1771 #ifdef HAVE_BROKEN_PIPE_BUF
1773 #define PIPE_BUF 512
1775 PyModule_AddIntConstant(m
, "PIPE_BUF", PIPE_BUF
);
1778 #if defined(HAVE_POLL)
1780 if (select_have_broken_poll()) {
1781 if (PyObject_DelAttrString(m
, "poll") == -1) {
1788 Py_TYPE(&poll_Type
) = &PyType_Type
;
1789 PyModule_AddIntConstant(m
, "POLLIN", POLLIN
);
1790 PyModule_AddIntConstant(m
, "POLLPRI", POLLPRI
);
1791 PyModule_AddIntConstant(m
, "POLLOUT", POLLOUT
);
1792 PyModule_AddIntConstant(m
, "POLLERR", POLLERR
);
1793 PyModule_AddIntConstant(m
, "POLLHUP", POLLHUP
);
1794 PyModule_AddIntConstant(m
, "POLLNVAL", POLLNVAL
);
1797 PyModule_AddIntConstant(m
, "POLLRDNORM", POLLRDNORM
);
1800 PyModule_AddIntConstant(m
, "POLLRDBAND", POLLRDBAND
);
1803 PyModule_AddIntConstant(m
, "POLLWRNORM", POLLWRNORM
);
1806 PyModule_AddIntConstant(m
, "POLLWRBAND", POLLWRBAND
);
1809 PyModule_AddIntConstant(m
, "POLLMSG", POLLMSG
);
1812 #endif /* HAVE_POLL */
1815 Py_TYPE(&pyEpoll_Type
) = &PyType_Type
;
1816 if (PyType_Ready(&pyEpoll_Type
) < 0)
1819 Py_INCREF(&pyEpoll_Type
);
1820 PyModule_AddObject(m
, "epoll", (PyObject
*) &pyEpoll_Type
);
1822 PyModule_AddIntConstant(m
, "EPOLLIN", EPOLLIN
);
1823 PyModule_AddIntConstant(m
, "EPOLLOUT", EPOLLOUT
);
1824 PyModule_AddIntConstant(m
, "EPOLLPRI", EPOLLPRI
);
1825 PyModule_AddIntConstant(m
, "EPOLLERR", EPOLLERR
);
1826 PyModule_AddIntConstant(m
, "EPOLLHUP", EPOLLHUP
);
1827 PyModule_AddIntConstant(m
, "EPOLLET", EPOLLET
);
1830 PyModule_AddIntConstant(m
, "EPOLLONESHOT", EPOLLONESHOT
);
1832 /* PyModule_AddIntConstant(m, "EPOLL_RDHUP", EPOLLRDHUP); */
1833 PyModule_AddIntConstant(m
, "EPOLLRDNORM", EPOLLRDNORM
);
1834 PyModule_AddIntConstant(m
, "EPOLLRDBAND", EPOLLRDBAND
);
1835 PyModule_AddIntConstant(m
, "EPOLLWRNORM", EPOLLWRNORM
);
1836 PyModule_AddIntConstant(m
, "EPOLLWRBAND", EPOLLWRBAND
);
1837 PyModule_AddIntConstant(m
, "EPOLLMSG", EPOLLMSG
);
1838 #endif /* HAVE_EPOLL */
1841 kqueue_event_Type
.tp_new
= PyType_GenericNew
;
1842 Py_TYPE(&kqueue_event_Type
) = &PyType_Type
;
1843 if(PyType_Ready(&kqueue_event_Type
) < 0)
1846 Py_INCREF(&kqueue_event_Type
);
1847 PyModule_AddObject(m
, "kevent", (PyObject
*)&kqueue_event_Type
);
1849 Py_TYPE(&kqueue_queue_Type
) = &PyType_Type
;
1850 if(PyType_Ready(&kqueue_queue_Type
) < 0)
1852 Py_INCREF(&kqueue_queue_Type
);
1853 PyModule_AddObject(m
, "kqueue", (PyObject
*)&kqueue_queue_Type
);
1856 PyModule_AddIntConstant(m
, "KQ_FILTER_READ", EVFILT_READ
);
1857 PyModule_AddIntConstant(m
, "KQ_FILTER_WRITE", EVFILT_WRITE
);
1858 PyModule_AddIntConstant(m
, "KQ_FILTER_AIO", EVFILT_AIO
);
1859 PyModule_AddIntConstant(m
, "KQ_FILTER_VNODE", EVFILT_VNODE
);
1860 PyModule_AddIntConstant(m
, "KQ_FILTER_PROC", EVFILT_PROC
);
1861 #ifdef EVFILT_NETDEV
1862 PyModule_AddIntConstant(m
, "KQ_FILTER_NETDEV", EVFILT_NETDEV
);
1864 PyModule_AddIntConstant(m
, "KQ_FILTER_SIGNAL", EVFILT_SIGNAL
);
1865 PyModule_AddIntConstant(m
, "KQ_FILTER_TIMER", EVFILT_TIMER
);
1868 PyModule_AddIntConstant(m
, "KQ_EV_ADD", EV_ADD
);
1869 PyModule_AddIntConstant(m
, "KQ_EV_DELETE", EV_DELETE
);
1870 PyModule_AddIntConstant(m
, "KQ_EV_ENABLE", EV_ENABLE
);
1871 PyModule_AddIntConstant(m
, "KQ_EV_DISABLE", EV_DISABLE
);
1872 PyModule_AddIntConstant(m
, "KQ_EV_ONESHOT", EV_ONESHOT
);
1873 PyModule_AddIntConstant(m
, "KQ_EV_CLEAR", EV_CLEAR
);
1875 PyModule_AddIntConstant(m
, "KQ_EV_SYSFLAGS", EV_SYSFLAGS
);
1876 PyModule_AddIntConstant(m
, "KQ_EV_FLAG1", EV_FLAG1
);
1878 PyModule_AddIntConstant(m
, "KQ_EV_EOF", EV_EOF
);
1879 PyModule_AddIntConstant(m
, "KQ_EV_ERROR", EV_ERROR
);
1881 /* READ WRITE filter flag */
1882 PyModule_AddIntConstant(m
, "KQ_NOTE_LOWAT", NOTE_LOWAT
);
1884 /* VNODE filter flags */
1885 PyModule_AddIntConstant(m
, "KQ_NOTE_DELETE", NOTE_DELETE
);
1886 PyModule_AddIntConstant(m
, "KQ_NOTE_WRITE", NOTE_WRITE
);
1887 PyModule_AddIntConstant(m
, "KQ_NOTE_EXTEND", NOTE_EXTEND
);
1888 PyModule_AddIntConstant(m
, "KQ_NOTE_ATTRIB", NOTE_ATTRIB
);
1889 PyModule_AddIntConstant(m
, "KQ_NOTE_LINK", NOTE_LINK
);
1890 PyModule_AddIntConstant(m
, "KQ_NOTE_RENAME", NOTE_RENAME
);
1891 PyModule_AddIntConstant(m
, "KQ_NOTE_REVOKE", NOTE_REVOKE
);
1893 /* PROC filter flags */
1894 PyModule_AddIntConstant(m
, "KQ_NOTE_EXIT", NOTE_EXIT
);
1895 PyModule_AddIntConstant(m
, "KQ_NOTE_FORK", NOTE_FORK
);
1896 PyModule_AddIntConstant(m
, "KQ_NOTE_EXEC", NOTE_EXEC
);
1897 PyModule_AddIntConstant(m
, "KQ_NOTE_PCTRLMASK", NOTE_PCTRLMASK
);
1898 PyModule_AddIntConstant(m
, "KQ_NOTE_PDATAMASK", NOTE_PDATAMASK
);
1900 PyModule_AddIntConstant(m
, "KQ_NOTE_TRACK", NOTE_TRACK
);
1901 PyModule_AddIntConstant(m
, "KQ_NOTE_CHILD", NOTE_CHILD
);
1902 PyModule_AddIntConstant(m
, "KQ_NOTE_TRACKERR", NOTE_TRACKERR
);
1904 /* NETDEV filter flags */
1905 #ifdef EVFILT_NETDEV
1906 PyModule_AddIntConstant(m
, "KQ_NOTE_LINKUP", NOTE_LINKUP
);
1907 PyModule_AddIntConstant(m
, "KQ_NOTE_LINKDOWN", NOTE_LINKDOWN
);
1908 PyModule_AddIntConstant(m
, "KQ_NOTE_LINKINV", NOTE_LINKINV
);
1911 #endif /* HAVE_KQUEUE */