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