static void _do_multi_socket_action(_bosh_conn_ctx conn_ctx)
{
    JW_LOG_TRACE_FUNCTION_NO_ARGS;

    assert(conn_ctx);

    // tell curl that a timeout has occurred
    jw_err    err;
    CURLMcode rc = curl_multi_socket_action(
            conn_ctx->multi, CURL_SOCKET_TIMEOUT, 0, &conn_ctx->num_active);
    if (!_check_curl_mcode(rc, &err))
    {
        goto _do_multi_socket_action_fail_label;
    }

    // test to see if we have any connection status changes to react to
    if (!_check_multi_info(conn_ctx, &err))
    {
        goto _do_multi_socket_action_fail_label;
    }

    return;

_do_multi_socket_action_fail_label:
    conn_ctx->error_cb(err.code, conn_ctx->cb_arg);
}

/* 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;
  }
}

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

/* note: this function can free the tr_web if its 'closing' flag is set
   and no tasks remain.  callers must not reference their g pointer
   after calling this function */
static void
tr_multi_socket_action( tr_web * g, int fd, int mask )
{
    int closed = FALSE;
    CURLMcode rc;

    dbgmsg( "check_run_count: prev_running %d, still_running %d",
            g->prev_running, g->still_running );

    /* invoke libcurl's processing */
    do {
        rc = curl_multi_socket_action( g->multi, fd, mask, &g->still_running );
        dbgmsg( "event_cb(): fd %d, mask %d, still_running is %d",
                fd, mask, g->still_running );
    } while( rc == CURLM_CALL_MULTI_PERFORM );
    if( rc != CURLM_OK )
        tr_err( "%s", curl_multi_strerror( rc ) );

    remove_finished_tasks( g );

    add_tasks_from_queue( g );

    if( !g->still_running ) {
        stop_timer( g );
        if( g->closing ) {
            web_close( g );
            closed = TRUE;
        }
    }

    if( !closed )
        restart_timer( g );
}

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 *req, int status, int events) {
    uv_timer_stop(&timeout);
    //printf("curl_perform# timeout %d status %d events %d \n",timeout,status,events);
    int running_handles;
    int flags = 0;
    if (events & UV_READABLE) flags |= CURL_CSELECT_IN;
    if (events & UV_WRITABLE) flags |= CURL_CSELECT_OUT;

    curl_context_t *context;

    context = (curl_context_t*)req;
    //printf("curl_perform# flag %d  sockfd %d \n",flags,context->sockfd);
    curl_multi_socket_action(curl_handle, context->sockfd, flags, &running_handles);

    char *done_url;

    CURLMsg *message;
    int pending;
    while ((message = curl_multi_info_read(curl_handle, &pending))) {
        switch (message->msg) {
        case CURLMSG_DONE:
            curl_easy_getinfo(message->easy_handle, CURLINFO_EFFECTIVE_URL, &done_url);
            printf("\n%s DONE\n", done_url);

            curl_multi_remove_handle(curl_handle, message->easy_handle);
            curl_easy_cleanup(message->easy_handle);

            break;
        default:
            fprintf(stderr, "CURLMSG default\n");
            abort();
        }
    }
}

void curl_perform_action(int socket, int actions)
{
    int running_handles;
    char *done_url;
    CURLMsg *message;
    int pending;

    curl_multi_socket_action(curl_handle, socket, actions, &running_handles);

    while ((message = curl_multi_info_read(curl_handle, &pending))) {
        switch (message->msg) {
            case CURLMSG_DONE:
            {
                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));

                curl_multi_remove_handle(curl_handle, message->easy_handle);
                curl_easy_cleanup(message->easy_handle);
                --remaining;

                break;
            }
            default:
                log_error("CURLMSG default\n");
                abort();
        }
    }
}

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

static void curl_on_active(handle_t s,int event){
  int running_handles;
  int flags = 0;
  curl_conn_t conn;
  CURLMsg *message;
  int pending;
  if(event & EVENT_READ)
  	flags |= CURL_CSELECT_IN;
  if(event & EVENT_WRITE)
  	flags |= CURL_CSELECT_OUT;
  conn = (curl_conn_t)s;
  if(conn->c_handle->timer){
	  kn_del_timer(conn->c_handle->timer);
	  conn->c_handle->timer = NULL; 
  }
  curl_multi_socket_action(kn_CURLM_get(conn->c_handle), ((handle_t)conn)->fd, flags,&running_handles);
  while ((message = curl_multi_info_read(kn_CURLM_get(conn->c_handle), &pending))) {
	kn_CURL_t curl;
	curl_easy_getinfo(message->easy_handle, CURLINFO_PRIVATE, &curl);
	if(message->msg == CURLMSG_DONE){
		if(curl->cb)
			curl->cb(curl,message,curl->ud);
		else
			kn_curl_easy_cleanup(curl);
	}else{
	    fprintf(stderr, "CURLMSG default\n");
		abort();
	}
   }
}

