Slic3r::Http::priv Struct Reference

Collaboration diagram for Slic3r::Http::priv:

Public Types
enum	{ DEFAULT_TIMEOUT_CONNECT = 10 , DEFAULT_TIMEOUT_MAX = 0 , DEFAULT_SIZE_LIMIT = 5 * 1024 * 1024 }

Public Member Functions
	priv (const std::string &url)
	~priv ()
void	set_timeout_connect (long timeout)
void	set_timeout_max (long timeout)
void	form_add_file (const char *name, const fs::path &path, const char *filename)
void	set_post_body (const fs::path &path)
void	set_post_body (const std::string &body)
void	set_put_body (const fs::path &path)
void	set_range (const std::string &range)
std::string	curl_error (CURLcode curlcode)
std::string	body_size_error ()
void	http_perform ()

Static Public Member Functions
static bool	ca_file_supported (::CURL *curl)
static size_t	writecb (void *data, size_t size, size_t nmemb, void *userp)
static int	xfercb (void *userp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
static int	xfercb_legacy (void *userp, double dltotal, double dlnow, double ultotal, double ulnow)
static size_t	form_file_read_cb (char *buffer, size_t size, size_t nitems, void *userp)

Public Attributes
::CURL *	curl
::curl_httppost *	form
::curl_httppost *	form_end
::curl_slist *	headerlist
std::string	buffer
std::deque< fs::ifstream >	form_files
std::string	postfields
std::string	error_buffer
size_t	limit
bool	cancel
std::unique_ptr< fs::ifstream >	putFile
std::thread	io_thread
Http::CompleteFn	completefn
Http::ErrorFn	errorfn
Http::ProgressFn	progressfn
Http::IPResolveFn	ipresolvefn

Detailed Description

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
DEFAULT_TIMEOUT_CONNECT
DEFAULT_TIMEOUT_MAX
DEFAULT_SIZE_LIMIT

       {
    DEFAULT_TIMEOUT_CONNECT = 10,
        DEFAULT_TIMEOUT_MAX = 0,
    DEFAULT_SIZE_LIMIT = 5 * 1024 * 1024,
  };

Constructor & Destructor Documentation

priv()

Slic3r::Http::priv::priv

(

const std::string &

url

)

  : curl(::curl_easy_init())
  , form(nullptr)
  , form_end(nullptr)
  , headerlist(nullptr)
  , error_buffer(CURL_ERROR_SIZE + 1, '\0')
  , limit(0)
  , cancel(false)
{
    Http::tls_global_init();
 
  if (curl == nullptr) {
    throw Slic3r::RuntimeError(std::string("Could not construct Curl object"));
  }
 
  set_timeout_connect(DEFAULT_TIMEOUT_CONNECT);
    set_timeout_max(DEFAULT_TIMEOUT_MAX);
  ::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());   // curl makes a copy internally
  ::curl_easy_setopt(curl, CURLOPT_USERAGENT, SLIC3R_APP_NAME "/" SLIC3R_VERSION);
  ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer.front());
}

References curl, DEFAULT_TIMEOUT_CONNECT, DEFAULT_TIMEOUT_MAX, error_buffer, set_timeout_connect(), set_timeout_max(), and Slic3r::Http::tls_global_init().

Here is the call graph for this function:

~priv()

Slic3r::Http::priv::~priv

(

)

{
  ::curl_easy_cleanup(curl);
  ::curl_formfree(form);
  ::curl_slist_free_all(headerlist);
}

Member Function Documentation

body_size_error()

std::string Slic3r::Http::priv::body_size_error

(

)

{
  return (boost::format("HTTP body data size exceeded limit (%1% bytes)") % limit).str();
}

ca_file_supported()

bool Slic3r::Http::priv::ca_file_supported ( ::CURL *  curl )

static

{
#if defined(_WIN32) || defined(__APPLE__)
  bool res = false;
#else
  bool res = true;
#endif
 
  if (curl == nullptr) { return res; }
 
#if LIBCURL_VERSION_MAJOR >= 7 && LIBCURL_VERSION_MINOR >= 48
  ::curl_tlssessioninfo *tls;
  if (::curl_easy_getinfo(curl, CURLINFO_TLS_SSL_PTR, &tls) == CURLE_OK) {
    if (tls->backend == CURLSSLBACKEND_SCHANNEL || tls->backend == CURLSSLBACKEND_DARWINSSL) {
      // With Windows and OS X native SSL support, cert files cannot be set
            // DK: OSX is now not building CURL and links system one, thus we do not know which backend is installed. Still, false will be returned since the ifdef at the begining if this function.
      res = false;
    }
  }
#endif
 
  return res;
}

