static PyObject *
do_multi_close(CurlMultiObject *self)
{
if (check_multi_state(self, 2, "close") != 0) {
return NULL;
}
util_multi_close(self);
Py_RETURN_NONE;
}
static PyObject *
do_multi_select(CurlMultiObject *self, PyObject *args)
{
int max_fd = -1, n;
double timeout = -1.0;
struct timeval tv, *tvp;
CURLMcode res;
if (!PyArg_ParseTuple(args, "d:select", &timeout)) {
return NULL;
}
if (check_multi_state(self, 1 | 2, "select") != 0) {
return NULL;
}
if (timeout < 0 || timeout >= 365 * 24 * 60 * 60) {
PyErr_SetString(PyExc_OverflowError, "invalid timeout period");
return NULL;
} else {
long seconds = (long)timeout;
timeout = timeout - (double)seconds;
assert(timeout >= 0.0);
assert(timeout < 1.0);
tv.tv_sec = seconds;
tv.tv_usec = (long)(timeout*1000000.0);
tvp = &tv;
}
FD_ZERO(&self->read_fd_set);
FD_ZERO(&self->write_fd_set);
FD_ZERO(&self->exc_fd_set);
res = curl_multi_fdset(self->multi_handle, &self->read_fd_set,
&self->write_fd_set, &self->exc_fd_set, &max_fd);
if (res != CURLM_OK) {
CURLERROR_MSG("multi_fdset failed");
}
if (max_fd < 0) {
n = 0;
}
else {
Py_BEGIN_ALLOW_THREADS
n = select(max_fd + 1, &self->read_fd_set, &self->write_fd_set, &self->exc_fd_set, tvp);
Py_END_ALLOW_THREADS
/* info: like Python's socketmodule.c we do not raise an exception
* if select() fails - we'll leave it to the actual libcurl
* socket code to report any errors.
*/
}
return PyInt_FromLong(n);
}
static PyObject *
do_multi_timeout(CurlMultiObject *self)
{
CURLMcode res;
long timeout;
if (check_multi_state(self, 1 | 2, "timeout") != 0) {
return NULL;
}
res = curl_multi_timeout(self->multi_handle, &timeout);
if (res != CURLM_OK) {
CURLERROR_MSG("timeout failed");
}
/* Return number of millisecs until timeout */
return Py_BuildValue("l", timeout);
}
static PyObject *
do_multi_assign(CurlMultiObject *self, PyObject *args)
{
CURLMcode res;
curl_socket_t socket;
PyObject *obj;
if (!PyArg_ParseTuple(args, "iO:assign", &socket, &obj))
return NULL;
if (check_multi_state(self, 1 | 2, "assign") != 0) {
return NULL;
}
Py_INCREF(obj);
res = curl_multi_assign(self->multi_handle, socket, obj);
if (res != CURLM_OK) {
CURLERROR_MSG("assign failed");
}
Py_RETURN_NONE;
}
static PyObject *
do_multi_setopt(CurlMultiObject *self, PyObject *args)
{
int option, which;
PyObject *obj;
if (!PyArg_ParseTuple(args, "iO:setopt", &option, &obj))
return NULL;
if (check_multi_state(self, 1 | 2, "setopt") != 0)
return NULL;
/* Early checks of option value */
if (option <= 0)
goto error;
if (option >= (int)CURLOPTTYPE_OFF_T + MOPTIONS_SIZE)
goto error;
if (option % 10000 >= MOPTIONS_SIZE)
goto error;
/* Handle the case of integer arguments */
if (PyInt_Check(obj)) {
return do_multi_setopt_int(self, option, obj);
}
/* Handle the case of list or tuple objects */
which = PyListOrTuple_Check(obj);
if (which) {
return do_multi_setopt_list(self, option, which, obj);
}
if (PyFunction_Check(obj) || PyCFunction_Check(obj) ||
PyCallable_Check(obj) || PyMethod_Check(obj)) {
return do_multi_setopt_callable(self, option, obj);
}
/* Failed to match any of the function signatures -- return error */
error:
PyErr_SetString(PyExc_TypeError, "invalid arguments to setopt");
return NULL;
}
static PyObject *
do_multi_perform(CurlMultiObject *self)
{
CURLMcode res;
int running = -1;
if (check_multi_state(self, 1 | 2, "perform") != 0) {
return NULL;
}
PYCURL_BEGIN_ALLOW_THREADS
res = curl_multi_perform(self->multi_handle, &running);
PYCURL_END_ALLOW_THREADS
/* We assume these errors are ok, otherwise raise exception */
if (res != CURLM_OK && res != CURLM_CALL_MULTI_PERFORM) {
CURLERROR_MSG("perform failed");
}
/* Return a tuple with the result and the number of running handles */
return Py_BuildValue("(ii)", (int)res, running);
}
/* --------------- socket_action --------------- */
static PyObject *
do_multi_socket_action(CurlMultiObject *self, PyObject *args)
{
CURLMcode res;
curl_socket_t socket;
int ev_bitmask;
int running = -1;
if (!PyArg_ParseTuple(args, "ii:socket_action", &socket, &ev_bitmask))
return NULL;
if (check_multi_state(self, 1 | 2, "socket_action") != 0) {
return NULL;
}
PYCURL_BEGIN_ALLOW_THREADS
res = curl_multi_socket_action(self->multi_handle, socket, ev_bitmask, &running);
PYCURL_END_ALLOW_THREADS
if (res != CURLM_OK) {
CURLERROR_MSG("multi_socket_action failed");
}
/* Return a tuple with the result and the number of running handles */
return Py_BuildValue("(ii)", (int)res, running);
}
static PyObject *
do_multi_info_read(CurlMultiObject *self, PyObject *args)
{
PyObject *ret = NULL;
PyObject *ok_list = NULL, *err_list = NULL;
CURLMsg *msg;
int in_queue = 0, num_results = INT_MAX;
/* Sanity checks */
if (!PyArg_ParseTuple(args, "|i:info_read", &num_results)) {
return NULL;
}
if (num_results <= 0) {
PyErr_SetString(ErrorObject, "argument to info_read must be greater than zero");
return NULL;
}
if (check_multi_state(self, 1 | 2, "info_read") != 0) {
return NULL;
}
if ((ok_list = PyList_New((Py_ssize_t)0)) == NULL) goto error;
if ((err_list = PyList_New((Py_ssize_t)0)) == NULL) goto error;
/* Loop through all messages */
while ((msg = curl_multi_info_read(self->multi_handle, &in_queue)) != NULL) {
CURLcode res;
CurlObject *co = NULL;
/* Check for termination as specified by the user */
if (num_results-- <= 0) {
break;
}
/* Fetch the curl object that corresponds to the curl handle in the message */
res = curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, &co);
if (res != CURLE_OK || co == NULL) {
Py_DECREF(err_list);
Py_DECREF(ok_list);
CURLERROR_MSG("Unable to fetch curl handle from curl object");
}
assert(Py_TYPE(co) == p_Curl_Type);
if (msg->msg != CURLMSG_DONE) {
/* FIXME: what does this mean ??? */
}
if (msg->data.result == CURLE_OK) {
/* Append curl object to list of objects which succeeded */
if (PyList_Append(ok_list, (PyObject *)co) != 0) {
goto error;
}
}
else {
/* Create a result tuple that will get added to err_list. */
PyObject *v = Py_BuildValue("(Ois)", (PyObject *)co, (int)msg->data.result, co->error);
/* Append curl object to list of objects which failed */
if (v == NULL || PyList_Append(err_list, v) != 0) {
Py_XDECREF(v);
goto error;
}
Py_DECREF(v);
}
}
/* Return (number of queued messages, [ok_objects], [error_objects]) */
ret = Py_BuildValue("(iOO)", in_queue, ok_list, err_list);
error:
Py_XDECREF(err_list);
Py_XDECREF(ok_list);
return ret;
}
static PyObject *
do_multi_fdset(CurlMultiObject *self)
{
CURLMcode res;
int max_fd = -1, fd;
PyObject *ret = NULL;
PyObject *read_list = NULL, *write_list = NULL, *except_list = NULL;
PyObject *py_fd = NULL;
if (check_multi_state(self, 1 | 2, "fdset") != 0) {
return NULL;
}
/* Clear file descriptor sets */
FD_ZERO(&self->read_fd_set);
FD_ZERO(&self->write_fd_set);
FD_ZERO(&self->exc_fd_set);
/* Don't bother releasing the gil as this is just a data structure operation */
res = curl_multi_fdset(self->multi_handle, &self->read_fd_set,
&self->write_fd_set, &self->exc_fd_set, &max_fd);
if (res != CURLM_OK) {
CURLERROR_MSG("curl_multi_fdset() failed due to internal errors");
}
/* Allocate lists. */
if ((read_list = PyList_New((Py_ssize_t)0)) == NULL) goto error;
if ((write_list = PyList_New((Py_ssize_t)0)) == NULL) goto error;
if ((except_list = PyList_New((Py_ssize_t)0)) == NULL) goto error;
/* Populate lists */
for (fd = 0; fd < max_fd + 1; fd++) {
if (FD_ISSET(fd, &self->read_fd_set)) {
if ((py_fd = PyInt_FromLong((long)fd)) == NULL) goto error;
if (PyList_Append(read_list, py_fd) != 0) goto error;
Py_DECREF(py_fd);
py_fd = NULL;
}
if (FD_ISSET(fd, &self->write_fd_set)) {
if ((py_fd = PyInt_FromLong((long)fd)) == NULL) goto error;
if (PyList_Append(write_list, py_fd) != 0) goto error;
Py_DECREF(py_fd);
py_fd = NULL;
}
if (FD_ISSET(fd, &self->exc_fd_set)) {
if ((py_fd = PyInt_FromLong((long)fd)) == NULL) goto error;
if (PyList_Append(except_list, py_fd) != 0) goto error;
Py_DECREF(py_fd);
py_fd = NULL;
}
}
/* Return a tuple with the 3 lists */
ret = Py_BuildValue("(OOO)", read_list, write_list, except_list);
error:
Py_XDECREF(py_fd);
Py_XDECREF(except_list);
Py_XDECREF(write_list);
Py_XDECREF(read_list);
return ret;
}
static PyObject *
do_multi_setopt(CurlMultiObject *self, PyObject *args)
{
int option;
PyObject *obj;
if (!PyArg_ParseTuple(args, "iO:setopt", &option, &obj))
return NULL;
if (check_multi_state(self, 1 | 2, "setopt") != 0)
return NULL;
/* Early checks of option value */
if (option <= 0)
goto error;
if (option >= (int)CURLOPTTYPE_OFF_T + MOPTIONS_SIZE)
goto error;
if (option % 10000 >= MOPTIONS_SIZE)
goto error;
/* Handle the case of integer arguments */
if (PyInt_Check(obj)) {
long d = PyInt_AsLong(obj);
switch(option) {
case CURLMOPT_MAXCONNECTS:
case CURLMOPT_PIPELINING:
#ifdef HAVE_CURL_7_30_0_PIPELINE_OPTS
case CURLMOPT_MAX_HOST_CONNECTIONS:
case CURLMOPT_MAX_TOTAL_CONNECTIONS:
case CURLMOPT_MAX_PIPELINE_LENGTH:
case CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE:
case CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE:
#endif
curl_multi_setopt(self->multi_handle, option, d);
break;
default:
PyErr_SetString(PyExc_TypeError, "integers are not supported for this option");
return NULL;
}
Py_RETURN_NONE;
}
if (PyFunction_Check(obj) || PyCFunction_Check(obj) ||
PyCallable_Check(obj) || PyMethod_Check(obj)) {
/* We use function types here to make sure that our callback
* definitions exactly match the <curl/multi.h> interface.
*/
const curl_multi_timer_callback t_cb = multi_timer_callback;
const curl_socket_callback s_cb = multi_socket_callback;
switch(option) {
case CURLMOPT_SOCKETFUNCTION:
curl_multi_setopt(self->multi_handle, CURLMOPT_SOCKETFUNCTION, s_cb);
curl_multi_setopt(self->multi_handle, CURLMOPT_SOCKETDATA, self);
Py_INCREF(obj);
self->s_cb = obj;
break;
case CURLMOPT_TIMERFUNCTION:
curl_multi_setopt(self->multi_handle, CURLMOPT_TIMERFUNCTION, t_cb);
curl_multi_setopt(self->multi_handle, CURLMOPT_TIMERDATA, self);
Py_INCREF(obj);
self->t_cb = obj;
break;
default:
PyErr_SetString(PyExc_TypeError, "callables are not supported for this option");
return NULL;
}
Py_RETURN_NONE;
}
/* Failed to match any of the function signatures -- return error */
error:
PyErr_SetString(PyExc_TypeError, "invalid arguments to setopt");
return NULL;
}
