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; }