static int timer_callback(kn_timer_t timer){
	kn_CURLM_t cm = (kn_CURLM_t)kn_timer_getud(timer);
	int running_handles;	
	curl_multi_socket_action(cm->c_handle, CURL_SOCKET_TIMEOUT,0,&running_handles);
	//cm->timer = NULL;//不需要销毁,callback返回0后会被自动销毁
	return 1;
}

static int curl_glue_on_io(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
        CurlGlue *g = userdata;
        int action, k = 0, translated_fd;

        assert(s);
        assert(g);

        translated_fd = PTR_TO_FD(hashmap_get(g->translate_fds, FD_TO_PTR(fd)));

        if ((revents & (EPOLLIN|EPOLLOUT)) == (EPOLLIN|EPOLLOUT))
                action = CURL_POLL_INOUT;
        else if (revents & EPOLLIN)
                action = CURL_POLL_IN;
        else if (revents & EPOLLOUT)
                action = CURL_POLL_OUT;
        else
                action = 0;

        if (curl_multi_socket_action(g->curl, translated_fd, action, &k) < 0) {
                log_debug("Failed to propagate IO event.");
                return -EINVAL;
        }

        curl_glue_check_finished(g);
        return 0;
}

 /* Called by asio when our timeout expires */
 void http_client::timer_cb(const boost::system::error_code& e) {
   if(!e) {
     BOOST_LOG_TRIVIAL(trace) << this << ", " << BOOST_CURRENT_FUNCTION;
     // CURL_SOCKET_TIMEOUT, 0 is corrent on timeouts http://curl.haxx.se/libcurl/c/curl_multi_socket_action.html
     CURLMcode rc = curl_multi_socket_action(_multi, CURL_SOCKET_TIMEOUT, 0, &_still_running);
     //check_multi_info(); //TBD kolla om denna ska vara här
   }
 }

    static void asio_timer_callback(const boost::system::error_code& error, void* data) {
        if (!error) {
            asyn_http_object* aho = (asyn_http_object*)data;
            CURLMcode code = curl_multi_socket_action(aho->curlm, CURL_SOCKET_TIMEOUT, 0, &aho->still_running);

            check_multi_curl(data);
        }
    }

// This function is for signalling to curl a given time has passed.
// This timeout is usually given by curl itself.
void iotjs_https_uv_timeout_callback(uv_timer_t* timer) {
  iotjs_https_t* https_data = (iotjs_https_t*)(timer->data);
  IOTJS_VALIDATED_STRUCT_METHOD(iotjs_https_t, https_data);
  uv_timer_stop(timer);
  curl_multi_socket_action(_this->curl_multi_handle, CURL_SOCKET_TIMEOUT, 0,
                           &_this->running_handles);
  iotjs_https_check_done(https_data);
}

CURLMcode debug_curl_multi_socket_action(CURLM* multi_handle, curl_socket_t sockfd, int ev_bitmask, int* running_handles)
{
  CURLMcode ret;
  ret = curl_multi_socket_action(multi_handle, sockfd, ev_bitmask, running_handles);
  Dout(dc::curl, "curl_multi_socket_action(" << (AICURLM*)multi_handle << ", " << Socket(sockfd) <<
	  ", " << EvBitmask(ev_bitmask) << ", {" << (ret == CURLM_OK ? *running_handles : 0) << "}) = " << ret);
  return ret;
}

void ConnectionManager::TimerTriggered() {
    
    WriteManagerLog(this) << "Timer triggered.";
    
    int running_count = 0;
    curl_multi_socket_action(multi_handle_, CURL_SOCKET_TIMEOUT, 0, &running_count);
    CheckFinishedConnections();
}

 void http_client::socket_rx_cb(const boost::system::error_code& e, boost::asio::ip::tcp::socket * tcp_socket, call_context::handle context) {
   if(!e && !context->_curl_done) {
     //BOOST_LOG_TRIVIAL(debug) << "socket_rx_cb " << e << " bytes " << tcp_socket->available();
     CURLMcode rc = curl_multi_socket_action(_multi, tcp_socket->native_handle(), CURL_CSELECT_IN, &_still_running);
     if(!context->_curl_done)
       tcp_socket->async_read_some(boost::asio::null_buffers(), boost::bind(&http_client::socket_rx_cb, this, boost::asio::placeholders::error, tcp_socket, context));
   }
 }

static void
_ev_timer_curl_cb(struct ev_loop *loop, struct ev_timer *w, int revents)
{
	int running = 0;
	struct curlev *cuev = w->data;
	curl_multi_socket_action(cuev->multi, CURL_SOCKET_TIMEOUT, 0, &running);
	xsyslog(LOG_INFO, "ev timer: %p, running: %d", (void*)cuev, running);
}

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