source: python/trunk/Modules/selectmodule.c@ 389

Last change on this file since 389 was 2, checked in by Yuri Dario, 15 years ago

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