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