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 = 1024 * 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, boost::filesystem::ifstream::off_type offset, size_t length)
void	mime_form_add_text (const char *name, const char *value)
void	mime_form_add_file (const char *name, const char *path)
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_del_body (const std::string &body)
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)
static size_t	headers_cb (char *buffer, size_t size, size_t nitems, void *userp)

Public Attributes
::CURL *	curl
::curl_httppost *	form
::curl_httppost *	form_end
::curl_mime *	mime
::curl_slist *	headerlist
std::string	url
std::string	method
std::string	buffer
std::deque< form_file >	form_files
std::string	postfields
std::string	error_buffer
std::string	headers
size_t	limit
std::atomic_bool	cancel
std::unique_ptr< form_file >	putFile
std::thread	io_thread
Http::CompleteFn	completefn
Http::ErrorFn	errorfn
Http::ProgressFn	progressfn
Http::IPResolveFn	ipresolvefn
Http::HeaderCallbackFn	headerfn

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 = 1024 * 1024 * 1024,
  };

Constructor & Destructor Documentation

priv()

Slic3r::Http::priv::priv

(

const std::string &

url

)

  : curl(::curl_easy_init())
  , form(nullptr)
  , form_end(nullptr)
  , mime(nullptr)
  , headerlist(nullptr)
  , url(url)
  , method("GET")
  , 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_DEBUGFUNCTION, log_trace);
  ::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());   // curl makes a copy internally
  ::curl_easy_setopt(curl, CURLOPT_USERAGENT, SLIC3R_APP_NAME "/" SoftFever_VERSION);
  ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer.front());
#ifdef __WINDOWS__
  ::curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_MAX_TLSv1_2);
#endif
  ::curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
  ::curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
 
  // https://everything.curl.dev/http/post/expect100.html
  // remove the Expect: header, it will add a second delay to each request,
  // if the file is uploaded in packets, it will cause the upload time to be longer
  headerlist = curl_slist_append(headerlist, "Expect:");
}

References cancel, curl, DEFAULT_TIMEOUT_CONNECT, DEFAULT_TIMEOUT_MAX, error_buffer, form, form_end, headerlist, L, limit, Slic3r::log_trace(), method, mime, set_timeout_connect(), set_timeout_max(), Slic3r::Http::tls_global_init(), and url.

Here is the call graph for this function:

~priv()

Slic3r::Http::priv::~priv

(

)

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

References curl, form, headerlist, and mime.

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

References limit.

Referenced by http_perform().

Here is the caller graph for this function:

ca_file_supported()

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

static

{
  //BBS support set ca file by default
  bool res = true;
 
  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
      res = false;
    }
  }
#endif
 
  return res;
}

References curl.

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("curl:%1%:\n%2%\n[Error %3%]")
    % ::curl_easy_strerror(curlcode)
    % error_buffer.c_str()
    % curlcode
  ).str();
}

References error_buffer.

Referenced by http_perform().

Here is the caller graph for this function:

form_add_file()

void Slic3r::Http::priv::form_add_file	(	const char *	name,
		const fs::path &	path,
		const char *	filename,
		boost::filesystem::ifstream::off_type	offset,
		size_t	length )

{
  // 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.
 
  std::string filename_str;
  if (filename == nullptr) {
    filename_str = path.string();
    filename = filename_str.c_str();
  }
 
  form_files.emplace_back(path, offset, length);
  auto &f = form_files.back();
    size_t size = length;
    if (length == 0) {
        f.ifs.seekg(0, std::ios::end);
        size = f.ifs.tellg() - offset;
    }
    f.ifs.seekg(offset);
 
  if (filename != nullptr) {
    ::curl_formadd(&form, &form_end,
      CURLFORM_COPYNAME, name,
      CURLFORM_FILENAME, filename,
      CURLFORM_CONTENTTYPE, "application/octet-stream",
      CURLFORM_STREAM, static_cast<void*>(&f),
      CURLFORM_CONTENTSLENGTH, static_cast<long>(size),
      CURLFORM_END
    );
  }
}

References Slic3r::f(), form, form_end, form_files, Slic3r::length(), and Slic3r::offset().

Here is the call graph for this function:

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 f = reinterpret_cast<form_file*>(userp);
 
  try {
      size_t max_read_size = size * nitems;
        if (f->content_length == 0) {
      // Unlimited
            f->ifs.read(buffer, max_read_size);
        } else {
            unsigned long long read_size = f->ifs.tellg() - f->init_offset;
            if (read_size >= f->content_length) {
                return 0;
            }
 
            max_read_size = std::min(max_read_size, size_t(f->content_length - read_size));
            f->ifs.read(buffer, max_read_size);
        }
  } catch (const std::exception &) {
    return CURL_READFUNC_ABORT;
  }
 
  return f->ifs.gcount();
}

References buffer, and Slic3r::f().

Referenced by http_perform().

Here is the call graph for this function:

Here is the caller graph for this function:

headers_cb()

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

static

{
  auto self = static_cast<priv*>(userp);
 
  if (self->headerfn) {
        self->headers.append(buffer, nitems * size);
    self->headerfn(self->headers);
  }
  return nitems * size;
}

References buffer.

Referenced by http_perform().

