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