void event_callback(int _socket, short _kind, void* _connection_ptr) { const auto connection = static_cast<curl_handler::connection_context*>(_connection_ptr); const auto handler = connection->curl_handler_; const auto tv = curl_handler::make_timeval(connection->timeout_); event_del(connection->timeout_event_); event_add(connection->timeout_event_, &tv); int action = 0; if (_kind & EV_READ) action |= CURL_CSELECT_IN; if (_kind & EV_WRITE) action |= CURL_CSELECT_OUT; const auto error = curl_multi_socket_action(handler->multi_handle_, _socket, action, &handler->running_); assert(!error); (void*) error; // supress warning check_multi_info(handler); if (handler->running_ <= 0) { if (evtimer_pending(handler->timer_event_, NULL)) evtimer_del(handler->timer_event_); } }
/* Called by glib when we get action on a multi socket */ static gboolean event_cb(GIOChannel *ch, GIOCondition condition, gpointer data) { GlobalInfo *g = (GlobalInfo*) data; CURLMcode rc; int fd = g_io_channel_unix_get_fd(ch); int action = (condition & G_IO_IN ? CURL_CSELECT_IN : 0) | (condition & G_IO_OUT ? CURL_CSELECT_OUT : 0); rc = curl_multi_socket_action(g->multi, fd, action, &g->still_running); mcode_or_die("event_cb: curl_multi_socket_action", rc); check_multi_info(g); if(g->still_running) { return TRUE; } else { MSG_OUT("last transfer done, kill timeout\n"); if(g->timer_event) { g_source_remove(g->timer_event); } return FALSE; } }
static gboolean event_cb(GIOChannel *ch, GIOCondition condition, gpointer data) { CURLMcode res; FetchData *fetch_data = (FetchData*)data; struct curl_data *cd = fetch_data->private_data; CURLM *curl = cd->curlm; int fd = g_io_channel_unix_get_fd(ch); int action = (condition & G_IO_IN ? CURL_CSELECT_IN : 0) | (condition & G_IO_OUT ? CURL_CSELECT_OUT : 0); res = curl_multi_socket_action(curl, fd, action, &cd->running); if (res != CURLM_OK) { g_set_error(&fetch_data->error, RESTRAINT_FETCH_LIBARCHIVE_ERROR, res, "curl failed"); g_idle_add (archive_finish_callback, fetch_data); return FALSE; } check_multi_info(fetch_data); if (cd->running) { return TRUE; } else { if (cd->to_ev != 0) { g_source_remove(cd->to_ev); cd->to_ev = 0; } return FALSE; } }
void curl_perform(uv_poll_t *si, int status, int events) { int running_handles; int flags = 0; Socket_Info *s = (Socket_Info *) si->data; Mathilda *m = (Mathilda *) s->m; uv_timer_stop(&m->timeout); if(status < 0) { flags = CURL_CSELECT_ERR; } if(!status && events & UV_READABLE) { flags |= CURL_CSELECT_IN; } if(!status && events & UV_WRITABLE) { flags |= CURL_CSELECT_OUT; } curl_multi_socket_action(m->multi_handle, s->sock_fd, flags, &running_handles); check_multi_info(m); uv_timer_start(&m->timeout, (uv_timer_cb) on_timeout, 0, 0); }
void on_timeout(uv_timer_t *req, int status) { int running_handles; curl_multi_socket_action(curl_handle, CURL_SOCKET_TIMEOUT, 0, &running_handles); check_multi_info(); }
void on_timeout(uv_timer_t *req) { int running_handles; bear_stream_t *stream = (bear_stream_t*) req->data; curl_multi_socket_action(stream->curl_handle, CURL_SOCKET_TIMEOUT, 0, &running_handles); check_multi_info(stream); }
void event_timer_callback(evutil_socket_t /*_descriptor*/, short /*_flags*/, void* _curl_handler_ptr) { const auto handler = static_cast<curl_handler*>(_curl_handler_ptr); const auto error = curl_multi_socket_action(handler->multi_handle_, CURL_SOCKET_TIMEOUT, 0, &handler->running_); assert(!error); (void*) error; // supress warning check_multi_info(handler); }
/* Called by libevent when our timeout expires */ static void timer_cb(EV_P_ struct ev_timer *w, int revents) { DPRINT("%s w %p revents %i\n", __PRETTY_FUNCTION__, w, revents); GlobalInfo *g = (GlobalInfo *)w->data; CURLMcode rc; rc = curl_multi_socket_action(g->multi, CURL_SOCKET_TIMEOUT, 0, &g->still_running); mcode_or_die("timer_cb: curl_multi_socket_action", rc); check_multi_info(g); }
/* Called by glib when our timeout expires */ static gboolean timer_cb(gpointer data) { GlobalInfo *g = (GlobalInfo *)data; CURLMcode rc; rc = curl_multi_socket_action(g->multi, CURL_SOCKET_TIMEOUT, 0, &g->still_running); mcode_or_die("timer_cb: curl_multi_socket_action", rc); check_multi_info(g); return FALSE; }
/* Called by libevent when our timeout expires */ static void timer_cb(int fd, short kind, void *userp) { GlobalInfo *g = (GlobalInfo *)userp; CURLMcode rc; (void)fd; (void)kind; rc = curl_multi_socket_action(g->multi, CURL_SOCKET_TIMEOUT, 0, &g->still_running); mcode_or_die("timer_cb: curl_multi_socket_action", rc); check_multi_info(g); }
/* Called by libevent when our "wait for socket actions" timeout expires */ static void socket_action_timer_cb(struct ev_loop *loop, struct ev_timer *timer, int revents) { orcout(orcm_debug, "%s timer %p revents %i\n", __PRETTY_FUNCTION__, timer, revents); global_info *global = (global_info *)timer->data; CURLMcode rc; /* Do the timeout action */ rc = curl_multi_socket_action(global->multi, CURL_SOCKET_TIMEOUT, 0, &(global->still_running)); mcode_or_die("socket_action_timer_cb: curl_multi_socket_action", rc); check_multi_info(global); }
/* Called by asio when our timeout expires */ static void timer_cb(const boost::system::error_code & error, GlobalInfo *g) { std::cout << std::endl << __PRETTY_FUNCTION__ << " called" << std::endl; if (!error) { fprintf(MSG_OUT, "\ntimer_cb: "); CURLMcode rc; rc = curl_multi_socket_action(g->multi, CURL_SOCKET_TIMEOUT, 0, &g->still_running); mcode_or_die("timer_cb: curl_multi_socket_action", rc); check_multi_info(g); } }
/* Called by asio when our timeout expires */ static void timer_cb(const boost::system::error_code & error, GlobalInfo *g) { if(!error) { fprintf(MSG_OUT, "\ntimer_cb: "); CURLMcode rc; rc = curl_multi_socket_action(g->multi, CURL_SOCKET_TIMEOUT, 0, &g->still_running); mcode_or_die("timer_cb: curl_multi_socket_action", rc); check_multi_info(g); } }
void curl_perform(uv_poll_t *req, int status, int events) { uv_timer_stop(&timeout); int running_handles; int flags = 0; if (status < 0) flags = CURL_CSELECT_ERR; if (!status && events & UV_READABLE) flags |= CURL_CSELECT_IN; if (!status && events & UV_WRITABLE) flags |= CURL_CSELECT_OUT; curl_context_t *context; context = (curl_context_t*)req; curl_multi_socket_action(curl_handle, context->sockfd, flags, &running_handles); check_multi_info(); }
/* Called by asio when there is an action on a socket */ static void event_cb(GlobalInfo * g, boost::asio::ip::tcp::socket * tcp_socket, int action) { fprintf(MSG_OUT, "\nevent_cb: action=%d", action); CURLMcode rc; rc = curl_multi_socket_action(g->multi, tcp_socket->native_handle(), action, &g->still_running); mcode_or_die("event_cb: curl_multi_socket_action", rc); check_multi_info(g); if ( g->still_running <= 0 ) { fprintf(MSG_OUT, "\nlast transfer done, kill timeout"); timer.cancel(); } }
/* Called by libevent when we get action on a multi socket */ static void event_cb(struct ev_loop *loop, struct ev_io *event_io, int revents) { orcout(orcm_debug, "%s event_io %p revents %i\n", __PRETTY_FUNCTION__, event_io, revents); global_info *global = (global_info *)event_io->data; CURLMcode rc; int action = (revents & EV_READ ? CURL_POLL_IN : 0) | (revents & EV_WRITE ? CURL_POLL_OUT : 0); rc = curl_multi_socket_action(global->multi, event_io->fd, action, &(global->still_running)); mcode_or_die("event_cb: curl_multi_socket_action", rc); check_multi_info(global); if (global->still_running <= 0 && global->job_count <= 0) { orcout(orcm_debug, "last transfer done, kill timeout\n"); ev_timer_stop(global->loop, &(global->timer_event)); } }
/* Called by libevent when we get action on a multi socket */ static void event_cb(EV_P_ struct ev_io *w, int revents) { DPRINT("%s w %p revents %i\n", __PRETTY_FUNCTION__, w, revents); GlobalInfo *g = (GlobalInfo*) w->data; CURLMcode rc; int action = (revents&EV_READ?CURL_POLL_IN:0)| (revents&EV_WRITE?CURL_POLL_OUT:0); rc = curl_multi_socket_action(g->multi, w->fd, action, &g->still_running); mcode_or_die("event_cb: curl_multi_socket_action", rc); check_multi_info(g); if ( g->still_running <= 0 ) { fprintf(MSG_OUT, "last transfer done, kill timeout\n"); ev_timer_stop(g->loop, &g->timer_event); } }
static void curl_perform(uv_poll_t *req, int status, int events) { int running_handles; int flags = 0; curl_context_t *context; if(events & UV_READABLE) flags |= CURL_CSELECT_IN; if(events & UV_WRITABLE) flags |= CURL_CSELECT_OUT; context = (curl_context_t *) req->data; curl_multi_socket_action(curl_handle, context->sockfd, flags, &running_handles); check_multi_info(); }
/* Called by asio when there is an action on a socket */ static void event_cb(GlobalInfo *g, curl_socket_t s, int action, const boost::system::error_code & error, int *fdp) { std::cout << std::endl << __PRETTY_FUNCTION__ << " called" << std::endl; fprintf(MSG_OUT, "\nevent_cb: action=%d", action); if (socket_map.find(s) == socket_map.end()) { fprintf(MSG_OUT, "\nevent_cb: socket already closed"); return; } /* make sure the event matches what are wanted */ if (*fdp == action || *fdp == CURL_POLL_INOUT) { CURLMcode rc; if (error) action = CURL_CSELECT_ERR; rc = curl_multi_socket_action(g->multi, s, action, &g->still_running); mcode_or_die("event_cb: curl_multi_socket_action", rc); check_multi_info(g); if (g->still_running <= 0) { fprintf(MSG_OUT, "\nlast transfer done, kill timeout"); timer.cancel(); } /* keep on watching. * the socket may have been closed and/or fdp may have been changed * in curl_multi_socket_action(), so check them both */ if (!error && socket_map.find(s) != socket_map.end() && (*fdp == action || *fdp == CURL_POLL_INOUT)) { boost::asio::ip::tcp::socket *tcp_socket = socket_map.find(s)->second; if (action == CURL_POLL_IN) { tcp_socket->async_read_some(boost::asio::null_buffers(), boost::bind(&event_cb, g, s, action, _1, fdp)); } if (action == CURL_POLL_OUT) { tcp_socket->async_write_some(boost::asio::null_buffers(), boost::bind(&event_cb, g, s, action, _1, fdp)); } } } }
/* Called by libevent when our timeout expires */ void timer_cb(int fd, short kind, void *userp) { struct http_m_global *g = (struct http_m_global *)userp; CURLMcode rc; (void)fd; (void)kind; char error[CURL_ERROR_SIZE]; LM_DBG("timeout on socket %d\n", fd); rc = curl_multi_socket_action(g->multi, CURL_SOCKET_TIMEOUT, 0, &g->still_running); if (check_mcode(rc, error) < 0) { LM_ERR("curl_multi_socket_action error: %s", error); } check_multi_info(g); }
/* Called by asio when our timeout expires */ void timer_cb(const boost::system::error_code & error, Context* c) { TRACE("timer_cb"); if ( error != boost::asio::error::operation_aborted ) { TRACE_MSG("no error"); CURLMcode rc = curl_multi_socket_action(c->multi_, CURL_SOCKET_TIMEOUT, 0, &c->still_running_); mcode_or_throw("timer_cb: curl_multi_socket_action", rc); check_multi_info(c); } #ifndef NDEBUG else { TRACE_MSG("Error: " << error.message()); } #endif }
//libuv polling call back //as soon as an event detected this function will be called. void curl_perform(uv_poll_t *req, int status, int events) { (void)status; //unused int running_handles; int flags = 0; bear_stream_t *stream = (bear_stream_t *) req->data; uv_timer_stop(&stream->timeout); if(events & UV_READABLE) flags |= CURL_CSELECT_IN; if(events & UV_WRITABLE) flags |= CURL_CSELECT_OUT; curl_multi_socket_action(stream->curl_handle,stream->sockfd, flags, &running_handles); check_multi_info(stream); }
/* Called by libevent when we get action on a multi socket */ static void event_cb(int fd, short kind, void *userp) { GlobalInfo *g = (GlobalInfo*) userp; CURLMcode rc; int action = (kind & EV_READ ? CURL_CSELECT_IN : 0) | (kind & EV_WRITE ? CURL_CSELECT_OUT : 0); rc = curl_multi_socket_action(g->multi, fd, action, &g->still_running); mcode_or_die("event_cb: curl_multi_socket_action", rc); check_multi_info(g); if ( g->still_running <= 0 ) { fprintf(MSG_OUT, "last transfer done, kill timeout\n"); if (evtimer_pending(g->timer_event, NULL)) { evtimer_del(g->timer_event); } } }
/* Called by asio when there is an action on a socket */ void event_cb(Context* c, CURL* e, boost::asio::ip::tcp::socket * tcp_socket, int action, boost::system::error_code const& ec) { TRACE("event_cb"); AsyncHTTPRequester* r; curl_easy_getinfo(e, CURLINFO_PRIVATE, &r); r->reschedule_ = true; CURLMcode rc = curl_multi_socket_action(c->multi_, tcp_socket->native_handle(), action, &c->still_running_); mcode_or_throw("event_cb: curl_multi_socket_action", rc); check_multi_info(c); if ( c->still_running_ <= 0 ) { c->timer_.cancel(); } //else if ( !ec && r->reschedule_ ) //{ // setsock(tcp_socket, e, action, c); //} }
bool socketmanager::AddConn(CURL* ch, std::unique_ptr<mcurlconn> cs) { if (asyncdns) { // This can conditionally steal cs, if it does it returns true and we stop here if (asyncdns->CheckAsync(ch, std::move(cs))) { return true; } } SetCurlHandleVerboseState(ch, currentlogflags & LOGT::CURLVERB); curl_easy_setopt(ch, CURLOPT_TIMEOUT, (cs->mcflags & mcurlconn::MCF::NOTIMEOUT) ? 0 : cs->timeout); curl_easy_setopt(ch, CURLOPT_PRIVATE, cs.get()); curl_easy_setopt(ch, CURLOPT_ACCEPT_ENCODING, ""); //accept all enabled encodings if (currentlogflags & LOGT::SOCKTRACE) { curl_easy_setopt(ch, CURLOPT_SOCKOPTFUNCTION, &pre_connect_func); curl_easy_setopt(ch, CURLOPT_SOCKOPTDATA, cs.get()); } if (gc.setproxy) { curl_easy_setopt(ch, CURLOPT_PROXY, gc.proxyurl.c_str()); curl_easy_setopt(ch, CURLOPT_NOPROXY, gc.noproxylist.c_str()); curl_easy_setopt(ch, CURLOPT_HTTPPROXYTUNNEL, gc.proxyhttptunnel ? 1 : 0); } else { curl_easy_setopt(ch, CURLOPT_PROXY, nullptr); curl_easy_setopt(ch, CURLOPT_NOPROXY, nullptr); curl_easy_setopt(ch, CURLOPT_HTTPPROXYTUNNEL, 0); } if (!gc.netiface.empty()) { curl_easy_setopt(ch, CURLOPT_INTERFACE, gc.netiface.c_str()); } else { curl_easy_setopt(ch, CURLOPT_INTERFACE, nullptr); } connlist.push_back({ ch, std::move(cs) }); bool ret = (CURLM_OK == curl_multi_add_handle(curlmulti, ch)); curl_multi_socket_action(curlmulti, 0, 0, &curnumsocks); check_multi_info(&sm); return ret; }
void curl_perform(uv_poll_t *req, int status, int events) { int running_handles; int flags = 0; curl_context_t *context; char *done_url; CURLMsg *message; int pending; uv_timer_stop(&timeout); if (events & UV_READABLE) flags |= CURL_CSELECT_IN; if (events & UV_WRITABLE) flags |= CURL_CSELECT_OUT; context = (curl_context_t*)req; curl_multi_socket_action(curl_handle, context->sockfd, flags, &running_handles); check_multi_info(); }
void socketmanager::NotifySockEvent(curl_socket_t sockfd, int ev_bitmask) { LogMsgFormat(LOGT::SOCKTRACE, "Socket Notify (%d)", sockfd); curl_multi_socket_action(curlmulti, sockfd, ev_bitmask, &curnumsocks); check_multi_info(this); }
void on_timeout(uv_timer_t *req) { int running_handles; Mathilda *m = (Mathilda *) req->data; curl_multi_socket_action(m->multi_handle, CURL_SOCKET_TIMEOUT, 0, &running_handles); check_multi_info(m); }
void sockettimeout::Notify() { LogMsgFormat(LOGT::SOCKTRACE, "Socket Timer Event"); curl_multi_socket_action(sm.curlmulti, CURL_SOCKET_TIMEOUT, 0, &sm.curnumsocks); check_multi_info(&sm); }
/* Called by libevent when we get action on a multi socket */ void event_cb(int fd, short kind, void *userp) { struct http_m_global *g; CURLMcode rc; CURL *easy = (CURL*) userp; struct http_m_cell *cell; cell = http_m_cell_lookup(easy); if (cell == NULL) { LM_INFO("Cell for handler %p not found in table\n", easy); return; } g = cell->global; int action = (kind & EV_READ ? CURL_CSELECT_IN : 0) | (kind & EV_WRITE ? CURL_CSELECT_OUT : 0); LM_DBG("activity %d on socket %d: action %d\n", kind, fd, action); if (kind == EV_TIMEOUT) { LM_DBG("handle %p timeout on socket %d (cell=%p, param=%p)\n", cell->easy, fd, cell, cell->param); update_stat(timeouts, 1); const char *error = "TIMEOUT"; strncpy(cell->error, error, strlen(error)+1); reply_error(cell); easy = cell->easy; /* we are going to remove the cell and the handle here: pass NULL as sockptr */ curl_multi_assign(g->multi, cell->sockfd, NULL); LM_DBG("cleaning up cell %p\n", cell); if (cell->evset && cell->ev) { LM_DBG("freeing event %p\n", cell->ev); event_del(cell->ev); event_free(cell->ev); cell->ev=NULL; cell->evset=0; } unlink_http_m_cell(cell); free_http_m_cell(cell); LM_DBG("removing handle %p\n", easy); curl_multi_remove_handle(g->multi, easy); curl_easy_cleanup(easy); rc = curl_multi_socket_action(g->multi, CURL_SOCKET_TIMEOUT, 0, &g->still_running); } else { LM_DBG("performing action %d on socket %d\n", action, fd); rc = curl_multi_socket_action(g->multi, fd, action, &g->still_running); LM_DBG("action %d on socket %d performed\n", action, fd); if (rc == CURLM_CALL_MULTI_PERFORM) { LM_DBG("received CURLM_CALL_MULTI_PERFORM, performing action again\n"); rc = curl_multi_socket_action(g->multi, fd, action, &g->still_running); } if (check_mcode(rc, cell->error) < 0) { LM_ERR("error: %s\n", cell->error); reply_error(cell); curl_multi_remove_handle(g->multi, easy); curl_easy_cleanup(easy); } } check_multi_info(g); if ( g->still_running <= 0 ) { LM_DBG("last transfer done, kill timeout\n"); if (evtimer_pending(g->timer_event, NULL)) { evtimer_del(g->timer_event); } } }