uvco::UvCurlContext_ Class Reference

Classes
struct	PollCtx
	A uv poll handle with its associated CurlRequest_. More...

Public Member Functions
	UvCurlContext_ (const Loop &loop)
	UvCurlContext_ (const UvCurlContext_ &)=delete
	UvCurlContext_ (UvCurlContext_ &&)=delete
UvCurlContext_ &	operator= (const UvCurlContext_ &)=delete
UvCurlContext_ &	operator= (UvCurlContext_ &&)=delete
	~UvCurlContext_ ()
void	addHandle (CURL *handle)
	Add a Curl easy handle to the multi handle.
void	removeHandle (CURL *handle)
	Remove a Curl easy handle from the multi handle.
void	checkCurlInfo () const
	Checks with Curl for any completed/errored requests.
void	initPoll (CurlRequestCore_ *request, curl_socket_t newSocket) noexcept
void	uvStartPoll (curl_socket_t socket, unsigned int events) noexcept
void	uvStopPoll (curl_socket_t socket) noexcept
CurlRequestCore_ &	getRequest (curl_socket_t socket)
Promise< void >	close ()
	Close all open sockets and the timer.

Static Public Member Functions
static int	curlSocketFunction (CURL *easy, curl_socket_t socket, int action, void *userp, void *)
static int	curlTimerFunction (CURLM *, long timeoutMs, void *userp)
	Called by Curl to inform us of a timeout to set up.
static void	onUvTimeout (uv_timer_t *timer)
	Called by libuv when a timeout timer expires.
static void	onCurlSocketActive (uv_poll_t *poll, int status, int events)
	Called by libuv when there is activity on a curl socket.

Private Attributes
CURLM *	multi_
uv_loop_t *	loop_
std::unique_ptr< uv_timer_t >	timer_
std::map< curl_socket_t, PollCtx >	polls_

Detailed Description

Contains references to the libcurl multi handle and the libuv loop. Only valid as long as one loop instance is running. Used as context for curl socket functions (SOCKETDATA) and timer functions (TIMERDATA).

Constructor & Destructor Documentation

UvCurlContext_() [1/3]

uvco::UvCurlContext_::UvCurlContext_ ( const Loop & loop )

explicit

    : multi_{curl_multi_init()}, loop_{loop.uvloop()},
      timer_{std::make_unique<uv_timer_t>()} {
  uv_timer_init(loop_, timer_.get());
  // Set handle data for onUvTimeout callback.
  setData(timer_.get(), this);
 
  // Initialize Curl callbacks.
  curl_multi_setopt(multi_, CURLMOPT_SOCKETFUNCTION,
                    UvCurlContext_::curlSocketFunction);
  curl_multi_setopt(multi_, CURLMOPT_SOCKETDATA, this);
  curl_multi_setopt(multi_, CURLMOPT_TIMERFUNCTION,
                    UvCurlContext_::curlTimerFunction);
  curl_multi_setopt(multi_, CURLMOPT_TIMERDATA, this);
}

UvCurlContext_() [2/3]

uvco::UvCurlContext_::UvCurlContext_ ( const UvCurlContext_ & )

delete

UvCurlContext_() [3/3]

uvco::UvCurlContext_::UvCurlContext_ ( UvCurlContext_ && )

delete

~UvCurlContext_()

uvco::UvCurlContext_::~UvCurlContext_ ( )

inline

                    {
    if (multi_ != nullptr) {
      curl_multi_cleanup(multi_);
      multi_ = nullptr;
    }
 
    for (auto &[socket, poll] : polls_) {
      closeHandle(poll.poll.release());
    }
    polls_.clear();
    if (timer_ != nullptr) {
      closeHandle(timer_.release());
    }
    BOOST_ASSERT_MSG(polls_.empty(),
                     "UvCurlContext_ must be closed before destruction");
  }

Member Function Documentation

addHandle()

void uvco::UvCurlContext_::addHandle ( CURL * handle )

inline

