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