本文整理汇总了C++中curl_multi_timeout函数的典型用法代码示例。如果您正苦于以下问题:C++ curl_multi_timeout函数的具体用法?C++ curl_multi_timeout怎么用?C++ curl_multi_timeout使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了curl_multi_timeout函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: select
bool CMultiHttp::Perform()
{
struct timeval timeout;
int still_running=0;
int rc=0; /* select() return code */
CURLMcode mc; /* curl_multi_fdset() return code */
fd_set fdread;
fd_set fdwrite;
fd_set fdexcep;
int maxfd = -1;
long curl_timeo = -1;
FD_ZERO(&fdread);
FD_ZERO(&fdwrite);
FD_ZERO(&fdexcep);
/* set a suitable timeout to play around with */
timeout.tv_sec = 5;
timeout.tv_usec = 0;
curl_multi_timeout(m_murl, &curl_timeo);
if( curl_timeo==0 )
curl_timeo=50;
if(curl_timeo >= 0)
{
timeout.tv_sec = curl_timeo/1000;
if(timeout.tv_sec > 1)
timeout.tv_sec = 1;
else
timeout.tv_usec = (curl_timeo % 1000) * 1000;
}
/* get file descriptors from the transfers */
mc = curl_multi_fdset(m_murl, &fdread, &fdwrite, &fdexcep, &maxfd);
if(mc != CURLM_OK)
{
LOG_FUNC_P1(_T("curl_multi_fdset() failed, code %d"),mc);
return false;
}
/* On success the value of maxfd is guaranteed to be >= -1. We call
select(maxfd + 1, ...); specially in case of (maxfd == -1) there are
no fds ready yet so we call select(0, ...) --or Sleep() on Windows--
to sleep 100ms, which is the minimum suggested value in the
curl_multi_fdset() doc. */
if(maxfd == -1)
{
Sleep(100);
rc = 0;
}
else
{
FD_SET(m_fds[1],&fdread);
FD_SET(m_fds[1],&fdwrite);
FD_SET(m_fds[1],&fdexcep);
rc = ::select(maxfd+2, &fdread,&fdwrite, &fdexcep, &timeout);
if(FD_ISSET(m_fds[1],&fdread))
{
std::string cmd;
if( !recvcmd(m_fds[1],cmd) )
{
m_state = CMultiHttp::Terminate;
return false;
}
if( cmd==CMD_CANCEL )
{
LOG_FUNC_P0(_T("url 后台线程 收到退出指令"));
m_state = CMultiHttp::Terminate;
return false;
}
}
}
switch(rc)
{
case -1:
/* select error */
break;
case 0:
default:
while( CURLM_CALL_MULTI_PERFORM==curl_multi_perform(m_murl,&still_running) )
;
{
struct CURLMsg *m;
int msgQ=0;
m = curl_multi_info_read(m_murl,&msgQ);
if(m && (m->msg == CURLMSG_DONE))
{
CURL *e = m->easy_handle;
if( !OneComplete(e,m->data.result) )
still_running=0;
}
}
break;
}
if( still_running )
return true;
m_state = CMultiHttp::Terminate;
return false;
}
示例2: FD_ZERO
bool
Net::Session::Select(int timeout_ms)
{
fd_set rfds, wfds, efds;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_ZERO(&efds);
int max_fd;
CURLMcode mcode = curl_multi_fdset(multi, &rfds, &wfds,
&efds, &max_fd);
if (mcode != CURLM_OK)
return false;
long curl_timeout;
mcode = curl_multi_timeout(multi, &curl_timeout);
if (mcode == CURLM_OK && curl_timeout >= 0) {
if (curl_timeout < 50)
curl_timeout = 50;
if (timeout_ms < 0 || curl_timeout < (long)timeout_ms)
timeout_ms = curl_timeout;
}
struct timeval timeout, *timeout_p;
if (timeout_ms >= 0) {
timeout.tv_sec = timeout_ms / 1000;
timeout.tv_usec = timeout_ms * 1000;
timeout_p = &timeout;
} else
timeout_p = NULL;
int ret = select(max_fd, &rfds, &wfds, &efds, timeout_p);
return ret > 0;
}
示例3: to
/* Called before all the file descriptors are polled by the glib main loop.
We must have a look at all fds that libcurl wants polled. If any of them
are new/no longer needed, we have to (de)register them with glib. */
gboolean prepare(GSource* source, gint* timeout) {
D((stderr, "prepare\n"));
assert(source == &curlSrc->source);
if (curlSrc->multiHandle == 0) return FALSE;
registerUnregisterFds();
// Handle has been added. we are ready
if (curlSrc->callPerform == -1) {
s_currTimeout = *timeout = 0;
return TRUE;
}
long curlTimeout = 0;
curl_multi_timeout(curlSrc->multiHandle, &curlTimeout);
// Curl tells us it is ready
if (curlTimeout == 0) {
s_currTimeout = *timeout = 0;
return TRUE;
}
// Curl says wait forever. do it only when if we don't have pending
// connections
if (curlTimeout < 0) {
s_currTimeout = *timeout = (s_numEasyHandles > 0) ? GLIBCURL_TIMEOUT : -1;
return FALSE;
}
s_currTimeout = *timeout = MIN(GLIBCURL_TIMEOUT, curlTimeout);
return FALSE;
}
示例4: client_schedule
/**
* Function setting up file descriptors and scheduling task to run
*
* @param plugin plugin as closure
* @param now schedule task in 1ms, regardless of what curl may say
* @return GNUNET_SYSERR for hard failure, GNUNET_OK for ok
*/
static int
client_schedule (struct Plugin *plugin, int now)
{
fd_set rs;
fd_set ws;
fd_set es;
int max;
struct GNUNET_NETWORK_FDSet *grs;
struct GNUNET_NETWORK_FDSet *gws;
long to;
CURLMcode mret;
struct GNUNET_TIME_Relative timeout;
/* Cancel previous scheduled task */
if (plugin->client_perform_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (plugin->client_perform_task);
plugin->client_perform_task = GNUNET_SCHEDULER_NO_TASK;
}
max = -1;
FD_ZERO (&rs);
FD_ZERO (&ws);
FD_ZERO (&es);
mret = curl_multi_fdset (plugin->client_mh, &rs, &ws, &es, &max);
if (mret != CURLM_OK)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("%s failed at %s:%d: `%s'\n"),
"curl_multi_fdset", __FILE__, __LINE__,
curl_multi_strerror (mret));
return GNUNET_SYSERR;
}
mret = curl_multi_timeout (plugin->client_mh, &to);
if (to == -1)
timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1);
else
timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, to);
if (now == GNUNET_YES)
timeout = GNUNET_TIME_UNIT_MILLISECONDS;
if (mret != CURLM_OK)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("%s failed at %s:%d: `%s'\n"),
"curl_multi_timeout", __FILE__, __LINE__,
curl_multi_strerror (mret));
return GNUNET_SYSERR;
}
grs = GNUNET_NETWORK_fdset_create ();
gws = GNUNET_NETWORK_fdset_create ();
GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
plugin->client_perform_task =
GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
timeout, grs, gws,
&client_run, plugin);
GNUNET_NETWORK_fdset_destroy (gws);
GNUNET_NETWORK_fdset_destroy (grs);
return GNUNET_OK;
}
示例5: do_select_job
static void do_select_job(CURLM* cmh)
{
fd_set fdread;
fd_set fdwrite;
fd_set fdexcep;
int maxfd = -1;
long curl_timeo = -1;
FD_ZERO(&fdread);
FD_ZERO(&fdwrite);
FD_ZERO(&fdexcep);
struct timeval timeout;
timeout.tv_sec = 1;
timeout.tv_usec = 0;
curl_multi_timeout(cmh, &curl_timeo);
if (curl_timeo >= 0)
{
timeout.tv_sec = curl_timeo / 1000;
if (timeout.tv_sec > 1)
{
timeout.tv_sec = 1;
}
else
{
timeout.tv_usec = (curl_timeo % 1000) * 1000;
}
}
curl_multi_fdset(cmh, &fdread, &fdwrite, &fdexcep, &maxfd);
select(maxfd + 1, &fdread, &fdwrite, &fdexcep, &timeout);
}
示例6: smcp_curl_proxy_node_update_fdset
smcp_status_t
smcp_curl_proxy_node_update_fdset(
smcp_curl_proxy_node_t self,
fd_set *read_fd_set,
fd_set *write_fd_set,
fd_set *error_fd_set,
int *max_fd,
cms_t *timeout
) {
int fd = *max_fd;
long cms_timeout = *timeout;
curl_multi_fdset(
self->curl_multi_handle,
read_fd_set,
write_fd_set,
error_fd_set,
&fd
);
*max_fd = MAX(*max_fd,fd);
curl_multi_timeout(
self->curl_multi_handle,
&cms_timeout
);
if(cms_timeout!=-1) {
*timeout = MIN(*timeout,cms_timeout);
}
return SMCP_STATUS_OK;
}
示例7: curl_source_prepare
/**
* The GSource prepare() method implementation.
*/
static gboolean
curl_source_prepare(G_GNUC_UNUSED GSource *source, G_GNUC_UNUSED gint *timeout_)
{
http_client_update_fds();
#if LIBCURL_VERSION_NUM >= 0x070f04
http_client.timeout = false;
long timeout2;
CURLMcode mcode = curl_multi_timeout(http_client.multi, &timeout2);
if (mcode == CURLM_OK) {
if (timeout2 >= 0 && timeout2 < 10)
/* CURL 7.21.1 likes to report "timeout=0",
which means we're running in a busy loop.
Quite a bad idea to waste so much CPU.
Let's use a lower limit of 10ms. */
timeout2 = 10;
*timeout_ = timeout2;
http_client.timeout = timeout2 >= 0;
} else
g_warning("curl_multi_timeout() failed: %s\n",
curl_multi_strerror(mcode));
#endif
return FALSE;
}
示例8: ruby_curl_multi_perform
/*
* call-seq:
* multi = Curl::Multi.new
* easy1 = Curl::Easy.new('url')
* easy2 = Curl::Easy.new('url')
*
* multi.add(easy1)
* multi.add(easy2)
*
* multi.perform do
* # while idle other code my execute here
* end
*
* Run multi handles, looping selecting when data can be transfered
*/
static VALUE ruby_curl_multi_perform(VALUE self) {
CURLMcode mcode;
ruby_curl_multi *rbcm;
int maxfd, rc;
fd_set fdread, fdwrite, fdexcep;
long timeout;
struct timeval tv = {0, 0};
Data_Get_Struct(self, ruby_curl_multi, rbcm);
//rb_gc_mark(self);
rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
while(rbcm->running) {
FD_ZERO(&fdread);
FD_ZERO(&fdwrite);
FD_ZERO(&fdexcep);
/* load the fd sets from the multi handle */
mcode = curl_multi_fdset(rbcm->handle, &fdread, &fdwrite, &fdexcep, &maxfd);
if (mcode != CURLM_OK) {
raise_curl_multi_error_exception(mcode);
}
/* get the curl suggested time out */
mcode = curl_multi_timeout(rbcm->handle, &timeout);
if (mcode != CURLM_OK) {
raise_curl_multi_error_exception(mcode);
}
if (timeout == 0) { /* no delay */
rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
continue;
}
else if (timeout == -1) {
timeout = 1; /* You must not wait too long
(more than a few seconds perhaps) before
you call curl_multi_perform() again */
}
if (rb_block_given_p()) {
rb_yield(self);
}
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout * 1000) % 1000000;
rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
if (rc < 0) {
rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
}
rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );
}
return Qnil;
}
示例9: curl_perform_wait
void curl_perform_wait()
{
long timeout_ms = -1;
CURLMcode result = curl_multi_timeout(curl_handle, &timeout_ms);
if (result != CURLM_OK) log_error("curl_multi_timeout error %d", result);
if (timeout_ms < 1) timeout_ms = 1;
int numfds = 0;
result = curl_multi_wait(curl_handle, NULL, 0, (int)timeout_ms, &numfds);
if (result != CURLM_OK) log_error("curl_multi_wait error %d", result);
int numrunning = 0;
result = curl_multi_perform(curl_handle, &numrunning);
if (result != CURLM_OK) log_error("curl_multi_perform error %d", result);
int pending = 0;
CURLMsg *message;
while ((message = curl_multi_info_read(curl_handle, &pending))) {
switch (message->msg) {
case CURLMSG_DONE:
{
const char* done_url;
CURL* easy = message->easy_handle;
curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &done_url);
CURLcode code = message->data.result;
printf("%s DONE\ncode:%d - %s\n", done_url, code,
curl_easy_strerror(code));
struct curl_slist* list;
curl_easy_getinfo(easy, CURLINFO_PRIVATE, &list);
--remaining;
if (--repeats)
{
add_download(done_url);
}
curl_multi_remove_handle(curl_handle, easy);
curl_easy_cleanup(easy);
curl_slist_free_all(list);
break;
}
default:
log_error("CURLMSG default\n");
abort();
}
}
if (remaining == 0)
{
curl_multi_cleanup(curl_handle);
exit(0);
}
}
示例10: S3_get_request_context_timeout
int64_t S3_get_request_context_timeout(S3RequestContext *requestContext)
{
long timeout;
if (curl_multi_timeout(requestContext->curlm, &timeout) != CURLM_OK) {
timeout = 0;
}
return timeout;
}
示例11: set_timeout
int set_timeout() {
long timeout;
if (curl_multi_timeout(m_handler, &timeout)) {
LOGE("@set_timeout curl_multi_timeout");
return -1;
}
if(timeout < 0)
timeout = MULTI_SELECT_TIMEOUT;
m_timeout.tv_sec = timeout / 1000;
m_timeout.tv_usec = (timeout % 1000) * 1000;
return 0;
}
示例12: easy_transfer
static CURLcode easy_transfer(struct Curl_multi *multi)
{
bool done = FALSE;
CURLMcode mcode = CURLM_OK;
CURLcode result = CURLE_OK;
while(!done && !mcode) {
int still_running = 0;
bool gotsocket = FALSE;
mcode = Curl_multi_wait(multi, NULL, 0, 1000, NULL, &gotsocket);
if(!mcode) {
if(!gotsocket) {
long sleep_ms;
/* If it returns without any filedescriptor instantly, we need to
avoid busy-looping during periods where it has nothing particular
to wait for */
curl_multi_timeout(multi, &sleep_ms);
if(sleep_ms) {
if(sleep_ms > 1000)
sleep_ms = 1000;
Curl_wait_ms((int)sleep_ms);
}
}
mcode = curl_multi_perform(multi, &still_running);
}
/* only read 'still_running' if curl_multi_perform() return OK */
if(!mcode && !still_running) {
int rc;
CURLMsg *msg = curl_multi_info_read(multi, &rc);
if(msg) {
result = msg->data.result;
done = TRUE;
}
}
}
/* Make sure to return some kind of error if there was a multi problem */
if(mcode) {
result = (mcode == CURLM_OUT_OF_MEMORY) ? CURLE_OUT_OF_MEMORY :
/* The other multi errors should never happen, so return
something suitably generic */
CURLE_BAD_FUNCTION_ARGUMENT;
}
return result;
}
示例13: ecore_con_url_init
/**
* 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
}
示例14: do_multi_timeout
static PyObject *
do_multi_timeout(CurlMultiObject *self)
{
CURLMcode res;
long timeout;
if (check_multi_state(self, 1 | 2, "timeout") != 0) {
return NULL;
}
res = curl_multi_timeout(self->multi_handle, &timeout);
if (res != CURLM_OK) {
CURLERROR_MSG("timeout failed");
}
/* Return number of millisecs until timeout */
return Py_BuildValue("l", timeout);
}
示例15: http_get_timeout
struct timeval* http_get_timeout(void *d){
struct http_data *data=(struct http_data*)d;
long curl_timeo = -1;
if(data->cm==NULL)
return NULL;
curl_multi_timeout(data->cm, &curl_timeo);
if(curl_timeo >= 0) {
data->timeout.tv_sec = curl_timeo / 1000;
if(data->timeout.tv_sec > 1)
data->timeout.tv_sec = 1;
else
data->timeout.tv_usec = (curl_timeo % 1000) * 1000;
}
return &data->timeout;
}