Add a Curl easy handle to the multi handle.

{ curl_multi_add_handle(multi_, handle); }

checkCurlInfo()

void uvco::UvCurlContext_::checkCurlInfo

(

)

const

Checks with Curl for any completed/errored requests.

                                         {
  CURLMsg *msg{};
  long responseCode{};
  long verifyResult{};
  int inQueue{};
 
  // Check for completed requests.
  while (nullptr != (msg = curl_multi_info_read(multi_, &inQueue))) {
    if (msg->msg == CURLMSG_DONE) {
      CurlRequestCore_ *request{};
      BOOST_VERIFY(CURLE_OK == curl_easy_getinfo(msg->easy_handle,
                                                 CURLINFO_PRIVATE, &request));
      BOOST_VERIFY(CURLE_OK == curl_easy_getinfo(msg->easy_handle,
                                                 CURLINFO_RESPONSE_CODE,
                                                 &responseCode));
      BOOST_VERIFY(CURLE_OK == curl_easy_getinfo(msg->easy_handle,
                                                 CURLINFO_SSL_VERIFYRESULT,
                                                 &verifyResult));
      request->setCurlStatus(msg->data.result);
      request->setResponseCode(responseCode);
      request->setVerifyResult(verifyResult);
      request->onError(0);
    }
  }
}

close()

Promise< void > uvco::UvCurlContext_::close ( )

inline

Close all open sockets and the timer.

                        {
    if (multi_ != nullptr) {
      curl_multi_cleanup(multi_);
      multi_ = nullptr;
    }
 
    std::vector<Promise<void>> promises;
    promises.reserve(polls_.size());
    for (auto &[socket, poll] : polls_) {
      closeHandle(poll.poll.release());
    }
    for (auto &promise : promises) {
      co_await promise;
    }
    polls_.clear();
    closeHandle(timer_.release());
    timer_.reset();
  }

curlSocketFunction()

int uvco::UvCurlContext_::curlSocketFunction ( CURL * easy, curl_socket_t socket, int action, void * userp, void *  )

static

Called by Curl to inform us of a new socket to monitor or a socket to be removed.

                                                 {
  auto *context = static_cast<UvCurlContext_ *>(userp);
 
  switch (action) {
  case CURL_POLL_IN:
  case CURL_POLL_OUT:
  case CURL_POLL_INOUT: {
    unsigned int watchFor{};
 
    // Obtain request object so it can be associated with socket for error
    // handling.
    CurlRequestCore_ *request{};
    curl_easy_getinfo(easy, CURLINFO_PRIVATE, &request);
 
    if (action != CURL_POLL_IN) {
      watchFor |= UV_WRITABLE;
    }
    if (action != CURL_POLL_OUT) {
      watchFor |= UV_READABLE;
    }
 
    context->initPoll(request, socket);
    context->uvStartPoll(socket, watchFor);
    break;
  }
 
  case CURL_POLL_REMOVE: {
    context->uvStopPoll(socket);
    break;
  }
 
  default:
    BOOST_ASSERT(false);
  }
 
  return 0;
}

curlTimerFunction()

int uvco::UvCurlContext_::curlTimerFunction ( CURLM * , long timeoutMs, void * userp )

static

Called by Curl to inform us of a timeout to set up.

                                                   {
  auto *curl = static_cast<UvCurlContext_ *>(userp);
  uv_timer_t &timer = *curl->timer_;
  if (timeoutMs < 0) {
    uv_timer_stop(&timer);
  } else {
    uv_timer_start(&timer, UvCurlContext_::onUvTimeout, timeoutMs, 0);
  }
  return 0;
}

getRequest()

CurlRequestCore_ & uvco::UvCurlContext_::getRequest ( curl_socket_t socket )

inline

Returns the CurlRequest associated with the given socket. This is essential for notifying individual requests of socket errors; socket errors occur in a uv callbcak which only has access to the socket.

                                                     {
    const auto it = polls_.find(socket);
    BOOST_ASSERT(it != polls_.end());
    return *it->second.request;
  }

