void DL_InitDownload() { if ( dl_initialized ) { return; } /* Make sure curl has initialized, so the cleanup doesn't get confused */ curl_global_init( CURL_GLOBAL_ALL ); dl_multi = curl_multi_init(); Com_Printf( "Client download subsystem initialized\n" ); dl_initialized = 1; }
static int child_init(int rank) { if (rank <= PROC_MAIN) return 0; multi_handle = curl_multi_init(); if (!multi_handle) { LM_ERR("failed to init CURLM handle\n"); return -1; } return 0; }
void wswcurl_init( void ) { wswcurl_mempool = Mem_AllocPool( NULL, "Curl" ); curldummy = curl_easy_init(); curlmulti = curl_multi_init(); http_requests_mutex = QMutex_Create(); // HTTP proxy settings http_proxy = Cvar_Get( "http_proxy", "", CVAR_ARCHIVE ); http_proxyuserpwd = Cvar_Get( "http_proxyuserpwd", "", CVAR_ARCHIVE ); }
kn_CURLM_t kn_CURLM_init(engine_t e){ pthread_once(&g_curl_key_once,curl_once_routine); CURLM *c = curl_multi_init(); if(!c) return NULL; kn_CURLM_t cm = calloc(1,sizeof(*cm)); cm->c_handle = c; cm->e = e; kn_dlist_init(&cm->curls); curl_multi_setopt(c, CURLMOPT_SOCKETFUNCTION, handle_socket); //curl_multi_setopt(c, CURLMOPT_TIMERDATA, cm); //curl_multi_setopt(c, CURLMOPT_TIMERFUNCTION, start_timeout); return cm; }
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); }
int IO::init() { assert (m_initialised == false); curl_global_init(CURL_GLOBAL_ALL); m_mhandle = curl_multi_init(); #ifdef HAVE_CURL_MULTI_PIPELINING curl_multi_setopt(m_mhandle, CURLMOPT_PIPELINING, 1); #endif m_initialised = true; return 0; }
URL_FILE *url_fopen(const char *url, const char *operation) { /* this code could check for URLs or types in the 'url' and basically use the real fopen() for standard files */ URL_FILE *file; (void)operation; file = malloc(sizeof(URL_FILE)); if(!file) return NULL; memset(file, 0, sizeof(URL_FILE)); if((file->handle.file=fopen(url, operation))) file->type = CFTYPE_FILE; /* marked as URL */ else { file->type = CFTYPE_CURL; /* marked as URL */ file->handle.curl = curl_easy_init(); curl_easy_setopt(file->handle.curl, CURLOPT_URL, url); curl_easy_setopt(file->handle.curl, CURLOPT_WRITEDATA, file); curl_easy_setopt(file->handle.curl, CURLOPT_VERBOSE, 0L); curl_easy_setopt(file->handle.curl, CURLOPT_WRITEFUNCTION, write_callback); if(!multi_handle) multi_handle = curl_multi_init(); curl_multi_add_handle(multi_handle, file->handle.curl); /* lets start the fetch */ curl_multi_perform(multi_handle, &file->still_running); if((file->buffer_pos == 0) && (!file->still_running)) { /* if still_running is 0 now, we should return NULL */ /* make sure the easy handle is not in the multi handle anymore */ curl_multi_remove_handle(multi_handle, file->handle.curl); /* cleanup */ curl_easy_cleanup(file->handle.curl); free(file); file = NULL; } } return file; }
void LLXMLRPCTransaction::Impl::init(XMLRPC_REQUEST request, bool useGzip) { mCurl = curl_easy_init(); if (gSavedSettings.getBOOL("BrowserProxyEnabled")) { mProxyAddress = gSavedSettings.getString("BrowserProxyAddress"); S32 port = gSavedSettings.getS32 ( "BrowserProxyPort" ); // tell curl about the settings curl_easy_setopt(mCurl, CURLOPT_PROXY, mProxyAddress.c_str()); curl_easy_setopt(mCurl, CURLOPT_PROXYPORT, (long)port); curl_easy_setopt(mCurl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP); }; // curl_easy_setopt(mCurl, CURLOPT_VERBOSE, 1); // usefull for debugging curl_easy_setopt(mCurl, CURLOPT_NOSIGNAL, 1); curl_easy_setopt(mCurl, CURLOPT_WRITEFUNCTION, &curlDownloadCallback); curl_easy_setopt(mCurl, CURLOPT_WRITEDATA, this); curl_easy_setopt(mCurl, CURLOPT_ERRORBUFFER, &mCurlErrorBuffer); curl_easy_setopt(mCurl, CURLOPT_CAINFO, gDirUtilp->getCAFile().c_str()); curl_easy_setopt(mCurl, CURLOPT_SSL_VERIFYPEER, gVerifySSLCert); curl_easy_setopt(mCurl, CURLOPT_SSL_VERIFYHOST, gVerifySSLCert? 2 : 0); /* Setting the DNS cache timeout to -1 disables it completely. This might help with bug #503 */ curl_easy_setopt(mCurl, CURLOPT_DNS_CACHE_TIMEOUT, -1); mHeaders = curl_slist_append(mHeaders, "Content-Type: text/xml"); curl_easy_setopt(mCurl, CURLOPT_URL, mURI.c_str()); curl_easy_setopt(mCurl, CURLOPT_HTTPHEADER, mHeaders); if (useGzip) { curl_easy_setopt(mCurl, CURLOPT_ENCODING, ""); } mRequestText = XMLRPC_REQUEST_ToXML(request, &mRequestTextSize); if (mRequestText) { curl_easy_setopt(mCurl, CURLOPT_POSTFIELDS, mRequestText); curl_easy_setopt(mCurl, CURLOPT_POSTFIELDSIZE, mRequestTextSize); } else { setStatus(StatusOtherError); } mCurlMulti = curl_multi_init(); curl_multi_add_handle(mCurlMulti, mCurl); }
int test(char *URL) { CURLM *cm = NULL; struct curl_slist *headers = NULL; char buffer[246]; /* naively fixed-size */ int res; if(test_argc < 4) return 99; sprintf(buffer, "Host: %s", HOST); /* now add a custom Host: header */ headers = curl_slist_append(headers, buffer); if(!headers) { fprintf(stderr, "curl_slist_append() failed\n"); return TEST_ERR_MAJOR_BAD; } if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) { fprintf(stderr, "curl_global_init() failed\n"); curl_slist_free_all(headers); return TEST_ERR_MAJOR_BAD; } if ((cm = curl_multi_init()) == NULL) { fprintf(stderr, "curl_multi_init() failed\n"); curl_slist_free_all(headers); curl_global_cleanup(); return TEST_ERR_MAJOR_BAD; } res = loop(cm, URL, PROXYUSERPWD, headers); if(res) goto test_cleanup; fprintf(stderr, "lib540: now we do the request again\n"); res = loop(cm, URL, PROXYUSERPWD, headers); test_cleanup: curl_multi_cleanup(cm); curl_global_cleanup(); curl_slist_free_all(headers); return res; }
jsr_curlm_t * jsr_curlm_new(void) { jsr_curlm_t *jsr_curlm = (jsr_curlm_t *)malloc(sizeof(jsr_curlm_t)); if (!jsr_curlm) return NULL; jsr_curlm->multi_handle = curl_multi_init(); jsr_curlm->list = jsr_list_new(); jsr_curlm->running_handles = 1; jsr_curlm->timeout = 1; return jsr_curlm; }
/** * Setup http_client plugin * * @param plugin the plugin handle * @return GNUNET_OK on success, GNUNET_SYSERR on error */ static int client_start (struct HTTP_Client_Plugin *plugin) { curl_global_init (CURL_GLOBAL_ALL); plugin->curl_multi_handle = curl_multi_init (); if (NULL == plugin->curl_multi_handle) { GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, plugin->name, _("Could not initialize curl multi handle, failed to start %s plugin!\n"), plugin->name); return GNUNET_SYSERR; } return GNUNET_OK; }
void RequestManager::Initialise(ByteString Proxy) { curl_global_init(CURL_GLOBAL_DEFAULT); multi = curl_multi_init(); if (multi) { curl_multi_setopt(multi, CURLMOPT_MAX_HOST_CONNECTIONS, curl_max_host_connections); } proxy = Proxy; user_agent = ByteString::Build("PowderToy/", SAVE_VERSION, ".", MINOR_VERSION, " (", IDENT_PLATFORM, "; ", IDENT_BUILD, "; M", MOD_ID, ") TPTPP/", SAVE_VERSION, ".", MINOR_VERSION, ".", BUILD_NUM, IDENT_RELTYPE, ".", SNAPSHOT_ID); worker_thread = std::thread([this]() { Worker(); }); }
MULTI_CONTEXT* __stdcall vbcurl_multi_init() { MULTI_CONTEXT* pmc = NULL; CURLM* pm = curl_multi_init(); if (!pm) return NULL; pmc = (MULTI_CONTEXT*)malloc(sizeof(MULTI_CONTEXT)); pmc->_magic = MULTI_MAGIC; pmc->_multi = pm; FD_ZERO(&pmc->_readSet); FD_ZERO(&pmc->_writeSet); FD_ZERO(&pmc->_excSet); pmc->_maxFD = 0; return pmc; }
/** * Initialises the Ecore_Con_Url library. * @return Number of times the library has been initialised without being * shut down. * @ingroup Ecore_Con_Url_Group */ EAPI int ecore_con_url_init(void) { #ifdef HAVE_CURL init_count++; if (init_count > 1) return init_count; if (!ECORE_CON_EVENT_URL_DATA) { ECORE_CON_EVENT_URL_DATA = ecore_event_type_new(); ECORE_CON_EVENT_URL_COMPLETE = ecore_event_type_new(); ECORE_CON_EVENT_URL_PROGRESS = ecore_event_type_new(); } if (!curlm) { long ms; FD_ZERO(&_current_fd_set); if (curl_global_init(CURL_GLOBAL_NOTHING)) { while (_url_con_list) ecore_con_url_destroy(eina_list_data_get(_url_con_list)); return 0; } curlm = curl_multi_init(); if (!curlm) { while (_url_con_list) ecore_con_url_destroy(eina_list_data_get(_url_con_list)); init_count--; return 0; } curl_multi_timeout(curlm, &ms); if (ms <= 0) ms = 1000; _curl_timeout = ecore_timer_add((double) ms / 1000, _ecore_con_url_idler_handler, (void *) 0xACE); ecore_timer_freeze(_curl_timeout); } return 1; #else return 0; #endif }
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"); }
zeb_curl_client_t * zeb_curl_client_new () { #if defined (HAVE_LIBCURL) zeb_curl_client_t *self = (zeb_curl_client_t *) zmalloc (sizeof (zeb_curl_client_t)); assert (self); // Initialize properties curl_global_init(CURL_GLOBAL_ALL); self->multi_handle = curl_multi_init (); return self; #else return NULL; #endif }
CurlHttpIO::CurlHttpIO() { curl_global_init(CURL_GLOBAL_DEFAULT); curlm = curl_multi_init(); curlsh = curl_share_init(); curl_share_setopt(curlsh, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS); curl_share_setopt(curlsh, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION); contenttypejson = curl_slist_append(NULL, "Content-Type: application/json"); contenttypejson = curl_slist_append(contenttypejson, "Expect:"); contenttypebinary = curl_slist_append(NULL, "Content-Type: application/octet-stream"); contenttypebinary = curl_slist_append(contenttypebinary, "Expect:"); }
int l_multi_init(lua_State *L) { l_multi_userdata *multi_userdata = l_multi_newuserdata(L); if ((multi_userdata->curlm = curl_multi_init()) == NULL) luaL_error(L, "something went wrong and you cannot use the other curl functions"); /* creaty uniqe table in registry to store state for callback functions */ lua_getfield(L, LUA_REGISTRYINDEX, MULTIREGISTRY_KEY); lua_pushlightuserdata(L, multi_userdata); lua_newtable(L); lua_settable(L, -3); lua_pop(L, 1); /* return userdata */ return 1; }
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); };
/* * call-seq: * Curl::Multi.new => #<Curl::Easy...> * * Create a new Curl::Multi instance */ static VALUE ruby_curl_multi_new(VALUE self) { VALUE new_curlm; ruby_curl_multi *rbcm = ALLOC(ruby_curl_multi); rbcm->handle = curl_multi_init(); rbcm->requests = rb_hash_new(); rbcm->active = 0; rbcm->running = 0; new_curlm = Data_Wrap_Struct(cCurlMulti, curl_multi_mark, curl_multi_free, rbcm); return new_curlm; }
Mensa::Mensa(const Configs& cfg) : multiHandle(curl_multi_init()), lastupdate(0), updating(false) { cfg.GetValue("menuurl", menuurl); cfg.GetValue("metaurl", metaurl); cfg.GetValue("login", login); cfg.GetValue("canteen", canteen); std::string rawlines; cfg.GetValue("lines", rawlines); std::istringstream sstr(rawlines); std::string newline; while(std::getline(sstr, newline, ',')) lines.insert(newline); }
void http_client_init(void) { CURLcode code = curl_global_init(CURL_GLOBAL_ALL); if (code != CURLE_OK) g_error("curl_global_init() failed: %s", curl_easy_strerror(code)); http_client.multi = curl_multi_init(); if (http_client.multi == NULL) g_error("curl_multi_init() failed"); http_client.source = g_source_new(&curl_source_funcs, sizeof(*http_client.source)); http_client.source_id = g_source_attach(http_client.source, g_main_context_default()); }
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(); } }
static void *rest_get_auth_token(void *const thread_args) { t_rest *const rest = thread_args; /* length + name=&password=*/ rest->common.parameters = string_create(&rest->common.parameters_len, rest->cookie.username_len + rest->cookie.password_len + 17); if (rest->common.parameters != NULL) { strcpy(rest->common.parameters, "name="); strcat(rest->common.parameters, rest->cookie.username); strcat(rest->common.parameters, "&password="******"POST"); pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0); rest->common.easy_handle = curl_easy_init(); rest->common.multi_handle = curl_multi_init(); if (rest->common.easy_handle == NULL) { MYERROR("Cannot init curl."); ctw_cleanup_request(&rest->common, NULL, NULL); } else { struct curl_slist *slist = NULL; struct _memory_struct out_content; struct _memory_struct out_header; FILE *fp = ctw_prepare(&rest->common, slist, &out_content, NULL); out_header.memory = getbytes(1); out_header.size = 0; struct _cb_val *cb_val = getbytes(sizeof(struct _cb_val)); cb_val->mem = &out_header; cb_val->ctw = (struct _ctw *)rest; curl_easy_setopt(rest->common.easy_handle, CURLOPT_HEADERFUNCTION, ctw_write_mem_cb); curl_easy_setopt(rest->common.easy_handle, CURLOPT_WRITEHEADER, (void *)cb_val); ctw_thread_perform(&rest->common); rest_process_auth_data(rest, &out_header); string_free(out_header.memory, &out_header.size); string_free(out_content.memory, &out_content.size); ctw_cleanup_request(&rest->common, fp, slist); } return NULL; }
static int webclient_create(lua_State* l) { curl_global_init(CURL_GLOBAL_ALL); CURLM* curlm = curl_multi_init(); if (!curlm) { curl_global_cleanup(); return luaL_error(l, "webclient create failed"); } struct webclient* webclient = (struct webclient*)lua_newuserdata(l, sizeof(*webclient)); webclient->curlm = curlm; luaL_getmetatable(l, LUA_WEB_CLIENT_MT); lua_setmetatable(l, -2); return 1; }
static struct input_stream * input_curl_open(const char *url, GError **error_r) { struct input_curl *c; bool ret; if (strncmp(url, "http://", 7) != 0) return NULL; c = g_new0(struct input_curl, 1); input_stream_init(&c->base, &input_plugin_curl, url); c->url = g_strdup(url); c->buffers = g_queue_new(); c->multi = curl_multi_init(); if (c->multi == NULL) { g_set_error(error_r, curl_quark(), 0, "curl_multi_init() failed"); input_curl_free(c); return NULL; } icy_clear(&c->icy_metadata); c->tag = NULL; ret = input_curl_easy_init(c, error_r); if (!ret) { input_curl_free(c); return NULL; } ret = input_curl_send_request(c, error_r); if (!ret) { input_curl_free(c); return NULL; } ret = input_curl_multi_info_read(c, error_r); if (!ret) { input_curl_free(c); return NULL; } return &c->base; }
void rest_multi_init(MultiRestState *state, int nhandles) { int i; if (nhandles > MAX_CURL_HANDLES) elog(ERROR, "Number of curl handles (%d) is larger than max (%d)", nhandles, MAX_CURL_HANDLES); state->nhandles = nhandles; state->multi_handle = curl_multi_init(); state->available = nhandles; for (i = 0; i < nhandles; i++) { state->handles[i] = NULL; state->errorbuffs[i] = NULL; state->postDatas[i] = NULL; state->responses[i] = NULL; } MULTI_REST_STATES = lappend(MULTI_REST_STATES, state); }
bool HttpMgr::init() { CURL *curl = NULL; CURLcode code = curl_global_init(CURL_GLOBAL_DEFAULT); if (code != CURLE_OK) { LOG_ERROR << "Failed to global init default " << code << "!"; return false; } m_currentCurl = curl_multi_init(); if( !m_currentCurl ) { LOG_ERROR << "curl_multi_init failed!"; return false; } return true; }
S3Status S3_create_request_context(S3RequestContext **requestContextReturn) { *requestContextReturn = (S3RequestContext *) malloc(sizeof(S3RequestContext)); if (!*requestContextReturn) { return S3StatusOutOfMemory; } if (!((*requestContextReturn)->curlm = curl_multi_init())) { free(*requestContextReturn); return S3StatusOutOfMemory; } (*requestContextReturn)->requests = 0; return S3StatusOK; }
/* * Setups the libcurl multi API */ void setup_multi_handle(churl_context* context) { int curl_error; /* Create multi handle on first use */ if (!context->multi_handle) if (!(context->multi_handle = curl_multi_init())) elog(ERROR, "internal error: curl_multi_init failed"); /* add the easy handle to the multi handle */ /* don't blame me, blame libcurl */ if (CURLM_OK != (curl_error = curl_multi_add_handle(context->multi_handle, context->curl_handle))) if (CURLM_CALL_MULTI_PERFORM != curl_error) elog(ERROR, "internal error: curl_multi_add_handle failed (%d - %s)", curl_error, curl_easy_strerror(curl_error)); multi_perform(context); }