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