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.