?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Localize the function lookup in timeit.
[python.git] / Modules / selectmodule.c
blob2638bdc7b6dd805f6857bbbc6fbde99acc72ab4d
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 nchanges);
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 while ((ei = PyIter_Next(it)) != NULL) {
1549 if (!kqueue_event_Check(ei)) {
1550 Py_DECREF(ei);
1551 PyErr_SetString(PyExc_TypeError,
1552 "changelist must be an iterable of "
1553 "select.kevent objects");
1554 goto error;
1555 } else {
1556 chl[i] = ((kqueue_event_Object *)ei)->e;
1557 }
1558 Py_DECREF(ei);
1559 }
1560 }
1561 Py_CLEAR(it);
1562
1563 /* event list */
1564 if (nevents) {
1565 evl = PyMem_New(struct kevent, nevents);
1566 if (evl == NULL) {
1567 PyErr_NoMemory();
1568 return NULL;
1569 }
1570 }
1571
1572 Py_BEGIN_ALLOW_THREADS
1573 gotevents = kevent(self->kqfd, chl, nchanges,
1574 evl, nevents, ptimeoutspec);
1575 Py_END_ALLOW_THREADS
1576
1577 if (gotevents == -1) {
1578 PyErr_SetFromErrno(PyExc_OSError);
1579 goto error;
1580 }
1581
1582 result = PyList_New(gotevents);
1583 if (result == NULL) {
1584 goto error;
1585 }
1586
1587 for (i=0; i < gotevents; i++) {
1588 kqueue_event_Object *ch;
1589
1590 ch = PyObject_New(kqueue_event_Object, &kqueue_event_Type);
1591 if (ch == NULL) {
1592 goto error;
1593 }
1594 ch->e = evl[i];
1595 PyList_SET_ITEM(result, i, (PyObject *)ch);
1596 }
1597 PyMem_Free(chl);
1598 PyMem_Free(evl);
1599 return result;
1600
1601 error:
1602 PyMem_Free(chl);
1603 PyMem_Free(evl);
1604 Py_XDECREF(result);
1605 Py_XDECREF(it);
1606 return NULL;
1607 }
1608
1609 PyDoc_STRVAR(kqueue_queue_control_doc,
1610 "control(changelist, max_events[, timeout=None]) -> eventlist\n\
1611 \n\
1612 Calls the kernel kevent function.\n\
1613 - changelist must be a list of kevent objects describing the changes\n\
1614 to be made to the kernel's watch list or None.\n\
1615 - max_events lets you specify the maximum number of events that the\n\
1616 kernel will return.\n\
1617 - timeout is the maximum time to wait in seconds, or else None,\n\
1618 to wait forever. timeout accepts floats for smaller timeouts, too.");
1619
1620
1621 static PyMethodDef kqueue_queue_methods[] = {
1622 {"fromfd", (PyCFunction)kqueue_queue_fromfd,
1623 METH_VARARGS | METH_CLASS, kqueue_queue_fromfd_doc},
1624 {"close", (PyCFunction)kqueue_queue_close, METH_NOARGS,
1625 kqueue_queue_close_doc},
1626 {"fileno", (PyCFunction)kqueue_queue_fileno, METH_NOARGS,
1627 kqueue_queue_fileno_doc},
1628 {"control", (PyCFunction)kqueue_queue_control,
1629 METH_VARARGS , kqueue_queue_control_doc},
1630 {NULL, NULL},
1631 };
1632
1633 static PyGetSetDef kqueue_queue_getsetlist[] = {
1634 {"closed", (getter)kqueue_queue_get_closed, NULL,
1635 "True if the kqueue handler is closed"},
1636 {0},
1637 };
1638
1639 PyDoc_STRVAR(kqueue_queue_doc,
1640 "Kqueue syscall wrapper.\n\
1641 \n\
1642 For example, to start watching a socket for input:\n\
1643 >>> kq = kqueue()\n\
1644 >>> sock = socket()\n\
1645 >>> sock.connect((host, port))\n\
1646 >>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_ADD)], 0)\n\
1647 \n\
1648 To wait one second for it to become writeable:\n\
1649 >>> kq.control(None, 1, 1000)\n\
1650 \n\
1651 To stop listening:\n\
1652 >>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_DELETE)], 0)");
1653
1654 static PyTypeObject kqueue_queue_Type = {
1655 PyVarObject_HEAD_INIT(NULL, 0)
1656 "select.kqueue", /* tp_name */
1657 sizeof(kqueue_queue_Object), /* tp_basicsize */
1658 0, /* tp_itemsize */
1659 (destructor)kqueue_queue_dealloc, /* tp_dealloc */
1660 0, /* tp_print */
1661 0, /* tp_getattr */
1662 0, /* tp_setattr */
1663 0, /* tp_compare */
1664 0, /* tp_repr */
1665 0, /* tp_as_number */
1666 0, /* tp_as_sequence */
1667 0, /* tp_as_mapping */
1668 0, /* tp_hash */
1669 0, /* tp_call */
1670 0, /* tp_str */
1671 0, /* tp_getattro */
1672 0, /* tp_setattro */
1673 0, /* tp_as_buffer */
1674 Py_TPFLAGS_DEFAULT, /* tp_flags */
1675 kqueue_queue_doc, /* tp_doc */
1676 0, /* tp_traverse */
1677 0, /* tp_clear */
1678 0, /* tp_richcompare */
1679 0, /* tp_weaklistoffset */
1680 0, /* tp_iter */
1681 0, /* tp_iternext */
1682 kqueue_queue_methods, /* tp_methods */
1683 0, /* tp_members */
1684 kqueue_queue_getsetlist, /* tp_getset */
1685 0, /* tp_base */
1686 0, /* tp_dict */
1687 0, /* tp_descr_get */
1688 0, /* tp_descr_set */
1689 0, /* tp_dictoffset */
1690 0, /* tp_init */
1691 0, /* tp_alloc */
1692 kqueue_queue_new, /* tp_new */
1693 0, /* tp_free */
1694 };
1695
1696 #endif /* HAVE_KQUEUE */
1697 /* ************************************************************************ */
1698
1699 PyDoc_STRVAR(select_doc,
1700 "select(rlist, wlist, xlist[, timeout]) -> (rlist, wlist, xlist)\n\
1701 \n\
1702 Wait until one or more file descriptors are ready for some kind of I/O.\n\
1703 The first three arguments are sequences of file descriptors to be waited for:\n\
1704 rlist -- wait until ready for reading\n\
1705 wlist -- wait until ready for writing\n\
1706 xlist -- wait for an ``exceptional condition''\n\
1707 If only one kind of condition is required, pass [] for the other lists.\n\
1708 A file descriptor is either a socket or file object, or a small integer\n\
1709 gotten from a fileno() method call on one of those.\n\
1710 \n\
1711 The optional 4th argument specifies a timeout in seconds; it may be\n\
1712 a floating point number to specify fractions of seconds. If it is absent\n\
1713 or None, the call will never time out.\n\
1714 \n\
1715 The return value is a tuple of three lists corresponding to the first three\n\
1716 arguments; each contains the subset of the corresponding file descriptors\n\
1717 that are ready.\n\
1718 \n\
1719 *** IMPORTANT NOTICE ***\n\
1720 On Windows and OpenVMS, only sockets are supported; on Unix, all file\n\
1721 descriptors can be used.");
1722
1723 static PyMethodDef select_methods[] = {
1724 {"select", select_select, METH_VARARGS, select_doc},
1725 #ifdef HAVE_POLL
1726 {"poll", select_poll, METH_NOARGS, poll_doc},
1727 #endif /* HAVE_POLL */
1728 {0, 0}, /* sentinel */
1729 };
1730
1731 PyDoc_STRVAR(module_doc,
1732 "This module supports asynchronous I/O on multiple file descriptors.\n\
1733 \n\
1734 *** IMPORTANT NOTICE ***\n\
1735 On Windows and OpenVMS, only sockets are supported; on Unix, all file descriptors.");
1736
1737 PyMODINIT_FUNC
1738 initselect(void)
1739 {
1740 PyObject *m;
1741 m = Py_InitModule3("select", select_methods, module_doc);
1742 if (m == NULL)
1743 return;
1744
1745 SelectError = PyErr_NewException("select.error", NULL, NULL);
1746 Py_INCREF(SelectError);
1747 PyModule_AddObject(m, "error", SelectError);
1748
1749 #if defined(HAVE_POLL)
1750 #ifdef __APPLE__
1751 if (select_have_broken_poll()) {
1752 if (PyObject_DelAttrString(m, "poll") == -1) {
1753 PyErr_Clear();
1754 }
1755 } else {
1756 #else
1757 {
1758 #endif
1759 Py_TYPE(&poll_Type) = &PyType_Type;
1760 PyModule_AddIntConstant(m, "POLLIN", POLLIN);
1761 PyModule_AddIntConstant(m, "POLLPRI", POLLPRI);
1762 PyModule_AddIntConstant(m, "POLLOUT", POLLOUT);
1763 PyModule_AddIntConstant(m, "POLLERR", POLLERR);
1764 PyModule_AddIntConstant(m, "POLLHUP", POLLHUP);
1765 PyModule_AddIntConstant(m, "POLLNVAL", POLLNVAL);
1766
1767 #ifdef POLLRDNORM
1768 PyModule_AddIntConstant(m, "POLLRDNORM", POLLRDNORM);
1769 #endif
1770 #ifdef POLLRDBAND
1771 PyModule_AddIntConstant(m, "POLLRDBAND", POLLRDBAND);
1772 #endif
1773 #ifdef POLLWRNORM
1774 PyModule_AddIntConstant(m, "POLLWRNORM", POLLWRNORM);
1775 #endif
1776 #ifdef POLLWRBAND
1777 PyModule_AddIntConstant(m, "POLLWRBAND", POLLWRBAND);
1778 #endif
1779 #ifdef POLLMSG
1780 PyModule_AddIntConstant(m, "POLLMSG", POLLMSG);
1781 #endif
1782 }
1783 #endif /* HAVE_POLL */
1784
1785 #ifdef HAVE_EPOLL
1786 Py_TYPE(&pyEpoll_Type) = &PyType_Type;
1787 if (PyType_Ready(&pyEpoll_Type) < 0)
1788 return;
1789
1790 Py_INCREF(&pyEpoll_Type);
1791 PyModule_AddObject(m, "epoll", (PyObject *) &pyEpoll_Type);
1792
1793 PyModule_AddIntConstant(m, "EPOLLIN", EPOLLIN);
1794 PyModule_AddIntConstant(m, "EPOLLOUT", EPOLLOUT);
1795 PyModule_AddIntConstant(m, "EPOLLPRI", EPOLLPRI);
1796 PyModule_AddIntConstant(m, "EPOLLERR", EPOLLERR);
1797 PyModule_AddIntConstant(m, "EPOLLHUP", EPOLLHUP);
1798 PyModule_AddIntConstant(m, "EPOLLET", EPOLLET);
1799 #ifdef EPOLLONESHOT
1800 /* Kernel 2.6.2+ */
1801 PyModule_AddIntConstant(m, "EPOLLONESHOT", EPOLLONESHOT);
1802 #endif
1803 /* PyModule_AddIntConstant(m, "EPOLL_RDHUP", EPOLLRDHUP); */
1804 PyModule_AddIntConstant(m, "EPOLLRDNORM", EPOLLRDNORM);
1805 PyModule_AddIntConstant(m, "EPOLLRDBAND", EPOLLRDBAND);
1806 PyModule_AddIntConstant(m, "EPOLLWRNORM", EPOLLWRNORM);
1807 PyModule_AddIntConstant(m, "EPOLLWRBAND", EPOLLWRBAND);
1808 PyModule_AddIntConstant(m, "EPOLLMSG", EPOLLMSG);
1809 #endif /* HAVE_EPOLL */
1810
1811 #ifdef HAVE_KQUEUE
1812 kqueue_event_Type.tp_new = PyType_GenericNew;
1813 Py_TYPE(&kqueue_event_Type) = &PyType_Type;
1814 if(PyType_Ready(&kqueue_event_Type) < 0)
1815 return;
1816
1817 Py_INCREF(&kqueue_event_Type);
1818 PyModule_AddObject(m, "kevent", (PyObject *)&kqueue_event_Type);
1819
1820 Py_TYPE(&kqueue_queue_Type) = &PyType_Type;
1821 if(PyType_Ready(&kqueue_queue_Type) < 0)
1822 return;
1823 Py_INCREF(&kqueue_queue_Type);
1824 PyModule_AddObject(m, "kqueue", (PyObject *)&kqueue_queue_Type);
1825
1826 /* event filters */
1827 PyModule_AddIntConstant(m, "KQ_FILTER_READ", EVFILT_READ);
1828 PyModule_AddIntConstant(m, "KQ_FILTER_WRITE", EVFILT_WRITE);
1829 PyModule_AddIntConstant(m, "KQ_FILTER_AIO", EVFILT_AIO);
1830 PyModule_AddIntConstant(m, "KQ_FILTER_VNODE", EVFILT_VNODE);
1831 PyModule_AddIntConstant(m, "KQ_FILTER_PROC", EVFILT_PROC);
1832 #ifdef EVFILT_NETDEV
1833 PyModule_AddIntConstant(m, "KQ_FILTER_NETDEV", EVFILT_NETDEV);
1834 #endif
1835 PyModule_AddIntConstant(m, "KQ_FILTER_SIGNAL", EVFILT_SIGNAL);
1836 PyModule_AddIntConstant(m, "KQ_FILTER_TIMER", EVFILT_TIMER);
1837
1838 /* event flags */
1839 PyModule_AddIntConstant(m, "KQ_EV_ADD", EV_ADD);
1840 PyModule_AddIntConstant(m, "KQ_EV_DELETE", EV_DELETE);
1841 PyModule_AddIntConstant(m, "KQ_EV_ENABLE", EV_ENABLE);
1842 PyModule_AddIntConstant(m, "KQ_EV_DISABLE", EV_DISABLE);
1843 PyModule_AddIntConstant(m, "KQ_EV_ONESHOT", EV_ONESHOT);
1844 PyModule_AddIntConstant(m, "KQ_EV_CLEAR", EV_CLEAR);
1845
1846 PyModule_AddIntConstant(m, "KQ_EV_SYSFLAGS", EV_SYSFLAGS);
1847 PyModule_AddIntConstant(m, "KQ_EV_FLAG1", EV_FLAG1);
1848
1849 PyModule_AddIntConstant(m, "KQ_EV_EOF", EV_EOF);
1850 PyModule_AddIntConstant(m, "KQ_EV_ERROR", EV_ERROR);
1851
1852 /* READ WRITE filter flag */
1853 PyModule_AddIntConstant(m, "KQ_NOTE_LOWAT", NOTE_LOWAT);
1854
1855 /* VNODE filter flags */
1856 PyModule_AddIntConstant(m, "KQ_NOTE_DELETE", NOTE_DELETE);
1857 PyModule_AddIntConstant(m, "KQ_NOTE_WRITE", NOTE_WRITE);
1858 PyModule_AddIntConstant(m, "KQ_NOTE_EXTEND", NOTE_EXTEND);
1859 PyModule_AddIntConstant(m, "KQ_NOTE_ATTRIB", NOTE_ATTRIB);
1860 PyModule_AddIntConstant(m, "KQ_NOTE_LINK", NOTE_LINK);
1861 PyModule_AddIntConstant(m, "KQ_NOTE_RENAME", NOTE_RENAME);
1862 PyModule_AddIntConstant(m, "KQ_NOTE_REVOKE", NOTE_REVOKE);
1863
1864 /* PROC filter flags */
1865 PyModule_AddIntConstant(m, "KQ_NOTE_EXIT", NOTE_EXIT);
1866 PyModule_AddIntConstant(m, "KQ_NOTE_FORK", NOTE_FORK);
1867 PyModule_AddIntConstant(m, "KQ_NOTE_EXEC", NOTE_EXEC);
1868 PyModule_AddIntConstant(m, "KQ_NOTE_PCTRLMASK", NOTE_PCTRLMASK);
1869 PyModule_AddIntConstant(m, "KQ_NOTE_PDATAMASK", NOTE_PDATAMASK);
1870
1871 PyModule_AddIntConstant(m, "KQ_NOTE_TRACK", NOTE_TRACK);
1872 PyModule_AddIntConstant(m, "KQ_NOTE_CHILD", NOTE_CHILD);
1873 PyModule_AddIntConstant(m, "KQ_NOTE_TRACKERR", NOTE_TRACKERR);
1874
1875 /* NETDEV filter flags */
1876 #ifdef EVFILT_NETDEV
1877 PyModule_AddIntConstant(m, "KQ_NOTE_LINKUP", NOTE_LINKUP);
1878 PyModule_AddIntConstant(m, "KQ_NOTE_LINKDOWN", NOTE_LINKDOWN);
1879 PyModule_AddIntConstant(m, "KQ_NOTE_LINKINV", NOTE_LINKINV);
1880 #endif
1881
1882 #endif /* HAVE_KQUEUE */
1883 }
python git mirror