1 files changed, 0 insertions, 304 deletions
diff --git a/external/glim/curl.hpp b/external/glim/curl.hpp
deleted file mode 100644
index ff2ba9ac1..000000000
--- a/external/glim/curl.hpp
+++ /dev/null
@@ -1,304 +0,0 @@
-/** \file
- * Very simple header-only wrapper around libcurl.\n
- * See also: https://github.com/venam/Browser\n
- * See also: https://github.com/mologie/curl-asio\n
- * See also: http://thread.gmane.org/gmane.comp.web.curl.library/1322 (this one uses a temporary file). */
-
-#ifndef _GLIM_CURL_INCLUDED
-#define _GLIM_CURL_INCLUDED
-
-#include "gstring.hpp"
-#include "exception.hpp"
-#include <curl/curl.h>
-#include <algorithm>
-#include <functional>
-#include <string.h>
-#include <stdint.h>
-
-namespace glim {
-
-inline size_t curlWriteToString (void *buffer, size_t size, size_t nmemb, void *userp) {
-  ((std::string*) userp)->append ((const char*) buffer, size * nmemb);
-  return size * nmemb;};
-
-inline size_t curlReadFromString (void *ptr, size_t size, size_t nmemb, void *userdata);
-inline size_t curlReadFromGString (void *ptr, size_t size, size_t nmemb, void *userdata);
-inline size_t curlWriteHeader (void *ptr, size_t size, size_t nmemb, void *curlPtr);
-inline int curlDebugCB (CURL* curl, curl_infotype type, char* bytes, size_t size, void* curlPtr);
-
-/**
- Simple HTTP requests using cURL.
- Example: \code
-   std::string w3 = glim::Curl() .http ("http://www.w3.org/") .go().str();
- \endcode
- */
-class Curl {
- protected:
-  Curl (const Curl&): _curl (NULL), _headers (NULL), _sent (0), _needs_cleanup (true) {} // No copying.
- public:
-  struct PerformError: public glim::Exception {
-    PerformError (const char* message, const char* file, int32_t line):
-      glim::Exception (message, file, line) {}
-  };
-  struct GetinfoError: public glim::Exception {
-    CURLcode _code; std::string _error;
-    GetinfoError (CURLcode code, const std::string& error, const char* file, int32_t line):
-      glim::Exception (error, file, line),
-      _code (code), _error (error) {}
-  };
- public:
-  CURL* _curl;
-  struct curl_slist *_headers;
-  std::function<void (const char* header, int len)> _headerListener;
-  std::function<void (curl_infotype type, char* bytes, size_t size)> _debugListener;
-  std::string _sendStr; ///< We're using `std::string` instead of `gstring` in order to support payloads larger than 16 MiB.
-  glim::gstring _sendGStr; ///< `gstring::view` and `gstring::ref` allow us to zero-copy.
-  uint32_t _sent;
-  std::string _got;
-  bool _needs_cleanup:1; ///< ~Curl will do `curl_easy_cleanup` if `true`.
-  char _errorBuf[CURL_ERROR_SIZE];
-
-  Curl (Curl&&) = default;
-
-  /// @param cleanup can be turned off if the cURL is freed elsewhere.
-  Curl (bool cleanup = true): _curl (curl_easy_init()), _headers (NULL), _sent (0), _needs_cleanup (cleanup) {
-    curl_easy_setopt (_curl, CURLOPT_NOSIGNAL, 1L); // required per http://curl.haxx.se/libcurl/c/libcurl-tutorial.html#Multi-threading
-    *_errorBuf = 0;}
-  /// Wraps an existing handle (will invoke `curl_easy_cleanup` nevertheless).
-  /// @param cleanup can be turned off if the cURL is freed elsewhere.
-  Curl (CURL* curl, bool cleanup = true): _curl (curl), _headers (NULL), _sent (0), _needs_cleanup (cleanup) {
-    curl_easy_setopt (_curl, CURLOPT_NOSIGNAL, 1L); // required per http://curl.haxx.se/libcurl/c/libcurl-tutorial.html#Multi-threading
-    *_errorBuf = 0;}
-  ~Curl(){
-    if (_headers) {curl_slist_free_all (_headers); _headers = NULL;}
-    if (_curl) {if (_needs_cleanup) curl_easy_cleanup (_curl); _curl = NULL;}
-  }
-
-  /** Stores the content to be sent into an `std::string` inside `Curl`.
-   * NB: In order to have an effect this method should be used *before* the `http()` and `smtp()` methods. */
-  template<typename STR> Curl& send (STR&& text) {
-    _sendStr = std::forward<STR> (text);
-    _sendGStr.clear();
-    _sent = 0;
-    return *this;}
-
-  /// Adds "Content-Type" header into `_headers`.
-  Curl& contentType (const char* ct) {
-    char ctb[64]; gstring cth (sizeof (ctb), ctb, false, 0);
-    cth << "Content-Type: " << ct << "\r\n";
-    _headers = curl_slist_append (_headers, cth.c_str());
-    return *this;
-  }
-
-  /// @param fullHeader is a full HTTP header and a newline, e.g. "User-Agent: Me\r\n".
-  Curl& header (const char* fullHeader) {
-    _headers = curl_slist_append (_headers, fullHeader);
-    return *this;
-  }
-
-  /**
-   Sets the majority of options for the http request.
-   NB: If `send` was used with a non-empty string then `http` will use `CURLOPT_UPLOAD`, setting http method to `PUT` (use the `method()` to override).
-   \n
-   Example: \code
-     glim::Curl curl;
-     curl.http (url.c_str()) .go();
-     std::cout << curl.status() << std::endl << curl.str() << std::endl;
-   \endcode
-   */
-  Curl& http (const char* url, int timeoutSec = 20) {
-    curl_easy_setopt (_curl, CURLOPT_NOSIGNAL, 1L); // required per http://curl.haxx.se/libcurl/c/libcurl-tutorial.html#Multi-threading
-    curl_easy_setopt (_curl, CURLOPT_URL, url);
-    curl_easy_setopt (_curl, CURLOPT_WRITEFUNCTION, curlWriteToString);
-    curl_easy_setopt (_curl, CURLOPT_WRITEDATA, &_got);
-    curl_easy_setopt (_curl, CURLOPT_TIMEOUT, timeoutSec);
-    curl_easy_setopt (_curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP);
-    curl_easy_setopt (_curl, CURLOPT_ERRORBUFFER, _errorBuf);
-    if (_sendStr.size() || _sendGStr.size()) {
-      curl_easy_setopt (_curl, CURLOPT_UPLOAD, 1L); // http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTUPLOAD
-      if (_sendStr.size()) {
-        curl_easy_setopt (_curl, CURLOPT_INFILESIZE, (long) _sendStr.size());
-        curl_easy_setopt (_curl, CURLOPT_READFUNCTION, curlReadFromString);
-      } else {
-        curl_easy_setopt (_curl, CURLOPT_INFILESIZE, (long) _sendGStr.size());
-        curl_easy_setopt (_curl, CURLOPT_READFUNCTION, curlReadFromGString);}
-      curl_easy_setopt (_curl, CURLOPT_READDATA, this);}
-    if (_headers)
-      curl_easy_setopt (_curl, CURLOPT_HTTPHEADER, _headers); // http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTHTTPHEADER
-    return *this;
-  }
-
-  /**
-   Set options for smtp request.
-   Example: \code
-     long rc = glim::Curl().send ("Subject: subject\r\n\r\n" "text\r\n") .smtp ("from", "to") .go().status();
-     if (rc != 250) std::cerr << "Error sending email: " << rc << std::endl;
-   \endcode */
-  Curl& smtp (const char* from, const char* to) {
-    curl_easy_setopt (_curl, CURLOPT_NOSIGNAL, 1L); // required per http://curl.haxx.se/libcurl/c/libcurl-tutorial.html#Multi-threading
-    curl_easy_setopt (_curl, CURLOPT_URL, "smtp://127.0.0.1");
-    if (from) curl_easy_setopt (_curl, CURLOPT_MAIL_FROM, from);
-    bcc (to);
-    if (_headers) curl_easy_setopt (_curl, CURLOPT_MAIL_RCPT, _headers);
-    curl_easy_setopt (_curl, CURLOPT_WRITEFUNCTION, curlWriteToString);
-    curl_easy_setopt (_curl, CURLOPT_WRITEDATA, &_got);
-    if (_sendStr.size()) {
-      curl_easy_setopt (_curl, CURLOPT_INFILESIZE, (long) _sendStr.size());
-      curl_easy_setopt (_curl, CURLOPT_READFUNCTION, curlReadFromString);
-      curl_easy_setopt (_curl, CURLOPT_READDATA, this);
-    } else if (_sendGStr.size()) {
-      curl_easy_setopt (_curl, CURLOPT_INFILESIZE, (long) _sendGStr.size());
-      curl_easy_setopt (_curl, CURLOPT_READFUNCTION, curlReadFromGString);
-      curl_easy_setopt (_curl, CURLOPT_READDATA, this);
-    }
-    curl_easy_setopt (_curl, CURLOPT_UPLOAD, 1L);  // cURL now needs this to actually send the email, cf. "http://curl.haxx.se/mail/lib-2013-12/0152.html".
-    return *this;
-  }
-
-  /** Add SMTP recipient to the `_headers` (which are then set into `CURLOPT_MAIL_RCPT` by the `Curl::smtp`).
-   * NB: Should be used *before* the `Curl::smtp`! */
-  Curl& bcc (const char* to) {
-    if (to) _headers = curl_slist_append (_headers, to);
-    return *this;
-  }
-
-  /**
-   Uses `CURLOPT_CUSTOMREQUEST` to set the http method.
-   Can be used both before and after the `http` method.\n
-   Example sending a POST request to ElasticSearch: \code
-     glim::Curl curl;
-     curl.send (C2GSTRING (R"({"query":{"match_all":{}},"facets":{"tags":{"terms":{"field":"tags","size":1000}}}})"));
-     curl.method ("POST") .http ("http://127.0.0.1:9200/froples/frople/_search", 120);
-     if (curl.verbose().go().status() != 200) GTHROW ("Error fetching tags: " + std::to_string (curl.status()) + ", " + curl.str());
-     cout << curl.gstr() << endl;
-   \endcode */
-  Curl& method (const char* method) {
-    curl_easy_setopt (_curl, CURLOPT_CUSTOMREQUEST, method);
-    return *this;
-  }
-
-  /** Setup a handler to process the headers cURL gets from the response.
-   * "The header callback will be called once for each header and only complete header lines are passed on to the callback".\n
-   * See http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTHEADERFUNCTION */
-  Curl& headerListener (std::function<void (const char* header, int len)> listener) {
-    curl_easy_setopt (_curl, CURLOPT_HEADERFUNCTION, curlWriteHeader);
-    curl_easy_setopt (_curl, CURLOPT_WRITEHEADER, this);
-    _headerListener = listener;
-    return *this;
-  }
-
-  /** Setup a handler to get the debug messages generated by cURL.
-   * See http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTDEBUGFUNCTION */
-  Curl& debugListener (std::function<void (curl_infotype type, char* bytes, size_t size)> listener) {
-    curl_easy_setopt (_curl, CURLOPT_DEBUGFUNCTION, curlDebugCB);
-    curl_easy_setopt (_curl, CURLOPT_DEBUGDATA, this);
-    _debugListener = listener;
-    return verbose (true);
-  }
-
-  /**
-   Setup a handler to get some of the debug messages generated by cURL.
-   Listener gets a formatted text: outbound data is prepended with "> " and inbound with "< ".\n
-   Usage example: \code
-     auto curlDebug = std::make_shared<std::string>();
-     curl->debugListenerF ([curlDebug](const char* bytes, size_t size) {curlDebug->append (bytes, size);});
-     ...
-     if (curl->status() != 200) std::cerr << "cURL status != 200; debug follows: " << *curlDebug << std::endl;
-   \endcode
-   See http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTDEBUGFUNCTION
-   @param listener The receiver of the debug information.
-   @param data Whether to pass the data (`CURLINFO_DATA_IN`, `CURLINFO_DATA_OUT`) to the `listener`.
-  */
-  Curl& debugListenerF (std::function<void (const char* bytes, size_t size)> listener, bool data = false) {
-    return debugListener ([listener/* = std::move (listener)*/,data] (curl_infotype type, char* bytes, size_t size) {
-      GSTRING_ON_STACK (buf, 256);
-      auto prepend = [&](const char* prefix) {
-        buf << prefix; for (char *p = bytes, *end = bytes + size; p < end; ++p) {buf << *p; if (*p == '\n' && p + 2 < end) buf << prefix;}};
-      if (type == CURLINFO_HEADER_IN || (type == CURLINFO_DATA_IN && data)) prepend ("< ");
-      else if (type == CURLINFO_HEADER_OUT || (type == CURLINFO_DATA_OUT && data)) prepend ("> ");
-      listener (buf.c_str(), buf.size());
-    });
-  }
-
-  /// Whether to print debug information to `CURLOPT_STDERR`.
-  /// Note that when `debugListener` is used, verbose output will go to the listener and not to `CURLOPT_STDERR`.
-  Curl& verbose (bool on = true) {
-    curl_easy_setopt (_curl, CURLOPT_VERBOSE, on ? 1L : 0L);
-    return *this;
-  }
-
-  /// Reset the buffers and perform the cURL request.
-  Curl& go() {
-    _got.clear();
-    *_errorBuf = 0;
-    if (curl_easy_perform (_curl)) throw PerformError (_errorBuf, __FILE__, __LINE__);
-    return *this;
-  }
-
-  /// The contents of the response.
-  const std::string& str() const {return _got;}
-  /// CString of `str`.
-  const char* c_str() const {return _got.c_str();}
-  /// Returns a gstring "view" into `str`.
-  gstring gstr() const {return gstring (0, (void*) _got.data(), false, _got.size());}
-
-  /// The status of the response (For HTTP it's 200 ok, 404 not found, 500 error, etc).
-  long status() const {
-    long status; CURLcode err = curl_easy_getinfo (_curl, CURLINFO_RESPONSE_CODE, &status);
-    if (err) {
-      GSTRING_ON_STACK (message, 128) << "CURL error " << (int) err << ": " << curl_easy_strerror (err);
-      throw GetinfoError (err, message.str(), __FILE__, __LINE__);
-    }
-    return status;}
-};
-
-/** Moves the content to be sent into a `glim::gstring` inside `Curl`.
- * NB: In order to have an effect this method should be used *before* the `http()` and `smtp()` methods. */
-template<> inline Curl& Curl::send<gstring> (gstring&& text) {
-  _sendStr.clear();
-  _sendGStr = std::move (text);
-  _sent = 0;
-  return *this;}
-
-inline size_t curlReadFromString (void *ptr, size_t size, size_t nmemb, void *userdata) {
-  Curl* curl = (Curl*) userdata;
-  size_t len = std::min (curl->_sendStr.size() - curl->_sent, size * nmemb);
-  if (len) memcpy (ptr, curl->_sendStr.data() + curl->_sent, len);
-  curl->_sent += len;
-  return len;}
-
-inline size_t curlReadFromGString (void *ptr, size_t size, size_t nmemb, void *userdata) {
-  Curl* curl = (Curl*) userdata;
-  size_t len = std::min (curl->_sendGStr.size() - curl->_sent, size * nmemb);
-  if (len) memcpy (ptr, curl->_sendGStr.data() + curl->_sent, len);
-  curl->_sent += len;
-  return len;}
-
-// http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTHEADERFUNCTION
-inline size_t curlWriteHeader (void *ptr, size_t size, size_t nmemb, void *curlPtr) {
-  Curl* curl = (Curl*) curlPtr;
-  std::function<void (const char* header, int len)>& listener = curl->_headerListener;
-  int len = size * nmemb;
-  if (listener) listener ((const char*) ptr, len);
-  return (size_t) len;
-}
-
-// http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTDEBUGFUNCTION
-inline int curlDebugCB (CURL*, curl_infotype type, char* bytes, size_t size, void* curlPtr) {
-  Curl* curl = (Curl*) curlPtr;
-  auto& listener = curl->_debugListener;
-  if (listener) listener (type, bytes, size);
-  return 0;
-}
-
-/// Example: std::string w3 = glim::curl2str ("http://www.w3.org/");
-inline std::string curl2str (const char* url, int timeoutSec = 20) {
-  try {
-    return glim::Curl().http (url, timeoutSec) .go().str();
-  } catch (const std::exception&) {}
-  return std::string();
-}
-
-}
-
-#endif