?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add NEWS entry as per RDM's suggestion (the bug was actually present
[python.git] / Modules / selectmodule.c
blobacbea7a7605b574ae76a243fe51c67ee08ef861b
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 #if (SIZEOF_UINTPTR_T != SIZEOF_VOID_P)
1198 # error uintptr_t does not match void *!
1199 #elif (SIZEOF_UINTPTR_T == SIZEOF_LONG_LONG)
1200 # define T_UINTPTRT T_ULONGLONG
1201 # define T_INTPTRT T_LONGLONG
1202 # define PyLong_AsUintptr_t PyLong_AsUnsignedLongLong
1203 # define UINTPTRT_FMT_UNIT "K"
1204 # define INTPTRT_FMT_UNIT "L"
1205 #elif (SIZEOF_UINTPTR_T == SIZEOF_LONG)
1206 # define T_UINTPTRT T_ULONG
1207 # define T_INTPTRT T_LONG
1208 # define PyLong_AsUintptr_t PyLong_AsUnsignedLong
1209 # define UINTPTRT_FMT_UNIT "k"
1210 # define INTPTRT_FMT_UNIT "l"
1211 #elif (SIZEOF_UINTPTR_T == SIZEOF_INT)
1212 # define T_UINTPTRT T_UINT
1213 # define T_INTPTRT T_INT
1214 # define PyLong_AsUintptr_t PyLong_AsUnsignedLong
1215 # define UINTPTRT_FMT_UNIT "I"
1216 # define INTPTRT_FMT_UNIT "i"
1217 #else
1218 # error uintptr_t does not match int, long, or long long!
1219 #endif
1220
1221 /* Unfortunately, we can't store python objects in udata, because
1222 * kevents in the kernel can be removed without warning, which would
1223 * forever lose the refcount on the object stored with it.
1224 */
1225
1226 #define KQ_OFF(x) offsetof(kqueue_event_Object, x)
1227 static struct PyMemberDef kqueue_event_members[] = {
1228 {"ident", T_UINTPTRT, KQ_OFF(e.ident)},
1229 {"filter", T_SHORT, KQ_OFF(e.filter)},
1230 {"flags", T_USHORT, KQ_OFF(e.flags)},
1231 {"fflags", T_UINT, KQ_OFF(e.fflags)},
1232 {"data", T_INTPTRT, KQ_OFF(e.data)},
1233 {"udata", T_UINTPTRT, KQ_OFF(e.udata)},
1234 {NULL} /* Sentinel */
1235 };
1236 #undef KQ_OFF
1237
1238 static PyObject *
1239 kqueue_event_repr(kqueue_event_Object *s)
1240 {
1241 char buf[1024];
1242 PyOS_snprintf(
1243 buf, sizeof(buf),
1244 "<select.kevent ident=%zu filter=%d flags=0x%x fflags=0x%x "
1245 "data=0x%zd udata=%p>",
1246 (size_t)(s->e.ident), s->e.filter, s->e.flags,
1247 s->e.fflags, (Py_ssize_t)(s->e.data), s->e.udata);
1248 return PyString_FromString(buf);
1249 }
1250
1251 static int
1252 kqueue_event_init(kqueue_event_Object *self, PyObject *args, PyObject *kwds)
1253 {
1254 PyObject *pfd;
1255 static char *kwlist[] = {"ident", "filter", "flags", "fflags",
1256 "data", "udata", NULL};
1257 static char *fmt = "O|hhi" INTPTRT_FMT_UNIT UINTPTRT_FMT_UNIT ":kevent";
1258
1259 EV_SET(&(self->e), 0, EVFILT_READ, EV_ADD, 0, 0, 0); /* defaults */
1260
1261 if (!PyArg_ParseTupleAndKeywords(args, kwds, fmt, kwlist,
1262 &pfd, &(self->e.filter), &(self->e.flags),
1263 &(self->e.fflags), &(self->e.data), &(self->e.udata))) {
1264 return -1;
1265 }
1266
1267 if (PyLong_Check(pfd)) {
1268 self->e.ident = PyLong_AsUintptr_t(pfd);
1269 }
1270 else {
1271 self->e.ident = PyObject_AsFileDescriptor(pfd);
1272 }
1273 if (PyErr_Occurred()) {
1274 return -1;
1275 }
1276 return 0;
1277 }
1278
1279 static PyObject *
1280 kqueue_event_richcompare(kqueue_event_Object *s, kqueue_event_Object *o,
1281 int op)
1282 {
1283 Py_intptr_t result = 0;
1284
1285 if (!kqueue_event_Check(o)) {
1286 if (op == Py_EQ || op == Py_NE) {
1287 PyObject *res = op == Py_EQ ? Py_False : Py_True;
1288 Py_INCREF(res);
1289 return res;
1290 }
1291 PyErr_Format(PyExc_TypeError,
1292 "can't compare %.200s to %.200s",
1293 Py_TYPE(s)->tp_name, Py_TYPE(o)->tp_name);
1294 return NULL;
1295 }
1296 if (((result = s->e.ident - o->e.ident) == 0) &&
1297 ((result = s->e.filter - o->e.filter) == 0) &&
1298 ((result = s->e.flags - o->e.flags) == 0) &&
1299 ((result = s->e.fflags - o->e.fflags) == 0) &&
1300 ((result = s->e.data - o->e.data) == 0) &&
1301 ((result = s->e.udata - o->e.udata) == 0)
1302 ) {
1303 result = 0;
1304 }
1305
1306 switch (op) {
1307 case Py_EQ:
1308 result = (result == 0);
1309 break;
1310 case Py_NE:
1311 result = (result != 0);
1312 break;
1313 case Py_LE:
1314 result = (result <= 0);
1315 break;
1316 case Py_GE:
1317 result = (result >= 0);
1318 break;
1319 case Py_LT:
1320 result = (result < 0);
1321 break;
1322 case Py_GT:
1323 result = (result > 0);
1324 break;
1325 }
1326 return PyBool_FromLong((long)result);
1327 }
1328
1329 static PyTypeObject kqueue_event_Type = {
1330 PyVarObject_HEAD_INIT(NULL, 0)
1331 "select.kevent", /* tp_name */
1332 sizeof(kqueue_event_Object), /* tp_basicsize */
1333 0, /* tp_itemsize */
1334 0, /* tp_dealloc */
1335 0, /* tp_print */
1336 0, /* tp_getattr */
1337 0, /* tp_setattr */
1338 0, /* tp_compare */
1339 (reprfunc)kqueue_event_repr, /* tp_repr */
1340 0, /* tp_as_number */
1341 0, /* tp_as_sequence */
1342 0, /* tp_as_mapping */
1343 0, /* tp_hash */
1344 0, /* tp_call */
1345 0, /* tp_str */
1346 0, /* tp_getattro */
1347 0, /* tp_setattro */
1348 0, /* tp_as_buffer */
1349 Py_TPFLAGS_DEFAULT, /* tp_flags */
1350 kqueue_event_doc, /* tp_doc */
1351 0, /* tp_traverse */
1352 0, /* tp_clear */
1353 (richcmpfunc)kqueue_event_richcompare, /* tp_richcompare */
1354 0, /* tp_weaklistoffset */
1355 0, /* tp_iter */
1356 0, /* tp_iternext */
1357 0, /* tp_methods */
1358 kqueue_event_members, /* tp_members */
1359 0, /* tp_getset */
1360 0, /* tp_base */
1361 0, /* tp_dict */
1362 0, /* tp_descr_get */
1363 0, /* tp_descr_set */
1364 0, /* tp_dictoffset */
1365 (initproc)kqueue_event_init, /* tp_init */
1366 0, /* tp_alloc */
1367 0, /* tp_new */
1368 0, /* tp_free */
1369 };
1370
1371 static PyObject *
1372 kqueue_queue_err_closed(void)
1373 {
1374 PyErr_SetString(PyExc_ValueError, "I/O operation on closed kqueue fd");
1375 return NULL;
1376 }
1377
1378 static int
1379 kqueue_queue_internal_close(kqueue_queue_Object *self)
1380 {
1381 int save_errno = 0;
1382 if (self->kqfd >= 0) {
1383 int kqfd = self->kqfd;
1384 self->kqfd = -1;
1385 Py_BEGIN_ALLOW_THREADS
1386 if (close(kqfd) < 0)
1387 save_errno = errno;
1388 Py_END_ALLOW_THREADS
1389 }
1390 return save_errno;
1391 }
1392
1393 static PyObject *
1394 newKqueue_Object(PyTypeObject *type, SOCKET fd)
1395 {
1396 kqueue_queue_Object *self;
1397 assert(type != NULL && type->tp_alloc != NULL);
1398 self = (kqueue_queue_Object *) type->tp_alloc(type, 0);
1399 if (self == NULL) {
1400 return NULL;
1401 }
1402
1403 if (fd == -1) {
1404 Py_BEGIN_ALLOW_THREADS
1405 self->kqfd = kqueue();
1406 Py_END_ALLOW_THREADS
1407 }
1408 else {
1409 self->kqfd = fd;
1410 }
1411 if (self->kqfd < 0) {
1412 Py_DECREF(self);
1413 PyErr_SetFromErrno(PyExc_IOError);
1414 return NULL;
1415 }
1416 return (PyObject *)self;
1417 }
1418
1419 static PyObject *
1420 kqueue_queue_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1421 {
1422
1423 if ((args != NULL && PyObject_Size(args)) ||
1424 (kwds != NULL && PyObject_Size(kwds))) {
1425 PyErr_SetString(PyExc_ValueError,
1426 "select.kqueue doesn't accept arguments");
1427 return NULL;
1428 }
1429
1430 return newKqueue_Object(type, -1);
1431 }
1432
1433 static void
1434 kqueue_queue_dealloc(kqueue_queue_Object *self)
1435 {
1436 kqueue_queue_internal_close(self);
1437 Py_TYPE(self)->tp_free(self);
1438 }
1439
1440 static PyObject*
1441 kqueue_queue_close(kqueue_queue_Object *self)
1442 {
1443 errno = kqueue_queue_internal_close(self);
1444 if (errno < 0) {
1445 PyErr_SetFromErrno(PyExc_IOError);
1446 return NULL;
1447 }
1448 Py_RETURN_NONE;
1449 }
1450
1451 PyDoc_STRVAR(kqueue_queue_close_doc,
1452 "close() -> None\n\
1453 \n\
1454 Close the kqueue control file descriptor. Further operations on the kqueue\n\
1455 object will raise an exception.");
1456
1457 static PyObject*
1458 kqueue_queue_get_closed(kqueue_queue_Object *self)
1459 {
1460 if (self->kqfd < 0)
1461 Py_RETURN_TRUE;
1462 else
1463 Py_RETURN_FALSE;
1464 }
1465
1466 static PyObject*
1467 kqueue_queue_fileno(kqueue_queue_Object *self)
1468 {
1469 if (self->kqfd < 0)
1470 return kqueue_queue_err_closed();
1471 return PyInt_FromLong(self->kqfd);
1472 }
1473
1474 PyDoc_STRVAR(kqueue_queue_fileno_doc,
1475 "fileno() -> int\n\
1476 \n\
1477 Return the kqueue control file descriptor.");
1478
1479 static PyObject*
1480 kqueue_queue_fromfd(PyObject *cls, PyObject *args)
1481 {
1482 SOCKET fd;
1483
1484 if (!PyArg_ParseTuple(args, "i:fromfd", &fd))
1485 return NULL;
1486
1487 return newKqueue_Object((PyTypeObject*)cls, fd);
1488 }
1489
1490 PyDoc_STRVAR(kqueue_queue_fromfd_doc,
1491 "fromfd(fd) -> kqueue\n\
1492 \n\
1493 Create a kqueue object from a given control fd.");
1494
1495 static PyObject *
1496 kqueue_queue_control(kqueue_queue_Object *self, PyObject *args)
1497 {
1498 int nevents = 0;
1499 int gotevents = 0;
1500 int nchanges = 0;
1501 int i = 0;
1502 PyObject *otimeout = NULL;
1503 PyObject *ch = NULL;
1504 PyObject *it = NULL, *ei = NULL;
1505 PyObject *result = NULL;
1506 struct kevent *evl = NULL;
1507 struct kevent *chl = NULL;
1508 struct timespec timeoutspec;
1509 struct timespec *ptimeoutspec;
1510
1511 if (self->kqfd < 0)
1512 return kqueue_queue_err_closed();
1513
1514 if (!PyArg_ParseTuple(args, "Oi|O:control", &ch, &nevents, &otimeout))
1515 return NULL;
1516
1517 if (nevents < 0) {
1518 PyErr_Format(PyExc_ValueError,
1519 "Length of eventlist must be 0 or positive, got %d",
1520 nevents);
1521 return NULL;
1522 }
1523
1524 if (ch != NULL && ch != Py_None) {
1525 it = PyObject_GetIter(ch);
1526 if (it == NULL) {
1527 PyErr_SetString(PyExc_TypeError,
1528 "changelist is not iterable");
1529 return NULL;
1530 }
1531 nchanges = PyObject_Size(ch);
1532 if (nchanges < 0) {
1533 return NULL;
1534 }
1535 }
1536
1537 if (otimeout == Py_None || otimeout == NULL) {
1538 ptimeoutspec = NULL;
1539 }
1540 else if (PyNumber_Check(otimeout)) {
1541 double timeout;
1542 long seconds;
1543
1544 timeout = PyFloat_AsDouble(otimeout);
1545 if (timeout == -1 && PyErr_Occurred())
1546 return NULL;
1547 if (timeout > (double)LONG_MAX) {
1548 PyErr_SetString(PyExc_OverflowError,
1549 "timeout period too long");
1550 return NULL;
1551 }
1552 if (timeout < 0) {
1553 PyErr_SetString(PyExc_ValueError,
1554 "timeout must be positive or None");
1555 return NULL;
1556 }
1557
1558 seconds = (long)timeout;
1559 timeout = timeout - (double)seconds;
1560 timeoutspec.tv_sec = seconds;
1561 timeoutspec.tv_nsec = (long)(timeout * 1E9);
1562 ptimeoutspec = &timeoutspec;
1563 }
1564 else {
1565 PyErr_Format(PyExc_TypeError,
1566 "timeout argument must be an number "
1567 "or None, got %.200s",
1568 Py_TYPE(otimeout)->tp_name);
1569 return NULL;
1570 }
1571
1572 if (nchanges) {
1573 chl = PyMem_New(struct kevent, nchanges);
1574 if (chl == NULL) {
1575 PyErr_NoMemory();
1576 return NULL;
1577 }
1578 i = 0;
1579 while ((ei = PyIter_Next(it)) != NULL) {
1580 if (!kqueue_event_Check(ei)) {
1581 Py_DECREF(ei);
1582 PyErr_SetString(PyExc_TypeError,
1583 "changelist must be an iterable of "
1584 "select.kevent objects");
1585 goto error;
1586 } else {
1587 chl[i++] = ((kqueue_event_Object *)ei)->e;
1588 }
1589 Py_DECREF(ei);
1590 }
1591 }
1592 Py_CLEAR(it);
1593
1594 /* event list */
1595 if (nevents) {
1596 evl = PyMem_New(struct kevent, nevents);
1597 if (evl == NULL) {
1598 PyErr_NoMemory();
1599 return NULL;
1600 }
1601 }
1602
1603 Py_BEGIN_ALLOW_THREADS
1604 gotevents = kevent(self->kqfd, chl, nchanges,
1605 evl, nevents, ptimeoutspec);
1606 Py_END_ALLOW_THREADS
1607
1608 if (gotevents == -1) {
1609 PyErr_SetFromErrno(PyExc_OSError);
1610 goto error;
1611 }
1612
1613 result = PyList_New(gotevents);
1614 if (result == NULL) {
1615 goto error;
1616 }
1617
1618 for (i = 0; i < gotevents; i++) {
1619 kqueue_event_Object *ch;
1620
1621 ch = PyObject_New(kqueue_event_Object, &kqueue_event_Type);
1622 if (ch == NULL) {
1623 goto error;
1624 }
1625 ch->e = evl[i];
1626 PyList_SET_ITEM(result, i, (PyObject *)ch);
1627 }
1628 PyMem_Free(chl);
1629 PyMem_Free(evl);
1630 return result;
1631
1632 error:
1633 PyMem_Free(chl);
1634 PyMem_Free(evl);
1635 Py_XDECREF(result);
1636 Py_XDECREF(it);
1637 return NULL;
1638 }
1639
1640 PyDoc_STRVAR(kqueue_queue_control_doc,
1641 "control(changelist, max_events[, timeout=None]) -> eventlist\n\
1642 \n\
1643 Calls the kernel kevent function.\n\
1644 - changelist must be a list of kevent objects describing the changes\n\
1645 to be made to the kernel's watch list or None.\n\
1646 - max_events lets you specify the maximum number of events that the\n\
1647 kernel will return.\n\
1648 - timeout is the maximum time to wait in seconds, or else None,\n\
1649 to wait forever. timeout accepts floats for smaller timeouts, too.");
1650
1651
1652 static PyMethodDef kqueue_queue_methods[] = {
1653 {"fromfd", (PyCFunction)kqueue_queue_fromfd,
1654 METH_VARARGS | METH_CLASS, kqueue_queue_fromfd_doc},
1655 {"close", (PyCFunction)kqueue_queue_close, METH_NOARGS,
1656 kqueue_queue_close_doc},
1657 {"fileno", (PyCFunction)kqueue_queue_fileno, METH_NOARGS,
1658 kqueue_queue_fileno_doc},
1659 {"control", (PyCFunction)kqueue_queue_control,
1660 METH_VARARGS , kqueue_queue_control_doc},
1661 {NULL, NULL},
1662 };
1663
1664 static PyGetSetDef kqueue_queue_getsetlist[] = {
1665 {"closed", (getter)kqueue_queue_get_closed, NULL,
1666 "True if the kqueue handler is closed"},
1667 {0},
1668 };
1669
1670 PyDoc_STRVAR(kqueue_queue_doc,
1671 "Kqueue syscall wrapper.\n\
1672 \n\
1673 For example, to start watching a socket for input:\n\
1674 >>> kq = kqueue()\n\
1675 >>> sock = socket()\n\
1676 >>> sock.connect((host, port))\n\
1677 >>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_ADD)], 0)\n\
1678 \n\
1679 To wait one second for it to become writeable:\n\
1680 >>> kq.control(None, 1, 1000)\n\
1681 \n\
1682 To stop listening:\n\
1683 >>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_DELETE)], 0)");
1684
1685 static PyTypeObject kqueue_queue_Type = {
1686 PyVarObject_HEAD_INIT(NULL, 0)
1687 "select.kqueue", /* tp_name */
1688 sizeof(kqueue_queue_Object), /* tp_basicsize */
1689 0, /* tp_itemsize */
1690 (destructor)kqueue_queue_dealloc, /* tp_dealloc */
1691 0, /* tp_print */
1692 0, /* tp_getattr */
1693 0, /* tp_setattr */
1694 0, /* tp_compare */
1695 0, /* tp_repr */
1696 0, /* tp_as_number */
1697 0, /* tp_as_sequence */
1698 0, /* tp_as_mapping */
1699 0, /* tp_hash */
1700 0, /* tp_call */
1701 0, /* tp_str */
1702 0, /* tp_getattro */
1703 0, /* tp_setattro */
1704 0, /* tp_as_buffer */
1705 Py_TPFLAGS_DEFAULT, /* tp_flags */
1706 kqueue_queue_doc, /* tp_doc */
1707 0, /* tp_traverse */
1708 0, /* tp_clear */
1709 0, /* tp_richcompare */
1710 0, /* tp_weaklistoffset */
1711 0, /* tp_iter */
1712 0, /* tp_iternext */
1713 kqueue_queue_methods, /* tp_methods */
1714 0, /* tp_members */
1715 kqueue_queue_getsetlist, /* tp_getset */
1716 0, /* tp_base */
1717 0, /* tp_dict */
1718 0, /* tp_descr_get */
1719 0, /* tp_descr_set */
1720 0, /* tp_dictoffset */
1721 0, /* tp_init */
1722 0, /* tp_alloc */
1723 kqueue_queue_new, /* tp_new */
1724 0, /* tp_free */
1725 };
1726
1727 #endif /* HAVE_KQUEUE */
1728 /* ************************************************************************ */
1729
1730 PyDoc_STRVAR(select_doc,
1731 "select(rlist, wlist, xlist[, timeout]) -> (rlist, wlist, xlist)\n\
1732 \n\
1733 Wait until one or more file descriptors are ready for some kind of I/O.\n\
1734 The first three arguments are sequences of file descriptors to be waited for:\n\
1735 rlist -- wait until ready for reading\n\
1736 wlist -- wait until ready for writing\n\
1737 xlist -- wait for an ``exceptional condition''\n\
1738 If only one kind of condition is required, pass [] for the other lists.\n\
1739 A file descriptor is either a socket or file object, or a small integer\n\
1740 gotten from a fileno() method call on one of those.\n\
1741 \n\
1742 The optional 4th argument specifies a timeout in seconds; it may be\n\
1743 a floating point number to specify fractions of seconds. If it is absent\n\
1744 or None, the call will never time out.\n\
1745 \n\
1746 The return value is a tuple of three lists corresponding to the first three\n\
1747 arguments; each contains the subset of the corresponding file descriptors\n\
1748 that are ready.\n\
1749 \n\
1750 *** IMPORTANT NOTICE ***\n\
1751 On Windows and OpenVMS, only sockets are supported; on Unix, all file\n\
1752 descriptors can be used.");
1753
1754 static PyMethodDef select_methods[] = {
1755 {"select", select_select, METH_VARARGS, select_doc},
1756 #ifdef HAVE_POLL
1757 {"poll", select_poll, METH_NOARGS, poll_doc},
1758 #endif /* HAVE_POLL */
1759 {0, 0}, /* sentinel */
1760 };
1761
1762 PyDoc_STRVAR(module_doc,
1763 "This module supports asynchronous I/O on multiple file descriptors.\n\
1764 \n\
1765 *** IMPORTANT NOTICE ***\n\
1766 On Windows and OpenVMS, only sockets are supported; on Unix, all file descriptors.");
1767
1768 PyMODINIT_FUNC
1769 initselect(void)
1770 {
1771 PyObject *m;
1772 m = Py_InitModule3("select", select_methods, module_doc);
1773 if (m == NULL)
1774 return;
1775
1776 SelectError = PyErr_NewException("select.error", NULL, NULL);
1777 Py_INCREF(SelectError);
1778 PyModule_AddObject(m, "error", SelectError);
1779
1780 #ifdef PIPE_BUF
1781 PyModule_AddIntConstant(m, "PIPE_BUF", PIPE_BUF);
1782 #endif
1783
1784 #if defined(HAVE_POLL)
1785 #ifdef __APPLE__
1786 if (select_have_broken_poll()) {
1787 if (PyObject_DelAttrString(m, "poll") == -1) {
1788 PyErr_Clear();
1789 }
1790 } else {
1791 #else
1792 {
1793 #endif
1794 Py_TYPE(&poll_Type) = &PyType_Type;
1795 PyModule_AddIntConstant(m, "POLLIN", POLLIN);
1796 PyModule_AddIntConstant(m, "POLLPRI", POLLPRI);
1797 PyModule_AddIntConstant(m, "POLLOUT", POLLOUT);
1798 PyModule_AddIntConstant(m, "POLLERR", POLLERR);
1799 PyModule_AddIntConstant(m, "POLLHUP", POLLHUP);
1800 PyModule_AddIntConstant(m, "POLLNVAL", POLLNVAL);
1801
1802 #ifdef POLLRDNORM
1803 PyModule_AddIntConstant(m, "POLLRDNORM", POLLRDNORM);
1804 #endif
1805 #ifdef POLLRDBAND
1806 PyModule_AddIntConstant(m, "POLLRDBAND", POLLRDBAND);
1807 #endif
1808 #ifdef POLLWRNORM
1809 PyModule_AddIntConstant(m, "POLLWRNORM", POLLWRNORM);
1810 #endif
1811 #ifdef POLLWRBAND
1812 PyModule_AddIntConstant(m, "POLLWRBAND", POLLWRBAND);
1813 #endif
1814 #ifdef POLLMSG
1815 PyModule_AddIntConstant(m, "POLLMSG", POLLMSG);
1816 #endif
1817 }
1818 #endif /* HAVE_POLL */
1819
1820 #ifdef HAVE_EPOLL
1821 Py_TYPE(&pyEpoll_Type) = &PyType_Type;
1822 if (PyType_Ready(&pyEpoll_Type) < 0)
1823 return;
1824
1825 Py_INCREF(&pyEpoll_Type);
1826 PyModule_AddObject(m, "epoll", (PyObject *) &pyEpoll_Type);
1827
1828 PyModule_AddIntConstant(m, "EPOLLIN", EPOLLIN);
1829 PyModule_AddIntConstant(m, "EPOLLOUT", EPOLLOUT);
1830 PyModule_AddIntConstant(m, "EPOLLPRI", EPOLLPRI);
1831 PyModule_AddIntConstant(m, "EPOLLERR", EPOLLERR);
1832 PyModule_AddIntConstant(m, "EPOLLHUP", EPOLLHUP);
1833 PyModule_AddIntConstant(m, "EPOLLET", EPOLLET);
1834 #ifdef EPOLLONESHOT
1835 /* Kernel 2.6.2+ */
1836 PyModule_AddIntConstant(m, "EPOLLONESHOT", EPOLLONESHOT);
1837 #endif
1838 /* PyModule_AddIntConstant(m, "EPOLL_RDHUP", EPOLLRDHUP); */
1839 PyModule_AddIntConstant(m, "EPOLLRDNORM", EPOLLRDNORM);
1840 PyModule_AddIntConstant(m, "EPOLLRDBAND", EPOLLRDBAND);
1841 PyModule_AddIntConstant(m, "EPOLLWRNORM", EPOLLWRNORM);
1842 PyModule_AddIntConstant(m, "EPOLLWRBAND", EPOLLWRBAND);
1843 PyModule_AddIntConstant(m, "EPOLLMSG", EPOLLMSG);
1844 #endif /* HAVE_EPOLL */
1845
1846 #ifdef HAVE_KQUEUE
1847 kqueue_event_Type.tp_new = PyType_GenericNew;
1848 Py_TYPE(&kqueue_event_Type) = &PyType_Type;
1849 if(PyType_Ready(&kqueue_event_Type) < 0)
1850 return;
1851
1852 Py_INCREF(&kqueue_event_Type);
1853 PyModule_AddObject(m, "kevent", (PyObject *)&kqueue_event_Type);
1854
1855 Py_TYPE(&kqueue_queue_Type) = &PyType_Type;
1856 if(PyType_Ready(&kqueue_queue_Type) < 0)
1857 return;
1858 Py_INCREF(&kqueue_queue_Type);
1859 PyModule_AddObject(m, "kqueue", (PyObject *)&kqueue_queue_Type);
1860
1861 /* event filters */
1862 PyModule_AddIntConstant(m, "KQ_FILTER_READ", EVFILT_READ);
1863 PyModule_AddIntConstant(m, "KQ_FILTER_WRITE", EVFILT_WRITE);
1864 PyModule_AddIntConstant(m, "KQ_FILTER_AIO", EVFILT_AIO);
1865 PyModule_AddIntConstant(m, "KQ_FILTER_VNODE", EVFILT_VNODE);
1866 PyModule_AddIntConstant(m, "KQ_FILTER_PROC", EVFILT_PROC);
1867 #ifdef EVFILT_NETDEV
1868 PyModule_AddIntConstant(m, "KQ_FILTER_NETDEV", EVFILT_NETDEV);
1869 #endif
1870 PyModule_AddIntConstant(m, "KQ_FILTER_SIGNAL", EVFILT_SIGNAL);
1871 PyModule_AddIntConstant(m, "KQ_FILTER_TIMER", EVFILT_TIMER);
1872
1873 /* event flags */
1874 PyModule_AddIntConstant(m, "KQ_EV_ADD", EV_ADD);
1875 PyModule_AddIntConstant(m, "KQ_EV_DELETE", EV_DELETE);
1876 PyModule_AddIntConstant(m, "KQ_EV_ENABLE", EV_ENABLE);
1877 PyModule_AddIntConstant(m, "KQ_EV_DISABLE", EV_DISABLE);
1878 PyModule_AddIntConstant(m, "KQ_EV_ONESHOT", EV_ONESHOT);
1879 PyModule_AddIntConstant(m, "KQ_EV_CLEAR", EV_CLEAR);
1880
1881 PyModule_AddIntConstant(m, "KQ_EV_SYSFLAGS", EV_SYSFLAGS);
1882 PyModule_AddIntConstant(m, "KQ_EV_FLAG1", EV_FLAG1);
1883
1884 PyModule_AddIntConstant(m, "KQ_EV_EOF", EV_EOF);
1885 PyModule_AddIntConstant(m, "KQ_EV_ERROR", EV_ERROR);
1886
1887 /* READ WRITE filter flag */
1888 PyModule_AddIntConstant(m, "KQ_NOTE_LOWAT", NOTE_LOWAT);
1889
1890 /* VNODE filter flags */
1891 PyModule_AddIntConstant(m, "KQ_NOTE_DELETE", NOTE_DELETE);
1892 PyModule_AddIntConstant(m, "KQ_NOTE_WRITE", NOTE_WRITE);
1893 PyModule_AddIntConstant(m, "KQ_NOTE_EXTEND", NOTE_EXTEND);
1894 PyModule_AddIntConstant(m, "KQ_NOTE_ATTRIB", NOTE_ATTRIB);
1895 PyModule_AddIntConstant(m, "KQ_NOTE_LINK", NOTE_LINK);
1896 PyModule_AddIntConstant(m, "KQ_NOTE_RENAME", NOTE_RENAME);
1897 PyModule_AddIntConstant(m, "KQ_NOTE_REVOKE", NOTE_REVOKE);
1898
1899 /* PROC filter flags */
1900 PyModule_AddIntConstant(m, "KQ_NOTE_EXIT", NOTE_EXIT);
1901 PyModule_AddIntConstant(m, "KQ_NOTE_FORK", NOTE_FORK);
1902 PyModule_AddIntConstant(m, "KQ_NOTE_EXEC", NOTE_EXEC);
1903 PyModule_AddIntConstant(m, "KQ_NOTE_PCTRLMASK", NOTE_PCTRLMASK);
1904 PyModule_AddIntConstant(m, "KQ_NOTE_PDATAMASK", NOTE_PDATAMASK);
1905
1906 PyModule_AddIntConstant(m, "KQ_NOTE_TRACK", NOTE_TRACK);
1907 PyModule_AddIntConstant(m, "KQ_NOTE_CHILD", NOTE_CHILD);
1908 PyModule_AddIntConstant(m, "KQ_NOTE_TRACKERR", NOTE_TRACKERR);
1909
1910 /* NETDEV filter flags */
1911 #ifdef EVFILT_NETDEV
1912 PyModule_AddIntConstant(m, "KQ_NOTE_LINKUP", NOTE_LINKUP);
1913 PyModule_AddIntConstant(m, "KQ_NOTE_LINKDOWN", NOTE_LINKDOWN);
1914 PyModule_AddIntConstant(m, "KQ_NOTE_LINKINV", NOTE_LINKINV);
1915 #endif
1916
1917 #endif /* HAVE_KQUEUE */
1918 }
python git mirror