Referenced by Slic3r::Http::ca_file(), and Slic3r::Http::ca_file_supported().

Here is the caller graph for this function:

curl_error()

std::string Slic3r::Http::priv::curl_error

(

CURLcode

curlcode

)

{
  return (boost::format("%1%:\n%2%\n[Error %3%]")
    % ::curl_easy_strerror(curlcode)
    % error_buffer.c_str()
    % curlcode
  ).str();
}

form_add_file()

void Slic3r::Http::priv::form_add_file	(	const char *	name,
		const fs::path &	path,
		const char *	filename
	)

{
  // We can't use CURLFORM_FILECONTENT, because curl doesn't support Unicode filenames on Windows
  // and so we use CURLFORM_STREAM with boost ifstream to read the file.
 
  if (filename == nullptr) {
    filename = path.string().c_str();
  }
 
  form_files.emplace_back(path, std::ios::in | std::ios::binary);
  auto &stream = form_files.back();
  stream.seekg(0, std::ios::end);
  size_t size = stream.tellg();
  stream.seekg(0);
 
  if (filename != nullptr) {
    ::curl_formadd(&form, &form_end,
      CURLFORM_COPYNAME, name,
      CURLFORM_FILENAME, filename,
      CURLFORM_CONTENTTYPE, "application/octet-stream",
      CURLFORM_STREAM, static_cast<void*>(&stream),
      CURLFORM_CONTENTSLENGTH, static_cast<long>(size),
      CURLFORM_END
    );
  }
}

form_file_read_cb()

size_t Slic3r::Http::priv::form_file_read_cb ( char *  buffer, size_t  size, size_t  nitems, void *  userp  )

static

{
  auto stream = reinterpret_cast<fs::ifstream*>(userp);
 
  try {
    stream->read(buffer, size * nitems);
  } catch (const std::exception &) {
    return CURL_READFUNC_ABORT;
  }
 
  return stream->gcount();
}

http_perform()

void Slic3r::Http::priv::http_perform

(

)

{
  ::curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
  ::curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
  ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writecb);
  ::curl_easy_setopt(curl, CURLOPT_WRITEDATA, static_cast<void*>(this));
  ::curl_easy_setopt(curl, CURLOPT_READFUNCTION, form_file_read_cb);
 
  ::curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
#if LIBCURL_VERSION_MAJOR >= 7 && LIBCURL_VERSION_MINOR >= 32
  ::curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, xfercb);
  ::curl_easy_setopt(curl, CURLOPT_XFERINFODATA, static_cast<void*>(this));
#ifndef _WIN32
  (void)xfercb_legacy;   // prevent unused function warning
#endif
#else
  ::curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, xfercb);
  ::curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, static_cast<void*>(this));
#endif
 
  ::curl_easy_setopt(curl, CURLOPT_VERBOSE, get_logging_level() >= 5);
 
  if (headerlist != nullptr) {
    ::curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
  }
 
  if (form != nullptr) {
    ::curl_easy_setopt(curl, CURLOPT_HTTPPOST, form);
  }
 
  if (!postfields.empty()) {
    ::curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postfields.c_str());
    ::curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, postfields.size());
  }
 
  CURLcode res = ::curl_easy_perform(curl);
 
    putFile.reset();
 
  if (res != CURLE_OK) {
    if (res == CURLE_ABORTED_BY_CALLBACK) {
      if (cancel) {
        // The abort comes from the request being cancelled programatically
        Progress dummyprogress(0, 0, 0, 0, std::string());
        bool cancel = true;
        if (progressfn) { progressfn(dummyprogress, cancel); }
      } else {
        // The abort comes from the CURLOPT_READFUNCTION callback, which means reading file failed
        if (errorfn) { errorfn(std::move(buffer), "Error reading file for file upload", 0); }
      }
    }
    else if (res == CURLE_WRITE_ERROR) {
      if (errorfn) { errorfn(std::move(buffer), body_size_error(), 0); }
    } else {
      if (errorfn) { errorfn(std::move(buffer), curl_error(res), 0); }
    };
  } else {
    long http_status = 0;
    ::curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_status);
 
    if (http_status >= 400) {
      if (errorfn) { errorfn(std::move(buffer), std::string(), http_status); }
    } else {
      if (completefn) { completefn(std::move(buffer), http_status); }
      if (ipresolvefn) {
        char* ct;
        res = curl_easy_getinfo(curl, CURLINFO_PRIMARY_IP, &ct);
        if ((CURLE_OK == res) && ct) {
          ipresolvefn(ct);
        }
      }
    }
  }
}