Here is the caller graph for this function:

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);
  //BBS set header functions
  ::curl_easy_setopt(curl, CURLOPT_HEADERDATA, static_cast<void *>(this));
  ::curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, headers_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, 1L);
 
  if (headerlist != nullptr) {
    ::curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
  }
 
  if (form != nullptr) {
    ::curl_easy_setopt(curl, CURLOPT_HTTPPOST, form);
  }
 
  if (mime != nullptr) {
    ::curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);
  }
 
  if (!postfields.empty()) {
    ::curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postfields.c_str());
    ::curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, postfields.size());
  } else if (method == "POST" && form == nullptr && mime == nullptr) {
    // A POST with no body. Without CURLOPT_POSTFIELDS, curl takes the request body from
    // the read callback, but form_file_read_cb only has a usable user pointer for a PUT
    // (set_put_body) or a streamed multipart part (form_add_file); for an empty POST it
    // dereferences libcurl's default READDATA as a form_file and crashes. Point curl at a
    // zero-length body so the read callback is never used.
    ::curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postfields.c_str());
    ::curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, static_cast<curl_off_t>(0));
  }
 
  CURLcode res = ::curl_easy_perform(curl);
 
    putFile.reset();
 
  if (res != CURLE_OK) {
    if (res == CURLE_ABORTED_BY_CALLBACK) {
      if (cancel.load()) {
        // 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);
 
    //BBS check success http status code
    if (http_status >= 200 && http_status < 300) {
      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);
        }
      }
    }
    //BBS check error http status code
    else if (http_status >= 400) {
      if (errorfn) { errorfn(std::move(buffer), std::string(), http_status); }
    }
  }
}

References body_size_error(), buffer, cancel, completefn, curl, curl_error(), errorfn, form, form_file_read_cb(), headerlist, headers_cb(), ipresolvefn, L, method, mime, postfields, progressfn, putFile, writecb(), xfercb(), and xfercb_legacy().

Here is the call graph for this function:

mime_form_add_file()

void Slic3r::Http::priv::mime_form_add_file	(	const char *	name,
		const char *	path )

{
  if (!mime) {
    mime = curl_mime_init(curl);
  }
 
  curl_mimepart* part;
  part = curl_mime_addpart(mime);
  curl_mime_name(part, "file");
  curl_mime_type(part, "multipart/form-data");
  curl_mime_filedata(part, path);
  // BBS specify filename after filedata
  curl_mime_filename(part, name);
}

References curl, and mime.

mime_form_add_text()

void Slic3r::Http::priv::mime_form_add_text	(	const char *	name,
		const char *	value )

{
  if (!mime) {
    mime = curl_mime_init(curl);
  }
 
  curl_mimepart *part;
  part = curl_mime_addpart(mime);
  curl_mime_name(part, name);
  curl_mime_type(part, "multipart/form-data");
  curl_mime_data(part, value, CURL_ZERO_TERMINATED);
}

References curl, and mime.

set_del_body()

void Slic3r::Http::priv::set_del_body

(

const std::string &

body

)

{
  postfields = body;
}

References postfields.

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

References postfields.

set_post_body() [2/2]

void Slic3r::Http::priv::set_post_body

(

const std::string &

body

)

{
  postfields = body;
}

References postfields.

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<form_file>(path, 0, 0);
    ::curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
    ::curl_easy_setopt(curl, CURLOPT_READDATA, (void *) (putFile.get()));
    ::curl_easy_setopt(curl, CURLOPT_INFILESIZE, filesize);
  }
}

References curl, and putFile.

set_range()

void Slic3r::Http::priv::set_range

(

const std::string &

range

)

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

References curl, and 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);
}

References curl.

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

References curl.

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

References DEFAULT_SIZE_LIMIT, and limit.

Referenced by http_perform().

Here is the caller graph for this function:

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) {
    double speed = 0.;
        curl_easy_getinfo(self->curl, CURLINFO_SPEED_UPLOAD, &speed);
    Progress progress(dltotal, dlnow, ultotal, ulnow, self->buffer, speed);
    self->progressfn(progress, cb_cancel);
  }
 
  if (cb_cancel) { self->cancel.store(true); }
 
  return self->cancel.load();
}

Referenced by http_perform(), and xfercb_legacy().

Here is the caller graph for this function:

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

References xfercb().

Referenced by http_perform().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

buffer

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

Referenced by form_file_read_cb(), headers_cb(), and http_perform().

cancel

std::atomic_bool Slic3r::Http::priv::cancel

Referenced by priv(), and http_perform().

completefn

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

Referenced by http_perform().

curl

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

Referenced by priv(), ~priv(), ca_file_supported(), http_perform(), mime_form_add_file(), mime_form_add_text(), set_put_body(), set_range(), set_timeout_connect(), and set_timeout_max().

error_buffer

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

Referenced by priv(), and curl_error().

errorfn

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

Referenced by http_perform().

form

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

Referenced by priv(), ~priv(), form_add_file(), and http_perform().

form_end

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

Referenced by priv(), and form_add_file().

form_files

std::deque<form_file> Slic3r::Http::priv::form_files

Referenced by form_add_file().

headerfn

Http::HeaderCallbackFn Slic3r::Http::priv::headerfn

headerlist

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

Referenced by priv(), ~priv(), and http_perform().

headers

std::string Slic3r::Http::priv::headers

io_thread

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

ipresolvefn

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

Referenced by http_perform().

limit

size_t Slic3r::Http::priv::limit

Referenced by priv(), body_size_error(), and writecb().

method

std::string Slic3r::Http::priv::method

Referenced by priv(), and http_perform().

mime

::curl_mime* Slic3r::Http::priv::mime

Referenced by priv(), ~priv(), http_perform(), mime_form_add_file(), and mime_form_add_text().

postfields

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

Referenced by http_perform(), set_del_body(), set_post_body(), and set_post_body().

progressfn

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

Referenced by http_perform().

putFile

std::unique_ptr<form_file> Slic3r::Http::priv::putFile

Referenced by http_perform(), and set_put_body().

url

std::string Slic3r::Http::priv::url

Referenced by priv().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/Http.cpp