static void php_http_client_curl_event_dtor(void **context)
{
php_http_client_curl_event_context_t *ctx = *context;
php_http_client_curl_t *curl;
#if DBG_EVENTS
fprintf(stderr, "D");
#endif
curl = ctx->client->ctx;
curl_multi_setopt(curl->handle->multi, CURLMOPT_SOCKETDATA, NULL);
curl_multi_setopt(curl->handle->multi, CURLMOPT_SOCKETFUNCTION, NULL);
curl_multi_setopt(curl->handle->multi, CURLMOPT_TIMERDATA, NULL);
curl_multi_setopt(curl->handle->multi, CURLMOPT_TIMERFUNCTION, NULL);
if (event_initialized(ctx->timeout) && event_pending(ctx->timeout, EV_TIMEOUT, NULL)) {
event_del(ctx->timeout);
}
efree(ctx->timeout);
event_base_free(ctx->evbase);
efree(ctx);
*context = NULL;
}
static void *php_http_client_curl_event_init(php_http_client_t *client)
{
php_http_client_curl_t *curl = client->ctx;
php_http_client_curl_event_context_t *ctx;
struct event_base *evb = event_base_new();
#if DBG_EVENTS
fprintf(stderr, "I");
#endif
if (!evb) {
return NULL;
}
ctx = ecalloc(1, sizeof(*ctx));
ctx->client = client;
ctx->evbase = evb;
ctx->timeout = ecalloc(1, sizeof(struct event));
curl_multi_setopt(curl->handle->multi, CURLMOPT_SOCKETDATA, ctx);
curl_multi_setopt(curl->handle->multi, CURLMOPT_SOCKETFUNCTION, php_http_client_curl_event_socket);
curl_multi_setopt(curl->handle->multi, CURLMOPT_TIMERDATA, ctx);
curl_multi_setopt(curl->handle->multi, CURLMOPT_TIMERFUNCTION, php_http_client_curl_event_timer);
return ctx;
}
int main(int argc, char **argv)
{
GlobalInfo *g;
CURLMcode rc;
GMainLoop*gmain;
int fd;
GIOChannel* ch;
g=g_malloc0(sizeof(GlobalInfo));
fd=init_fifo();
ch=g_io_channel_unix_new(fd);
g_io_add_watch(ch,G_IO_IN,fifo_cb,g);
gmain=g_main_loop_new(NULL,FALSE);
g->multi = curl_multi_init();
curl_multi_setopt(g->multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g->multi, CURLMOPT_SOCKETDATA, g);
curl_multi_setopt(g->multi, CURLMOPT_TIMERFUNCTION, update_timeout_cb);
curl_multi_setopt(g->multi, CURLMOPT_TIMERDATA, g);
/* we don't call any curl_multi_socket*() function yet as we have no handles
added! */
g_main_loop_run(gmain);
curl_multi_cleanup(g->multi);
return 0;
}
int main(int argc, char **argv) {
int i;
loop = uv_default_loop();
if (curl_global_init(CURL_GLOBAL_ALL)) {
fprintf(stderr, "Could not init cURL\n");
return 1;
}
uv_timer_init(loop, &timeout);
curl_handle = curl_multi_init();
curl_multi_setopt(curl_handle, CURLMOPT_SOCKETFUNCTION, handle_socket);
curl_multi_setopt(curl_handle, CURLMOPT_TIMERFUNCTION, start_timeout);
char upstream[128];
memset(upstream,0,128);
snprintf(upstream,128,"%d:%s:%d",i,"upstream",i+1);
add_download(upstream,strlen(upstream));
uv_run(loop, UV_RUN_DEFAULT);
curl_multi_cleanup(curl_handle);
return 0;
}
static PyObject *
do_multi_setopt_callable(CurlMultiObject *self, int option, PyObject *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;
}
int main(int argc, char **argv)
{
loop = uv_default_loop();
if (argc <= 1)
return 0;
if (curl_global_init(CURL_GLOBAL_ALL)) {
fprintf(stderr, "Could not init cURL\n");
return 1;
}
uv_timer_init(loop, &timeout);
curl_handle = curl_multi_init();
curl_multi_setopt(curl_handle, CURLMOPT_SOCKETFUNCTION, handle_socket);
curl_multi_setopt(curl_handle, CURLMOPT_TIMERFUNCTION, start_timeout);
while (argc-- > 1) {
add_download(argv[argc], argc);
}
uv_run(loop, UV_RUN_DEFAULT);
curl_multi_cleanup(curl_handle);
return 0;
}
int main(int argc, char **argv)
{
GlobalInfo g;
CURLMcode rc;
(void)argc;
(void)argv;
memset(&g, 0, sizeof(GlobalInfo));
g.loop = ev_default_loop(0);
init_fifo(&g);
g.multi = curl_multi_init();
ev_timer_init(&g.timer_event, timer_cb, 0., 0.);
g.timer_event.data = &g;
g.fifo_event.data = &g;
curl_multi_setopt(g.multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g.multi, CURLMOPT_SOCKETDATA, &g);
curl_multi_setopt(g.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(g.multi, CURLMOPT_TIMERDATA, &g);
/* we don't call any curl_multi_socket*() function yet as we have no handles
added! */
ev_loop(g.loop, 0);
curl_multi_cleanup(g.multi);
return 0;
}
int main(int argc, char **argv)
{
GlobalInfo g;
(void)argc;
(void)argv;
memset(&g, 0, sizeof(GlobalInfo));
g.evbase = event_base_new();
init_fifo(&g);
g.multi = curl_multi_init();
g.timer_event = evtimer_new(g.evbase, timer_cb, &g);
/* setup the generic multi interface options we want */
curl_multi_setopt(g.multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g.multi, CURLMOPT_SOCKETDATA, &g);
curl_multi_setopt(g.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(g.multi, CURLMOPT_TIMERDATA, &g);
/* we don't call any curl_multi_socket*() function yet as we have no handles
added! */
event_base_dispatch(g.evbase);
/* this, of course, won't get called since only way to stop this program is
via ctrl-C, but it is here to show how cleanup /would/ be done. */
clean_fifo(&g);
event_free(g.timer_event);
event_base_free(g.evbase);
curl_multi_cleanup(g.multi);
return 0;
}
int main(int argc, char **argv)
{
GlobalInfo g;
CURLMcode rc;
(void)argc;
(void)argv;
memset(&g, 0, sizeof(GlobalInfo));
g.loop = ev_default_loop(0);
init_fifo(&g);
g.multi = curl_multi_init();
ev_timer_init(&g.timer_event, timer_cb, 0., 0.);
g.timer_event.data = &g;
g.fifo_event.data = &g;
curl_multi_setopt(g.multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g.multi, CURLMOPT_SOCKETDATA, &g);
curl_multi_setopt(g.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(g.multi, CURLMOPT_TIMERDATA, &g);
do
{
rc = curl_multi_socket_all(g.multi, &g.still_running);
} while ( CURLM_CALL_MULTI_PERFORM == rc );
ev_loop(g.loop, 0);
curl_multi_cleanup(g.multi);
return 0;
}
int main(int argc, char **argv)
{
GlobalInfo *g;
CURLMcode rc;
GMainLoop*gmain;
int fd;
GIOChannel* ch;
g=g_malloc0(sizeof(GlobalInfo));
fd=init_fifo();
ch=g_io_channel_unix_new(fd);
g_io_add_watch(ch,G_IO_IN,fifo_cb,g);
gmain=g_main_loop_new(NULL,FALSE);
g->multi = curl_multi_init();
curl_multi_setopt(g->multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g->multi, CURLMOPT_SOCKETDATA, g);
curl_multi_setopt(g->multi, CURLMOPT_TIMERFUNCTION, update_timeout_cb);
curl_multi_setopt(g->multi, CURLMOPT_TIMERDATA, g);
do {
rc = curl_multi_socket_all(g->multi, &g->still_running);
} while (CURLM_CALL_MULTI_PERFORM == rc);
g_main_loop_run(gmain);
curl_multi_cleanup(g->multi);
return 0;
}
int main(int argc, char **argv)
{
GlobalInfo g;
(void)argc;
(void)argv;
memset(&g, 0, sizeof(GlobalInfo));
event_init();
init_fifo(&g);
g.multi = curl_multi_init();
evtimer_set(&g.timer_event, timer_cb, &g);
/* setup the generic multi interface options we want */
curl_multi_setopt(g.multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g.multi, CURLMOPT_SOCKETDATA, &g);
curl_multi_setopt(g.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(g.multi, CURLMOPT_TIMERDATA, &g);
/* we don't call any curl_multi_socket*() function yet as we have no handles
added! */
event_dispatch();
curl_multi_cleanup(g.multi);
return 0;
}
int main(int argc, char **argv)
{
GlobalInfo g;
CURLMcode rc;
(void)argc;
(void)argv;
memset(&g, 0, sizeof(GlobalInfo));
g.multi = curl_multi_init();
curl_multi_setopt(g.multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g.multi, CURLMOPT_SOCKETDATA, &g);
curl_multi_setopt(g.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(g.multi, CURLMOPT_TIMERDATA, &g);
new_conn((char *)"www.google.com", &g); /* add a URL */
/* enter io_service run loop */
io_service.run();
curl_multi_cleanup(g.multi);
fprintf(MSG_OUT, "\ndone.\n");
return 0;
}
static int _php_curl_multi_setopt(php_curlm *mh, zend_long option, zval *zvalue, zval *return_value) /* {{{ */
{
CURLMcode error = CURLM_OK;
switch (option) {
#if LIBCURL_VERSION_NUM >= 0x071000 /* 7.16.0 */
case CURLMOPT_PIPELINING:
#endif
#if LIBCURL_VERSION_NUM >= 0x071003 /* 7.16.3 */
case CURLMOPT_MAXCONNECTS:
#endif
#if LIBCURL_VERSION_NUM >= 0x071e00 /* 7.30.0 */
case CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE:
case CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE:
case CURLMOPT_MAX_HOST_CONNECTIONS:
case CURLMOPT_MAX_PIPELINE_LENGTH:
case CURLMOPT_MAX_TOTAL_CONNECTIONS:
#endif
{
zend_long lval = zval_get_long(zvalue);
if (option == CURLMOPT_PIPELINING && (lval & 1)) {
#if LIBCURL_VERSION_NUM >= 0x073e00 /* 7.62.0 */
php_error_docref(NULL, E_WARNING, "CURLPIPE_HTTP1 is no longer supported");
#else
php_error_docref(NULL, E_DEPRECATED, "CURLPIPE_HTTP1 is deprecated");
#endif
}
error = curl_multi_setopt(mh->multi, option, lval);
break;
}
#if LIBCURL_VERSION_NUM > 0x072D00 /* Available since 7.45.0 */
case CURLMOPT_PUSHFUNCTION:
if (mh->handlers->server_push == NULL) {
mh->handlers->server_push = ecalloc(1, sizeof(php_curlm_server_push));
} else if (!Z_ISUNDEF(mh->handlers->server_push->func_name)) {
zval_ptr_dtor(&mh->handlers->server_push->func_name);
mh->handlers->server_push->fci_cache = empty_fcall_info_cache;
}
ZVAL_COPY(&mh->handlers->server_push->func_name, zvalue);
mh->handlers->server_push->method = PHP_CURL_USER;
error = curl_multi_setopt(mh->multi, option, _php_server_push_callback);
if (error != CURLM_OK) {
return 0;
}
error = curl_multi_setopt(mh->multi, CURLMOPT_PUSHDATA, mh);
break;
#endif
default:
php_error_docref(NULL, E_WARNING, "Invalid curl multi configuration option");
error = CURLM_UNKNOWN_OPTION;
break;
}
SAVE_CURLM_ERROR(mh, error);
return error != CURLM_OK;
}
void init_multi_handler() {
m_handler = curl_multi_init();
if (NULL == m_handler)
throw MyException("can't init curl");
curl_multi_setopt(m_handler, CURLMOPT_MAXCONNECTS, CONNECTIONS_MAX_NUMBER);
curl_multi_setopt(m_handler, CURLMOPT_PIPELINING, 1L);
}
void CurlPoller::run()
{
curl_multi_setopt(m_curlm, CURLMOPT_TIMERFUNCTION, timer_callback);
curl_multi_setopt(m_curlm, CURLMOPT_TIMERDATA, &m_curlTimeout);
while(!m_bAbort)
pollingCycle(false);
}
/*
* events_setup()
*
* Do the multi handle setups that only event-based transfers need.
*/
static void events_setup(struct Curl_multi *multi, struct events *ev)
{
/* timer callback */
curl_multi_setopt(multi, CURLMOPT_TIMERFUNCTION, events_timer);
curl_multi_setopt(multi, CURLMOPT_TIMERDATA, ev);
/* socket callback */
curl_multi_setopt(multi, CURLMOPT_SOCKETFUNCTION, events_socket);
curl_multi_setopt(multi, CURLMOPT_SOCKETDATA, ev);
}
/**
* Initializes the input/output part of the
* specified metha object
**/
M_CODE
lm_init_io(io_t *io, metha_t *m)
{
io->m = m;
#ifdef WIN32
io->synchronous = 1;
#endif
if (io->synchronous)
return M_OK;
if (!(io->multi_h = curl_multi_init())) {
LM_ERROR(m, "could not create CURL multi interface");
return M_FAILED;
}
if (!(io->share_h = curl_share_init())) {
LM_ERROR(m, "could not create CURL share interface");
return M_ERROR;
}
if (pipe(io->msg_fd) != 0) {
LM_ERROR(m, "pipe() failed: %s", strerror(errno));
return M_FAILED;
}
if (!(io->queue.pos = malloc(QUEUE_INIT_SIZE*sizeof(ioqp_t))))
return M_OUT_OF_MEM;
io->queue.allocsz = QUEUE_INIT_SIZE;
io->queue.size = 0;
io->started = 0;
pthread_mutex_init(&io->queue_mtx, 0);
pthread_rwlock_init(&io->cookies_mtx, 0);
pthread_rwlock_init(&io->dns_mtx, 0);
pthread_rwlock_init(&io->share_mtx, 0);
if (io->cookies)
curl_share_setopt(io->share_h, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
curl_share_setopt(io->share_h, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
curl_share_setopt(io->share_h, CURLSHOPT_LOCKFUNC, &lm_iothr_lock_shared_cb);
curl_share_setopt(io->share_h, CURLSHOPT_UNLOCKFUNC, &lm_iothr_unlock_shared_cb);
curl_share_setopt(io->share_h, CURLSHOPT_USERDATA, io);
curl_multi_setopt(io->multi_h, CURLMOPT_SOCKETFUNCTION, &lm_iothr_socket_cb);
curl_multi_setopt(io->multi_h, CURLMOPT_SOCKETDATA, io);
curl_multi_setopt(io->multi_h, CURLMOPT_TIMERFUNCTION, &lm_iothr_set_timer_cb);
curl_multi_setopt(io->multi_h, CURLMOPT_TIMERDATA, io);
/*curl_multi_setopt(io->multi_h, CURLMOPT_PIPELINING, 1);*/
return M_OK;
}
http_client::http_client(boost::asio::io_service& io_service) :
_io_service(io_service),
_timer(_io_service),
_keepalive_timer(_io_service) {
_multi = curl_multi_init();
curl_multi_setopt(_multi, CURLMOPT_SOCKETFUNCTION, _sock_cb);
curl_multi_setopt(_multi, CURLMOPT_SOCKETDATA, this);
curl_multi_setopt(_multi, CURLMOPT_TIMERFUNCTION, _multi_timer_cb);
curl_multi_setopt(_multi, CURLMOPT_TIMERDATA, this);
_keepalive_timer.expires_from_now(boost::chrono::milliseconds(1000));
_keepalive_timer.async_wait(boost::bind(&http_client::keepalivetimer_cb, this, _1));
}
ConnectionManager::ConnectionManager(const std::shared_ptr<SocketFactory>& socket_factory,
const std::shared_ptr<SocketWatcher>& socket_watcher,
const std::shared_ptr<Timer>& timer) :
socket_factory_(socket_factory),
socket_watcher_(socket_watcher),
timer_(timer) {
multi_handle_ = curl_multi_init();
curl_multi_setopt(multi_handle_, CURLMOPT_TIMERFUNCTION, CurlTimerCallback);
curl_multi_setopt(multi_handle_, CURLMOPT_TIMERDATA, this);
curl_multi_setopt(multi_handle_, CURLMOPT_SOCKETFUNCTION, CurlSocketCallback);
curl_multi_setopt(multi_handle_, CURLMOPT_SOCKETDATA, this);
}
CURLMcode debug_curl_multi_setopt(CURLM* multi_handle, CURLMoption option, ...)
{
CURLMcode ret = CURLM_UNKNOWN_OPTION; // Suppress compiler warning.
va_list ap;
union param_type {
long along;
void* ptr;
curl_off_t offset;
} param;
unsigned int param_type = (option / 10000) * 10000;
va_start(ap, option);
switch (param_type)
{
case CURLOPTTYPE_LONG:
param.along = va_arg(ap, long);
break;
case CURLOPTTYPE_OBJECTPOINT:
case CURLOPTTYPE_FUNCTIONPOINT:
param.ptr = va_arg(ap, void*);
break;
case CURLOPTTYPE_OFF_T:
param.offset = va_arg(ap, curl_off_t);
break;
default:
std::cerr << "Extracting param_type failed; option = " << option << "; param_type = " << param_type << std::endl;
std::exit(EXIT_FAILURE);
}
va_end(ap);
switch (param_type)
{
case CURLOPTTYPE_LONG:
ret = curl_multi_setopt(multi_handle, option, param.along);
Dout(dc::curl, "curl_easy_setopt(" << (AICURLM*)multi_handle << ", " << option << ", " << param.along << "L) = " << ret);
break;
case CURLOPTTYPE_OBJECTPOINT:
ret = curl_multi_setopt(multi_handle, option, param.ptr);
Dout(dc::curl, "curl_easy_setopt(" << (AICURLM*)multi_handle << ", " << option << ", (object*)0x" << std::hex << (size_t)param.ptr << std::dec << ") = " << ret);
break;
case CURLOPTTYPE_FUNCTIONPOINT:
ret = curl_multi_setopt(multi_handle, option, param.ptr);
Dout(dc::curl, "curl_easy_setopt(" << (AICURLM*)multi_handle << ", " << option << ", (function*)0x" << std::hex << (size_t)param.ptr << std::dec << ") = " << ret);
break;
case CURLOPTTYPE_OFF_T:
ret = curl_multi_setopt(multi_handle, option, param.offset);
Dout(dc::curl, "curl_easy_setopt(" << (AICURLM*)multi_handle << ", " << option << ", (curl_off_t)" << param.offset << ") = " << ret);
break;
default: // Stop compiler complaining about no default.
break;
}
return ret;
}
Context::Context( boost::asio::io_service& io_service, bool verify_ssl_peer )
: timer_( io_service )
, strand_( io_service )
, io_service_( io_service )
, still_running_( 0 )
, verify_ssl_peer_( verify_ssl_peer )
{
multi_ = curl_multi_init();
curl_multi_setopt(multi_, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(multi_, CURLMOPT_SOCKETDATA, this);
curl_multi_setopt(multi_, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(multi_, CURLMOPT_TIMERDATA, this);
}
MultiAdapter::MultiAdapter(boost::asio::io_service & theIOService) :
io(theIOService),
_strand(theIOService)
{
_curlMulti = curl_multi_init();
CURLMcode myStatus = curl_multi_setopt(_curlMulti, CURLMOPT_SOCKETFUNCTION, &MultiAdapter::curl_socket_callback);
checkCurlStatus(myStatus, PLUS_FILE_LINE);
myStatus = curl_multi_setopt(_curlMulti, CURLMOPT_SOCKETDATA, this);
checkCurlStatus(myStatus, PLUS_FILE_LINE);
myStatus = curl_multi_setopt(_curlMulti, CURLMOPT_TIMERFUNCTION, &MultiAdapter::curl_timer_callback);
checkCurlStatus(myStatus, PLUS_FILE_LINE);
myStatus = curl_multi_setopt(_curlMulti, CURLMOPT_TIMERDATA, this);
checkCurlStatus(myStatus, PLUS_FILE_LINE);
};
/* }}} */
#endif
#if LIBCURL_VERSION_NUM >= 0x070f04 /* 7.15.4 */
static int _php_curl_multi_setopt(php_curlm *mh, zend_long option, zval *zvalue, zval *return_value) /* {{{ */
{
CURLMcode error = CURLM_OK;
switch (option) {
#if LIBCURL_VERSION_NUM >= 0x071000 /* 7.16.0 */
case CURLMOPT_PIPELINING:
#endif
#if LIBCURL_VERSION_NUM >= 0x071003 /* 7.16.3 */
case CURLMOPT_MAXCONNECTS:
#endif
error = curl_multi_setopt(mh->multi, option, zval_get_long(zvalue));
break;
default:
php_error_docref(NULL, E_WARNING, "Invalid curl multi configuration option");
error = CURLM_UNKNOWN_OPTION;
break;
}
if (error != CURLM_OK) {
return 1;
} else {
return 0;
}
}
void glibcurl_init() {
int fd;
/* Create source object for curl file descriptors, and hook it into the
default main context. */
curlSrc = (CurlGSource*)g_source_new(&curlFuncs, sizeof(CurlGSource));
g_source_attach(&curlSrc->source, NULL);
/* Init rest of our data */
memset(&curlSrc->lastPollFd, 0, sizeof(curlSrc->lastPollFd));
for (fd = 1; fd <= GLIBCURL_FDMAX; ++fd)
curlSrc->lastPollFd[fd].fd = fd;
curlSrc->lastPollFdMax = 0;
curlSrc->callPerform = 0;
/* Init libcurl */
curl_global_init(CURL_GLOBAL_ALL);
curlSrc->multiHandle = curl_multi_init();
curl_multi_setopt(curlSrc->multiHandle, CURLMOPT_MAXCONNECTS, 4);
g_source_set_priority((GSource*)glibcurl_handle(), G_PRIORITY_DEFAULT_IDLE);
D((stderr, "events: R=%x W=%x X=%x\n", GLIBCURL_READ, GLIBCURL_WRITE,
GLIBCURL_EXC));
s_numEasyHandles = 0;
s_currTimeout = 0;
s_timeAtLastDispatch.tv_sec = 0;
s_timeAtLastDispatch.tv_nsec = 0;
}
int start_full_download(bool pipelining)
{
int i;
failed = NULL;
for (i = 0; i < SWUPD_CURL_HASH_BUCKETS; i++) {
pthread_mutex_init(&swupd_curl_hashmap[i].mutex, NULL);
}
mcurl = curl_multi_init();
if (mcurl == NULL) {
return -1;
}
/*
* we want to not do HTTP pipelining once things have failed once.. in case some transpoxy in the middle
* is even more broken than average. This at least will allow the user to update, albeit slowly.
*/
if (pipelining) {
curl_multi_setopt(mcurl, CURLMOPT_PIPELINING, 1);
} else {
/* survival: don't go too parallel in verify/fix loop */
MAX_XFER = 1;
MAX_XFER_BOTTOM = 1;
}
printf("Starting download of remaining update content. This may take a while...\n");
return 0;
}
void socketmanager::InitMultiIOHandlerCommon() {
LogMsg(LOGT::SOCKTRACE, "socketmanager::InitMultiIOHandlerCommon: START");
st.reset(new sockettimeout(*this));
curlmulti=curl_multi_init();
curl_multi_setopt(curlmulti, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(curlmulti, CURLMOPT_SOCKETDATA, this);
curl_multi_setopt(curlmulti, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(curlmulti, CURLMOPT_TIMERDATA, this);
curl_version_info_data *data = curl_version_info(CURLVERSION_NOW);
if (!(data->features & CURL_VERSION_ASYNCHDNS)) {
LogMsg(LOGT::SOCKTRACE, "This version of libcurl does not support asynchronous DNS resolution, using a workaround.");
asyncdns.reset(new adns(this));
}
LogMsg(LOGT::SOCKTRACE, "socketmanager::InitMultiIOHandlerCommon: END");
}
CurlPoller::CurlPoller()
: m_bAbort(false), m_timeout(0), m_usersLock(QMutex::Recursive)
{
m_curlTimeout = 0;
curl_global_init(CURL_GLOBAL_SSL);
m_curlm = curl_multi_init();
m_poller = Poller::createInstance(this);
curl_multi_setopt(m_curlm, CURLMOPT_SOCKETFUNCTION, socket_callback);
curl_multi_setopt(m_curlm, CURLMOPT_SOCKETDATA, static_cast<CurlPoller*>(this));
if(!m_instance)
{
m_instance = this;
start();
}
}
void rb_http_handler_run(struct rb_http_handler_s *rb_http_handler) {
assert(rb_http_handler != NULL);
assert(rb_http_handler->options != NULL);
int i = 0;
struct rb_http_threaddata_s *rb_http_threaddata = NULL;
switch (rb_http_handler->options->mode) {
case NORMAL_MODE:
default:
rb_http_threaddata = calloc(1, sizeof(struct rb_http_threaddata_s));
rb_http_handler->threads[0] = rb_http_threaddata;
rd_fifoq_init(&rb_http_threaddata->rfq);
rd_fifoq_init(&rb_http_handler->rfq_reports);
rb_http_threaddata->rfq_pending = NULL;
rb_http_threaddata->rb_http_handler = rb_http_handler;
rb_http_threaddata->opaque = NULL;
rb_http_handler->options->max_batch_messages =
rb_http_handler->options->max_messages / 10;
rb_http_handler->multi_handle = curl_multi_init();
curl_multi_setopt(rb_http_handler->multi_handle,
CURLMOPT_MAX_TOTAL_CONNECTIONS,
rb_http_handler->options->connections);
pthread_create(&rb_http_threaddata->p_thread, NULL, &rb_http_process_normal,
rb_http_threaddata);
break;
case CHUNKED_MODE:
for (i = 0; i < rb_http_handler->options->connections; i++) {
rb_http_threaddata = calloc(1, sizeof(struct rb_http_threaddata_s));
rb_http_handler->threads[i] = rb_http_threaddata;
rb_http_handler->options->max_batch_messages =
rb_http_handler->options->max_messages / 10;
rb_http_handler->options->post_timeout =
rb_http_handler->options->batch_timeout;
rd_fifoq_init(&rb_http_threaddata->rfq);
rb_http_threaddata->post_timestamp = time(NULL);
rb_http_threaddata->rfq_pending = NULL;
rb_http_threaddata->rb_http_handler = rb_http_handler;
rb_http_threaddata->easy_handle = curl_easy_init();
rb_http_threaddata->chunks = 0;
rb_http_threaddata->opaque = NULL;
if (rb_http_handler->options->insecure) {
curl_easy_setopt(rb_http_threaddata->easy_handle,
CURLOPT_SSL_VERIFYPEER, 0);
curl_easy_setopt(rb_http_threaddata->easy_handle,
CURLOPT_SSL_VERIFYHOST, 0);
}
pthread_create(&rb_http_threaddata->p_thread, NULL,
&rb_http_process_chunked, rb_http_threaddata);
}
break;
}
}
static void curl_attach_aio_context(BlockDriverState *bs,
AioContext *new_context)
{
BDRVCURLState *s = bs->opaque;
aio_timer_init(new_context, &s->timer,
QEMU_CLOCK_REALTIME, SCALE_NS,
curl_multi_timeout_do, s);
assert(!s->multi);
s->multi = curl_multi_init();
s->aio_context = new_context;
curl_multi_setopt(s->multi, CURLMOPT_SOCKETFUNCTION, curl_sock_cb);
#ifdef NEED_CURL_TIMER_CALLBACK
curl_multi_setopt(s->multi, CURLMOPT_TIMERDATA, s);
curl_multi_setopt(s->multi, CURLMOPT_TIMERFUNCTION, curl_timer_cb);
#endif
}
/*
* call-seq:
* multi = Curl::Multi.new
* multi.pipeline = true
*
* Pass a long set to 1 to enable or 0 to disable. Enabling pipelining on a multi handle will make it
* attempt to perform HTTP Pipelining as far as possible for transfers using this handle. This means
* that if you add a second request that can use an already existing connection, the second request will
* be "piped" on the same connection rather than being executed in parallel. (Added in 7.16.0)
*
*/
static VALUE ruby_curl_multi_pipeline(VALUE self, VALUE onoff) {
#ifdef HAVE_CURLMOPT_PIPELINING
ruby_curl_multi *rbcm;
Data_Get_Struct(self, ruby_curl_multi, rbcm);
curl_multi_setopt(rbcm->handle, CURLMOPT_PIPELINING, onoff == Qtrue ? 1 : 0);
#endif
return onoff;
}
