← Back to branch summary

~malept/ubuntu/lucid/python2.6/dev-dependency-fix

« back to all changes in this revision

Viewing changes to Modules/selectmodule.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-02-13 12:51:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090213125100-uufgcb9yeqzujpqw
Tags: upstream-2.6.1
Import upstream version 2.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Modules/selectmodule.c
 
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
}