References Slic3r::Http::cancel(), Slic3r::get_logging_level(), L, and void().

Here is the call graph for this function:

set_post_body() [1/2]

void Slic3r::Http::priv::set_post_body

(

const fs::path &

path

)

{
  std::ifstream file(path.string());
  std::string file_content { std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>() };
  postfields = std::move(file_content);
}

set_post_body() [2/2]

void Slic3r::Http::priv::set_post_body

(

const std::string &

body

)

{
  postfields = body;
}

set_put_body()

void Slic3r::Http::priv::set_put_body

(

const fs::path &

path

)

{
  boost::system::error_code ec;
  boost::uintmax_t filesize = file_size(path, ec);
  if (!ec) {
        putFile = std::make_unique<fs::ifstream>(path);
        ::curl_easy_setopt(curl, CURLOPT_READDATA, (void *) (putFile.get()));
    ::curl_easy_setopt(curl, CURLOPT_INFILESIZE, filesize);
  }
}

set_range()

void Slic3r::Http::priv::set_range

(

const std::string &

range

)

{
  ::curl_easy_setopt(curl, CURLOPT_RANGE, range.c_str());
}

References Slic3r::range().

Here is the call graph for this function:

set_timeout_connect()

void Slic3r::Http::priv::set_timeout_connect

(

long

timeout

)

{
  ::curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, timeout);
}

Referenced by priv().

Here is the caller graph for this function:

set_timeout_max()

void Slic3r::Http::priv::set_timeout_max

(

long

timeout

)

{
    ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
}

Referenced by priv().

Here is the caller graph for this function:

writecb()

size_t Slic3r::Http::priv::writecb ( void *  data, size_t  size, size_t  nmemb, void *  userp  )

static

{
  auto self = static_cast<priv*>(userp);
  const char *cdata = static_cast<char*>(data);
  const size_t realsize = size * nmemb;
  const size_t limit = self->limit > 0 ? self->limit : DEFAULT_SIZE_LIMIT;
  if (self->buffer.size() + realsize > limit) {
    // This makes curl_easy_perform return CURLE_WRITE_ERROR
    return 0;
  }
 
  self->buffer.append(cdata, realsize);
 
  return realsize;
}

xfercb()

int Slic3r::Http::priv::xfercb ( void *  userp, curl_off_t  dltotal, curl_off_t  dlnow, curl_off_t  ultotal, curl_off_t  ulnow  )

static

{
  auto self = static_cast<priv*>(userp);
  bool cb_cancel = false;
 
  if (self->progressfn) {
    Progress progress(dltotal, dlnow, ultotal, ulnow, self->buffer);
    self->progressfn(progress, cb_cancel);
  }
 
  if (cb_cancel) { self->cancel = true; }
 
  return self->cancel;
}

xfercb_legacy()

int Slic3r::Http::priv::xfercb_legacy ( void *  userp, double  dltotal, double  dlnow, double  ultotal, double  ulnow  )

static

{
  return xfercb(userp, dltotal, dlnow, ultotal, ulnow);
}

Member Data Documentation

buffer

std::string Slic3r::Http::priv::buffer

cancel

bool Slic3r::Http::priv::cancel

completefn

Http::CompleteFn Slic3r::Http::priv::completefn

curl

::CURL* Slic3r::Http::priv::curl

Referenced by priv().

error_buffer

std::string Slic3r::Http::priv::error_buffer

Referenced by priv().

errorfn

Http::ErrorFn Slic3r::Http::priv::errorfn

form

::curl_httppost* Slic3r::Http::priv::form

form_end

::curl_httppost* Slic3r::Http::priv::form_end

form_files

std::deque<fs::ifstream> Slic3r::Http::priv::form_files

headerlist

::curl_slist* Slic3r::Http::priv::headerlist

io_thread

std::thread Slic3r::Http::priv::io_thread

ipresolvefn

Http::IPResolveFn Slic3r::Http::priv::ipresolvefn

limit

size_t Slic3r::Http::priv::limit

postfields

std::string Slic3r::Http::priv::postfields

progressfn

Http::ProgressFn Slic3r::Http::priv::progressfn

putFile

std::unique_ptr<fs::ifstream> Slic3r::Http::priv::putFile

---

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

• src/slic3r/Utils/Http.cpp