initPoll()

void uvco::UvCurlContext_::initPoll ( CurlRequestCore_ * request, curl_socket_t newSocket )

inlinenoexcept

                                                                             {
    const auto it = polls_.find(newSocket);
    if (it != polls_.end()) {
      // Already initialized. Ensure that socket is associated with the correct
      // request in case Curl reuses a socket.
      it->second.request = request;
      return;
    }
    const auto newPollCtx =
        polls_.emplace(newSocket, std::make_unique<uv_poll_t>());
    uv_poll_t &poll = *newPollCtx.first->second.poll;
    newPollCtx.first->second.request = request;
    uv_poll_init_socket(loop_, &poll, newSocket);
    setData(&poll, this);
  }

onCurlSocketActive()

void uvco::UvCurlContext_::onCurlSocketActive ( uv_poll_t * poll, int status, int events )

static

Called by libuv when there is activity on a curl socket.

                                                    {
  int runningHandles{};
  unsigned int flags{};
  auto *context = getData<UvCurlContext_>(poll);
 
  curl_socket_t socket{};
  const uv_status filenoStatus = uv_fileno((uv_handle_t *)poll, &socket);
  if (filenoStatus != 0) {
    throw UvcoException{filenoStatus, "while getting file descriptor"};
  }
 
  if (status != 0) {
    context->getRequest(socket).onError(status);
    return;
  }
 
  if ((static_cast<unsigned>(events) & UV_READABLE) != 0) {
    flags |= CURL_CSELECT_IN;
  }
  if ((static_cast<unsigned>(events) & UV_WRITABLE) != 0) {
    flags |= CURL_CSELECT_OUT;
  }
 
  curl_multi_socket_action(context->multi_, socket, static_cast<int>(flags),
                           &runningHandles);
  context->checkCurlInfo();
}

onUvTimeout()

void uvco::UvCurlContext_::onUvTimeout ( uv_timer_t * timer )

static

Called by libuv when a timeout timer expires.

                                                  {
  auto *curl = getData<UvCurlContext_>(timer);
  int runningHandles = 0;
  curl_multi_socket_action(curl->multi_, CURL_SOCKET_TIMEOUT, 0,
                           &runningHandles);
}

operator=() [1/2]

UvCurlContext_ & uvco::UvCurlContext_::operator= ( const UvCurlContext_ & )

delete

operator=() [2/2]

UvCurlContext_ & uvco::UvCurlContext_::operator= ( UvCurlContext_ && )

delete

removeHandle()

void uvco::UvCurlContext_::removeHandle ( CURL * handle )

inline

Remove a Curl easy handle from the multi handle.

{ curl_multi_remove_handle(multi_, handle); }

uvStartPoll()

void uvco::UvCurlContext_::uvStartPoll ( curl_socket_t socket, unsigned int events )

inlinenoexcept

                                                                       {
    const auto it = polls_.find(socket);
    BOOST_ASSERT(it != polls_.end());
    uv_poll_t &poll = *it->second.poll;
    uv_poll_start(&poll, static_cast<int>(events),
                  UvCurlContext_::onCurlSocketActive);
  }

uvStopPoll()

void uvco::UvCurlContext_::uvStopPoll ( curl_socket_t socket )

inlinenoexcept

                                                 {
    const auto it = polls_.find(socket);
    if (it != polls_.end()) {
      uv_poll_stop(it->second.poll.get());
    }
  }

Member Data Documentation

loop_

uv_loop_t* uvco::UvCurlContext_::loop_

private

multi_

CURLM* uvco::UvCurlContext_::multi_

private

polls_

std::map<curl_socket_t, PollCtx> uvco::UvCurlContext_::polls_

private

timer_

std::unique_ptr<uv_timer_t> uvco::UvCurlContext_::timer_

private

---

The documentation for this class was generated from the following file:

• uvco/integrations/curl/curl.cc