?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
use bools
[python.git] / Modules / selectmodule.c
blobc52a5f971bcf044af70e6af635af6c509e33d3cd
1 /* select - Module containing unix select(2) call.
2 Under Unix, the file descriptors are small integers.
3 Under Win32, select only exists for sockets, and sockets may
4 have any value except INVALID_SOCKET.
5 Under BeOS, we suffer the same dichotomy as Win32; sockets can be anything
6 >= 0.
7 */
8
9 #include "Python.h"
10 #include <structmember.h>
11
12 #ifdef __APPLE__
13 /* Perform runtime testing for a broken poll on OSX to make it easier
14 * to use the same binary on multiple releases of the OS.
15 */
16 #undef HAVE_BROKEN_POLL
17 #endif
18
19 /* Windows #defines FD_SETSIZE to 64 if FD_SETSIZE isn't already defined.
20 64 is too small (too many people have bumped into that limit).
21 Here we boost it.
22 Users who want even more than the boosted limit should #define
23 FD_SETSIZE higher before this; e.g., via compiler /D switch.
24 */
25 #if defined(MS_WINDOWS) && !defined(FD_SETSIZE)
26 #define FD_SETSIZE 512
27 #endif
28
29 #if defined(HAVE_POLL_H)
30 #include <poll.h>
31 #elif defined(HAVE_SYS_POLL_H)
32 #include <sys/poll.h>
33 #endif
34
35 #ifdef __sgi
36 /* This is missing from unistd.h */
37 extern void bzero(void *, int);
38 #endif
39
40 #ifdef HAVE_SYS_TYPES_H
41 #include <sys/types.h>
42 #endif
43
44 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
45 #include <sys/time.h>
46 #include <utils.h>
47 #endif
48
49 #ifdef MS_WINDOWS
50 # include <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
60 static PyObject *SelectError;
61
62 /* list of Python objects and their file descriptor */
63 typedef struct {
64 PyObject *obj; /* owned reference */
65 SOCKET fd;
66 int sentinel; /* -1 == sentinel */
67 } pylist;
68
69 static void
70 reap_obj(pylist fd2obj[FD_SETSIZE + 1])
71 {
72 int i;
73 for (i = 0; i < FD_SETSIZE + 1 && fd2obj[i].sentinel >= 0; i++) {
74 Py_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 */
84 static int
85 seq2set(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 */
148 static PyObject *
149 set2list(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
194 static PyObject *
195 select_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
333 typedef struct {
334 PyObject_HEAD
335 PyObject *dict;
336 int ufd_uptodate;
337 int ufd_len;
338 struct pollfd *ufds;
339 } pollObject;
340
341 static 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
347 static int
348 update_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
372 PyDoc_STRVAR(poll_register_doc,
373 "register(fd [, eventmask] ) -> None\n\n\
374 Register a file descriptor with the polling object.\n\
375 fd -- either an integer, or an object with a fileno() method returning an\n\
376 int.\n\
377 events -- an optional bitmask describing the type of events to check for");
378
379 static PyObject *
380 poll_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
415 PyDoc_STRVAR(poll_modify_doc,
416 "modify(fd, eventmask) -> None\n\n\
417 Modify an already registered file descriptor.\n\
418 fd -- either an integer, or an object with a fileno() method returning an\n\
419 int.\n\
420 events -- an optional bitmask describing the type of events to check for");
421
422 static PyObject *
423 poll_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
463 PyDoc_STRVAR(poll_unregister_doc,
464 "unregister(fd) -> None\n\n\
465 Remove a file descriptor being tracked by the polling object.");
466
467 static PyObject *
468 poll_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
496 PyDoc_STRVAR(poll_poll_doc,
497 "poll( [timeout] ) -> list of (fd, event) 2-tuples\n\n\
498 Polls the set of registered file descriptors, returning a list containing \n\
499 any descriptors that have events or errors to report.");
500
501 static PyObject *
502 poll_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
593 static 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
605 static pollObject *
606 newPollObject(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
624 static void
625 poll_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
633 static PyObject *
634 poll_getattr(pollObject *self, char *name)
635 {
636 return Py_FindMethod(poll_methods, (PyObject *)self, name);
637 }
638
639 static 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
659 PyDoc_STRVAR(poll_doc,
660 "Returns a polling object, which supports registering and\n\
661 unregistering file descriptors, and then polling them for I/O events.");
662
663 static PyObject *
664 select_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 */
675 static 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
713 typedef struct {
714 PyObject_HEAD
715 SOCKET epfd; /* epoll control file descriptor */
716 } pyEpoll_Object;
717
718 static PyTypeObject pyEpoll_Type;
719 #define pyepoll_CHECK(op) (PyObject_TypeCheck((op), &pyEpoll_Type))
720
721 static PyObject *
722 pyepoll_err_closed(void)
723 {
724 PyErr_SetString(PyExc_ValueError, "I/O operation on closed epoll fd");
725 return NULL;
726 }
727
728 static int
729 pyepoll_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
743 static PyObject *
744 newPyEpoll_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
780 static PyObject *
781 pyepoll_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
794 static void
795 pyepoll_dealloc(pyEpoll_Object *self)
796 {
797 (void)pyepoll_internal_close(self);
798 Py_TYPE(self)->tp_free(self);
799 }
800
801 static PyObject*
802 pyepoll_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
812 PyDoc_STRVAR(pyepoll_close_doc,
813 "close() -> None\n\
814 \n\
815 Close the epoll control file descriptor. Further operations on the epoll\n\
816 object will raise an exception.");
817
818 static PyObject*
819 pyepoll_get_closed(pyEpoll_Object *self)
820 {
821 if (self->epfd < 0)
822 Py_RETURN_TRUE;
823 else
824 Py_RETURN_FALSE;
825 }
826
827 static PyObject*
828 pyepoll_fileno(pyEpoll_Object *self)
829 {
830 if (self->epfd < 0)
831 return pyepoll_err_closed();
832 return PyInt_FromLong(self->epfd);
833 }
834
835 PyDoc_STRVAR(pyepoll_fileno_doc,
836 "fileno() -> int\n\
837 \n\
838 Return the epoll control file descriptor.");
839
840 static PyObject*
841 pyepoll_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
851 PyDoc_STRVAR(pyepoll_fromfd_doc,
852 "fromfd(fd) -> epoll\n\
853 \n\
854 Create an epoll object from a given control fd.");
855
856 static PyObject *
857 pyepoll_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
905 static PyObject *
906 pyepoll_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
920 PyDoc_STRVAR(pyepoll_register_doc,
921 "register(fd[, eventmask]) -> bool\n\
922 \n\
923 Registers a new fd or modifies an already registered fd. register() returns\n\
924 True if a new fd was registered or False if the event mask for fd was modified.\n\
925 fd is the target file descriptor of the operation.\n\
926 events is a bit set composed of the various EPOLL constants; the default\n\
927 is EPOLL_IN | EPOLL_OUT | EPOLL_PRI.\n\
928 \n\
929 The epoll interface supports all file descriptors that support poll.");
930
931 static PyObject *
932 pyepoll_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
946 PyDoc_STRVAR(pyepoll_modify_doc,
947 "modify(fd, eventmask) -> None\n\
948 \n\
949 fd is the target file descriptor of the operation\n\
950 events is a bit set composed of the various EPOLL constants");
951
952 static PyObject *
953 pyepoll_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
966 PyDoc_STRVAR(pyepoll_unregister_doc,
967 "unregister(fd) -> None\n\
968 \n\
969 fd is the target file descriptor of the operation.");
970
971 static PyObject *
972 pyepoll_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
1046 PyDoc_STRVAR(pyepoll_poll_doc,
1047 "poll([timeout=-1[, maxevents=-1]]) -> [(fd, events), (...)]\n\
1048 \n\
1049 Wait for events on the epoll file descriptor for a maximum time of timeout\n\
1050 in seconds (as float). -1 makes poll wait indefinitely.\n\
1051 Up to maxevents are returned to the caller.");
1052
1053 static 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
1071 static PyGetSetDef pyepoll_getsetlist[] = {
1072 {"closed", (getter)pyepoll_get_closed, NULL,
1073 "True if the epoll handler is closed"},
1074 {0},
1075 };
1076
1077 PyDoc_STRVAR(pyepoll_doc,
1078 "select.epoll([sizehint=-1])\n\
1079 \n\
1080 Returns an epolling object\n\
1081 \n\
1082 sizehint must be a positive integer or -1 for the default size. The\n\
1083 sizehint is used to optimize internal data structures. It doesn't limit\n\
1084 the maximum number of monitored events.");
1085
1086 static 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
1163 PyDoc_STRVAR(kqueue_event_doc,
1164 "kevent(ident, filter=KQ_FILTER_READ, flags=KQ_ADD, fflags=0, data=0, udata=0)\n\
1165 \n\
1166 This object is the equivalent of the struct kevent for the C API.\n\
1167 \n\
1168 See the kqueue manpage for more detailed information about the meaning\n\
1169 of the arguments.\n\
1170 \n\
1171 One minor note: while you might hope that udata could store a\n\
1172 reference to a python object, it cannot, because it is impossible to\n\
1173 keep a proper reference count of the object once it's passed into the\n\
1174 kernel. Therefore, I have restricted it to only storing an integer. I\n\
1175 recommend ignoring it and simply using the 'ident' field to key off\n\
1176 of. You could also set up a dictionary on the python side to store a\n\
1177 udata->object mapping.");
1178
1179 typedef struct {
1180 PyObject_HEAD
1181 struct kevent e;
1182 } kqueue_event_Object;
1183
1184 static PyTypeObject kqueue_event_Type;
1185
1186 #define kqueue_event_Check(op) (PyObject_TypeCheck((op), &kqueue_event_Type))
1187
1188 typedef struct {
1189 PyObject_HEAD
1190 SOCKET kqfd; /* kqueue control fd */
1191 } kqueue_queue_Object;
1192
1193 static 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)
1203 static 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
1214 static PyObject *
1215 kqueue_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
1227 static int
1228 kqueue_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
1249 static PyObject *
1250 kqueue_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
1299 static 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
1341 static PyObject *
1342 kqueue_queue_err_closed(void)
1343 {
1344 PyErr_SetString(PyExc_ValueError, "I/O operation on closed kqueue fd");
1345 return NULL;
1346 }
1347
1348 static int
1349 kqueue_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
1363 static PyObject *
1364 newKqueue_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
1389 static PyObject *
1390 kqueue_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
1403 static void
1404 kqueue_queue_dealloc(kqueue_queue_Object *self)
1405 {
1406 kqueue_queue_internal_close(self);
1407 Py_TYPE(self)->tp_free(self);
1408 }
1409
1410 static PyObject*
1411 kqueue_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
1421 PyDoc_STRVAR(kqueue_queue_close_doc,
1422 "close() -> None\n\
1423 \n\
1424 Close the kqueue control file descriptor. Further operations on the kqueue\n\
1425 object will raise an exception.");
1426
1427 static PyObject*
1428 kqueue_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
1436 static PyObject*
1437 kqueue_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
1444 PyDoc_STRVAR(kqueue_queue_fileno_doc,
1445 "fileno() -> int\n\
1446 \n\
1447 Return the kqueue control file descriptor.");
1448
1449 static PyObject*
1450 kqueue_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
1460 PyDoc_STRVAR(kqueue_queue_fromfd_doc,
1461 "fromfd(fd) -> kqueue\n\
1462 \n\
1463 Create a kqueue object from a given control fd.");
1464
1465 static PyObject *
1466 kqueue_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
1610 PyDoc_STRVAR(kqueue_queue_control_doc,
1611 "control(changelist, max_events[, timeout=None]) -> eventlist\n\
1612 \n\
1613 Calls 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
1622 static 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
1634 static PyGetSetDef kqueue_queue_getsetlist[] = {
1635 {"closed", (getter)kqueue_queue_get_closed, NULL,
1636 "True if the kqueue handler is closed"},
1637 {0},
1638 };
1639
1640 PyDoc_STRVAR(kqueue_queue_doc,
1641 "Kqueue syscall wrapper.\n\
1642 \n\
1643 For 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\
1649 To wait one second for it to become writeable:\n\
1650 >>> kq.control(None, 1, 1000)\n\
1651 \n\
1652 To stop listening:\n\
1653 >>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_DELETE)], 0)");
1654
1655 static 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
1700 PyDoc_STRVAR(select_doc,
1701 "select(rlist, wlist, xlist[, timeout]) -> (rlist, wlist, xlist)\n\
1702 \n\
1703 Wait until one or more file descriptors are ready for some kind of I/O.\n\
1704 The first three arguments are sequences of file descriptors to be waited for:\n\
1705 rlist -- wait until ready for reading\n\
1706 wlist -- wait until ready for writing\n\
1707 xlist -- wait for an ``exceptional condition''\n\
1708 If only one kind of condition is required, pass [] for the other lists.\n\
1709 A file descriptor is either a socket or file object, or a small integer\n\
1710 gotten from a fileno() method call on one of those.\n\
1711 \n\
1712 The optional 4th argument specifies a timeout in seconds; it may be\n\
1713 a floating point number to specify fractions of seconds. If it is absent\n\
1714 or None, the call will never time out.\n\
1715 \n\
1716 The return value is a tuple of three lists corresponding to the first three\n\
1717 arguments; each contains the subset of the corresponding file descriptors\n\
1718 that are ready.\n\
1719 \n\
1720 *** IMPORTANT NOTICE ***\n\
1721 On Windows and OpenVMS, only sockets are supported; on Unix, all file\n\
1722 descriptors can be used.");
1723
1724 static 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
1732 PyDoc_STRVAR(module_doc,
1733 "This module supports asynchronous I/O on multiple file descriptors.\n\
1734 \n\
1735 *** IMPORTANT NOTICE ***\n\
1736 On Windows and OpenVMS, only sockets are supported; on Unix, all file descriptors.");
1737
1738 PyMODINIT_FUNC
1739 initselect(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 #ifdef PIPE_BUF
1751 PyModule_AddIntConstant(m, "PIPE_BUF", PIPE_BUF);
1752 #endif
1753
1754 #if defined(HAVE_POLL)
1755 #ifdef __APPLE__
1756 if (select_have_broken_poll()) {
1757 if (PyObject_DelAttrString(m, "poll") == -1) {
1758 PyErr_Clear();
1759 }
1760 } else {
1761 #else
1762 {
1763 #endif
1764 Py_TYPE(&poll_Type) = &PyType_Type;
1765 PyModule_AddIntConstant(m, "POLLIN", POLLIN);
1766 PyModule_AddIntConstant(m, "POLLPRI", POLLPRI);
1767 PyModule_AddIntConstant(m, "POLLOUT", POLLOUT);
1768 PyModule_AddIntConstant(m, "POLLERR", POLLERR);
1769 PyModule_AddIntConstant(m, "POLLHUP", POLLHUP);
1770 PyModule_AddIntConstant(m, "POLLNVAL", POLLNVAL);
1771
1772 #ifdef POLLRDNORM
1773 PyModule_AddIntConstant(m, "POLLRDNORM", POLLRDNORM);
1774 #endif
1775 #ifdef POLLRDBAND
1776 PyModule_AddIntConstant(m, "POLLRDBAND", POLLRDBAND);
1777 #endif
1778 #ifdef POLLWRNORM
1779 PyModule_AddIntConstant(m, "POLLWRNORM", POLLWRNORM);
1780 #endif
1781 #ifdef POLLWRBAND
1782 PyModule_AddIntConstant(m, "POLLWRBAND", POLLWRBAND);
1783 #endif
1784 #ifdef POLLMSG
1785 PyModule_AddIntConstant(m, "POLLMSG", POLLMSG);
1786 #endif
1787 }
1788 #endif /* HAVE_POLL */
1789
1790 #ifdef HAVE_EPOLL
1791 Py_TYPE(&pyEpoll_Type) = &PyType_Type;
1792 if (PyType_Ready(&pyEpoll_Type) < 0)
1793 return;
1794
1795 Py_INCREF(&pyEpoll_Type);
1796 PyModule_AddObject(m, "epoll", (PyObject *) &pyEpoll_Type);
1797
1798 PyModule_AddIntConstant(m, "EPOLLIN", EPOLLIN);
1799 PyModule_AddIntConstant(m, "EPOLLOUT", EPOLLOUT);
1800 PyModule_AddIntConstant(m, "EPOLLPRI", EPOLLPRI);
1801 PyModule_AddIntConstant(m, "EPOLLERR", EPOLLERR);
1802 PyModule_AddIntConstant(m, "EPOLLHUP", EPOLLHUP);
1803 PyModule_AddIntConstant(m, "EPOLLET", EPOLLET);
1804 #ifdef EPOLLONESHOT
1805 /* Kernel 2.6.2+ */
1806 PyModule_AddIntConstant(m, "EPOLLONESHOT", EPOLLONESHOT);
1807 #endif
1808 /* PyModule_AddIntConstant(m, "EPOLL_RDHUP", EPOLLRDHUP); */
1809 PyModule_AddIntConstant(m, "EPOLLRDNORM", EPOLLRDNORM);
1810 PyModule_AddIntConstant(m, "EPOLLRDBAND", EPOLLRDBAND);
1811 PyModule_AddIntConstant(m, "EPOLLWRNORM", EPOLLWRNORM);
1812 PyModule_AddIntConstant(m, "EPOLLWRBAND", EPOLLWRBAND);
1813 PyModule_AddIntConstant(m, "EPOLLMSG", EPOLLMSG);
1814 #endif /* HAVE_EPOLL */
1815
1816 #ifdef HAVE_KQUEUE
1817 kqueue_event_Type.tp_new = PyType_GenericNew;
1818 Py_TYPE(&kqueue_event_Type) = &PyType_Type;
1819 if(PyType_Ready(&kqueue_event_Type) < 0)
1820 return;
1821
1822 Py_INCREF(&kqueue_event_Type);
1823 PyModule_AddObject(m, "kevent", (PyObject *)&kqueue_event_Type);
1824
1825 Py_TYPE(&kqueue_queue_Type) = &PyType_Type;
1826 if(PyType_Ready(&kqueue_queue_Type) < 0)
1827 return;
1828 Py_INCREF(&kqueue_queue_Type);
1829 PyModule_AddObject(m, "kqueue", (PyObject *)&kqueue_queue_Type);
1830
1831 /* event filters */
1832 PyModule_AddIntConstant(m, "KQ_FILTER_READ", EVFILT_READ);
1833 PyModule_AddIntConstant(m, "KQ_FILTER_WRITE", EVFILT_WRITE);
1834 PyModule_AddIntConstant(m, "KQ_FILTER_AIO", EVFILT_AIO);
1835 PyModule_AddIntConstant(m, "KQ_FILTER_VNODE", EVFILT_VNODE);
1836 PyModule_AddIntConstant(m, "KQ_FILTER_PROC", EVFILT_PROC);
1837 #ifdef EVFILT_NETDEV
1838 PyModule_AddIntConstant(m, "KQ_FILTER_NETDEV", EVFILT_NETDEV);
1839 #endif
1840 PyModule_AddIntConstant(m, "KQ_FILTER_SIGNAL", EVFILT_SIGNAL);
1841 PyModule_AddIntConstant(m, "KQ_FILTER_TIMER", EVFILT_TIMER);
1842
1843 /* event flags */
1844 PyModule_AddIntConstant(m, "KQ_EV_ADD", EV_ADD);
1845 PyModule_AddIntConstant(m, "KQ_EV_DELETE", EV_DELETE);
1846 PyModule_AddIntConstant(m, "KQ_EV_ENABLE", EV_ENABLE);
1847 PyModule_AddIntConstant(m, "KQ_EV_DISABLE", EV_DISABLE);
1848 PyModule_AddIntConstant(m, "KQ_EV_ONESHOT", EV_ONESHOT);
1849 PyModule_AddIntConstant(m, "KQ_EV_CLEAR", EV_CLEAR);
1850
1851 PyModule_AddIntConstant(m, "KQ_EV_SYSFLAGS", EV_SYSFLAGS);
1852 PyModule_AddIntConstant(m, "KQ_EV_FLAG1", EV_FLAG1);
1853
1854 PyModule_AddIntConstant(m, "KQ_EV_EOF", EV_EOF);
1855 PyModule_AddIntConstant(m, "KQ_EV_ERROR", EV_ERROR);
1856
1857 /* READ WRITE filter flag */
1858 PyModule_AddIntConstant(m, "KQ_NOTE_LOWAT", NOTE_LOWAT);
1859
1860 /* VNODE filter flags */
1861 PyModule_AddIntConstant(m, "KQ_NOTE_DELETE", NOTE_DELETE);
1862 PyModule_AddIntConstant(m, "KQ_NOTE_WRITE", NOTE_WRITE);
1863 PyModule_AddIntConstant(m, "KQ_NOTE_EXTEND", NOTE_EXTEND);
1864 PyModule_AddIntConstant(m, "KQ_NOTE_ATTRIB", NOTE_ATTRIB);
1865 PyModule_AddIntConstant(m, "KQ_NOTE_LINK", NOTE_LINK);
1866 PyModule_AddIntConstant(m, "KQ_NOTE_RENAME", NOTE_RENAME);
1867 PyModule_AddIntConstant(m, "KQ_NOTE_REVOKE", NOTE_REVOKE);
1868
1869 /* PROC filter flags */
1870 PyModule_AddIntConstant(m, "KQ_NOTE_EXIT", NOTE_EXIT);
1871 PyModule_AddIntConstant(m, "KQ_NOTE_FORK", NOTE_FORK);
1872 PyModule_AddIntConstant(m, "KQ_NOTE_EXEC", NOTE_EXEC);
1873 PyModule_AddIntConstant(m, "KQ_NOTE_PCTRLMASK", NOTE_PCTRLMASK);
1874 PyModule_AddIntConstant(m, "KQ_NOTE_PDATAMASK", NOTE_PDATAMASK);
1875
1876 PyModule_AddIntConstant(m, "KQ_NOTE_TRACK", NOTE_TRACK);
1877 PyModule_AddIntConstant(m, "KQ_NOTE_CHILD", NOTE_CHILD);
1878 PyModule_AddIntConstant(m, "KQ_NOTE_TRACKERR", NOTE_TRACKERR);
1879
1880 /* NETDEV filter flags */
1881 #ifdef EVFILT_NETDEV
1882 PyModule_AddIntConstant(m, "KQ_NOTE_LINKUP", NOTE_LINKUP);
1883 PyModule_AddIntConstant(m, "KQ_NOTE_LINKDOWN", NOTE_LINKDOWN);
1884 PyModule_AddIntConstant(m, "KQ_NOTE_LINKINV", NOTE_LINKINV);
1885 #endif
1886
1887 #endif /* HAVE_KQUEUE */
1888 }
python git mirror