314 lines
9.8 KiB
C
314 lines
9.8 KiB
C
/*=============================================================================
|
|
curlMulti
|
|
===============================================================================
|
|
This is an extension to Curl's CURLM object. The extensions are:
|
|
|
|
1) It has a lock so multiple threads can use it simultaneously.
|
|
|
|
2) Its "select" file descriptor vectors are self-contained. CURLM
|
|
requires the user to maintain them separately.
|
|
=============================================================================*/
|
|
|
|
#define _XOPEN_SOURCE 600 /* Make sure strdup() is in <string.h> */
|
|
|
|
#include "xmlrpc_config.h"
|
|
|
|
#include <stdlib.h>
|
|
#if HAVE_SYS_SELECT_H
|
|
#include <sys/select.h>
|
|
#endif
|
|
|
|
#include <curl/curl.h>
|
|
#include <curl/types.h>
|
|
#include <curl/easy.h>
|
|
#include <curl/multi.h>
|
|
|
|
#include "mallocvar.h"
|
|
#include "xmlrpc-c/util.h"
|
|
#include "xmlrpc-c/string_int.h"
|
|
|
|
#include "curlversion.h"
|
|
#include "lock.h"
|
|
#include "lock_pthread.h"
|
|
|
|
#include "curlmulti.h"
|
|
|
|
|
|
|
|
static void
|
|
interpretCurlMultiError(const char ** const descriptionP,
|
|
CURLMcode const code) {
|
|
|
|
#if HAVE_CURL_STRERROR
|
|
*descriptionP = strdup(curl_multi_strerror(code));
|
|
#else
|
|
xmlrpc_asprintf(descriptionP, "Curl error code (CURLMcode) %d", code);
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
struct curlMulti {
|
|
CURLM * curlMultiP;
|
|
lock * lockP;
|
|
/* Hold this lock while accessing or using *curlMultiP. You're
|
|
using the multi manager whenever you're calling a Curl
|
|
library multi manager function.
|
|
*/
|
|
/* The following file descriptor sets are an integral part of the
|
|
CURLM object; Our curlMulti_fdset() routine binds them to the
|
|
CURLM object, and said object expects us to use them in a very
|
|
specific way, including doing a select() on them. It is very,
|
|
very messy.
|
|
*/
|
|
fd_set readFdSet;
|
|
fd_set writeFdSet;
|
|
fd_set exceptFdSet;
|
|
};
|
|
|
|
|
|
|
|
curlMulti *
|
|
curlMulti_create(void) {
|
|
|
|
curlMulti * retval;
|
|
curlMulti * curlMultiP;
|
|
|
|
MALLOCVAR(curlMultiP);
|
|
|
|
if (curlMultiP == NULL)
|
|
retval = NULL;
|
|
else {
|
|
curlMultiP->lockP = curlLock_create_pthread();
|
|
|
|
if (curlMultiP->lockP == NULL)
|
|
retval = NULL;
|
|
else {
|
|
curlMultiP->curlMultiP = curl_multi_init();
|
|
if (curlMultiP->curlMultiP == NULL)
|
|
retval = NULL;
|
|
else
|
|
retval = curlMultiP;
|
|
|
|
if (retval == NULL)
|
|
curlMultiP->lockP->destroy(curlMultiP->lockP);
|
|
}
|
|
if (retval == NULL)
|
|
free(curlMultiP);
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
curlMulti_destroy(curlMulti * const curlMultiP) {
|
|
|
|
curl_multi_cleanup(curlMultiP->curlMultiP);
|
|
|
|
curlMultiP->lockP->destroy(curlMultiP->lockP);
|
|
|
|
free(curlMultiP);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
curlMulti_perform(xmlrpc_env * const envP,
|
|
curlMulti * const curlMultiP,
|
|
bool * const immediateWorkToDoP,
|
|
int * const runningHandlesP) {
|
|
/*----------------------------------------------------------------------------
|
|
Do whatever work is ready to be done under the control of multi
|
|
manager 'curlMultiP'. E.g. if HTTP response data has recently arrived
|
|
from the network, process it as an HTTP response.
|
|
|
|
Iff this results in some work being finished from our point of view,
|
|
return *immediateWorkToDoP. (Caller can query the multi manager for
|
|
messages and find out what it is).
|
|
|
|
Return as *runningHandlesP the number of Curl easy handles under the
|
|
multi manager's control that are still running -- yet to finish.
|
|
-----------------------------------------------------------------------------*/
|
|
CURLMcode rc;
|
|
|
|
curlMultiP->lockP->acquire(curlMultiP->lockP);
|
|
|
|
rc = curl_multi_perform(curlMultiP->curlMultiP, runningHandlesP);
|
|
|
|
curlMultiP->lockP->release(curlMultiP->lockP);
|
|
|
|
if (rc == CURLM_CALL_MULTI_PERFORM) {
|
|
*immediateWorkToDoP = true;
|
|
} else {
|
|
*immediateWorkToDoP = false;
|
|
|
|
if (rc != CURLM_OK) {
|
|
const char * reason;
|
|
interpretCurlMultiError(&reason, rc);
|
|
xmlrpc_faultf(envP, "Impossible failure of curl_multi_perform(): "
|
|
"%s", reason);
|
|
xmlrpc_strfree(reason);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void
|
|
curlMulti_addHandle(xmlrpc_env * const envP,
|
|
curlMulti * const curlMultiP,
|
|
CURL * const curlSessionP) {
|
|
|
|
CURLMcode rc;
|
|
|
|
curlMultiP->lockP->acquire(curlMultiP->lockP);
|
|
|
|
rc = curl_multi_add_handle(curlMultiP->curlMultiP, curlSessionP);
|
|
|
|
curlMultiP->lockP->release(curlMultiP->lockP);
|
|
|
|
if (rc != CURLM_OK) {
|
|
const char * reason;
|
|
interpretCurlMultiError(&reason, rc);
|
|
xmlrpc_faultf(envP, "Could not add Curl session to the "
|
|
"curl multi manager. curl_multi_add_handle() "
|
|
"failed: %s", reason);
|
|
xmlrpc_strfree(reason);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
curlMulti_removeHandle(curlMulti * const curlMultiP,
|
|
CURL * const curlSessionP) {
|
|
|
|
curlMultiP->lockP->acquire(curlMultiP->lockP);
|
|
|
|
curl_multi_remove_handle(curlMultiP->curlMultiP, curlSessionP);
|
|
|
|
curlMultiP->lockP->release(curlMultiP->lockP);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
curlMulti_getMessage(curlMulti * const curlMultiP,
|
|
bool * const endOfMessagesP,
|
|
CURLMsg * const curlMsgP) {
|
|
/*----------------------------------------------------------------------------
|
|
Get the next message from the queue of things the Curl multi manager
|
|
wants to say to us.
|
|
|
|
Return the message as *curlMsgP.
|
|
|
|
Iff there are no messages in the queue, return *endOfMessagesP == true.
|
|
-----------------------------------------------------------------------------*/
|
|
int remainingMsgCount;
|
|
CURLMsg * privateCurlMsgP;
|
|
/* Note that this is a pointer into the multi manager's memory,
|
|
so we have to use it under lock.
|
|
*/
|
|
|
|
curlMultiP->lockP->acquire(curlMultiP->lockP);
|
|
|
|
privateCurlMsgP = curl_multi_info_read(curlMultiP->curlMultiP,
|
|
&remainingMsgCount);
|
|
|
|
if (privateCurlMsgP == NULL)
|
|
*endOfMessagesP = true;
|
|
else {
|
|
*endOfMessagesP = false;
|
|
*curlMsgP = *privateCurlMsgP;
|
|
}
|
|
curlMultiP->lockP->release(curlMultiP->lockP);
|
|
}
|
|
|
|
|
|
|
|
void
|
|
curlMulti_fdset(xmlrpc_env * const envP,
|
|
curlMulti * const curlMultiP,
|
|
fd_set * const readFdSetP,
|
|
fd_set * const writeFdSetP,
|
|
fd_set * const exceptFdSetP,
|
|
int * const maxFdP) {
|
|
/*----------------------------------------------------------------------------
|
|
Set the CURLM object's file descriptor sets to those in the
|
|
curlMulti object, update those file descriptor sets with the
|
|
current needs of the multi manager, and return the resulting values
|
|
of the file descriptor sets.
|
|
|
|
This is a bizarre operation, but is necessary because of the nonmodular
|
|
way in which the Curl multi interface works with respect to waiting
|
|
for work with select().
|
|
-----------------------------------------------------------------------------*/
|
|
CURLMcode rc;
|
|
|
|
curlMultiP->lockP->acquire(curlMultiP->lockP);
|
|
|
|
/* curl_multi_fdset() doesn't _set_ the fdsets. It adds to existing
|
|
ones (so you can easily do a select() on other fds and Curl
|
|
fds at the same time). So we have to clear first:
|
|
*/
|
|
FD_ZERO(&curlMultiP->readFdSet);
|
|
FD_ZERO(&curlMultiP->writeFdSet);
|
|
FD_ZERO(&curlMultiP->exceptFdSet);
|
|
|
|
/* WARNING: curl_multi_fdset() doesn't just update the fdsets pointed
|
|
to by its arguments. It makes the CURLM object remember those
|
|
pointers and refer back to them later! In fact, curl_multi_perform
|
|
expects its caller to have done a select() on those masks. No,
|
|
really. The man page even admits it.
|
|
|
|
Inspection of the Libcurl code in March 2007 indicates that
|
|
this isn't actually true -- curl_multi_fdset() updates your
|
|
fdset and doesn't remember the pointer at all. I.e. it's just
|
|
what you would expect. The man pages still says it's as
|
|
described above. My guess is that Libcurl was fixed at some
|
|
time and the man page not updated. In any case, we have to
|
|
work with old Libcurl if at all possible, so we still maintain
|
|
these fdsets as if they belong to the CURLM object.
|
|
*/
|
|
|
|
rc = curl_multi_fdset(curlMultiP->curlMultiP,
|
|
&curlMultiP->readFdSet,
|
|
&curlMultiP->writeFdSet,
|
|
&curlMultiP->exceptFdSet,
|
|
maxFdP);
|
|
|
|
*readFdSetP = curlMultiP->readFdSet;
|
|
*writeFdSetP = curlMultiP->writeFdSet;
|
|
*exceptFdSetP = curlMultiP->exceptFdSet;
|
|
|
|
curlMultiP->lockP->release(curlMultiP->lockP);
|
|
|
|
if (rc != CURLM_OK) {
|
|
const char * reason;
|
|
interpretCurlMultiError(&reason, rc);
|
|
xmlrpc_faultf(envP, "Impossible failure of curl_multi_fdset(): %s",
|
|
reason);
|
|
xmlrpc_strfree(reason);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void
|
|
curlMulti_updateFdSet(curlMulti * const curlMultiP,
|
|
fd_set const readFdSet,
|
|
fd_set const writeFdSet,
|
|
fd_set const exceptFdSet) {
|
|
/*----------------------------------------------------------------------------
|
|
curl_multi_perform() expects the file descriptor sets, which were bound
|
|
to the CURLM object via a prior curlMulti_fdset(), to contain the results
|
|
of a recent select(). This subroutine provides you a way to supply those.
|
|
-----------------------------------------------------------------------------*/
|
|
curlMultiP->readFdSet = readFdSet;
|
|
curlMultiP->writeFdSet = writeFdSet;
|
|
curlMultiP->exceptFdSet = exceptFdSet;
|
|
}
|
|
|
|
|
|
|