facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/ext/facter/leatherman/curl/inc/leatherman/curl/request.hpp

@@ -1,130 +0,0 @@
-/**
-* @file
-* Declares the HTTP request.
-*/
-#pragma once
-
-#include <string>
-#include <map>
-#include <functional>
-#include "export.h"
-
-namespace leatherman { namespace curl {
-
-    /**
-     * Implements the HTTP request.
-     */
-    struct LEATHERMAN_CURL_EXPORT request
-    {
-        /**
-         * Constructs a HTTP request.
-         * @param url The URL for the request.
-         */
-        explicit request(std::string url);
-
-        /**
-         * Gets the URL for the request.
-         * @return Returns the URL for the request.
-         */
-        std::string const& url() const;
-
-        /**
-         * Adds a header to the request.
-         * @param name The header name.
-         * @param value The header value.
-         */
-        void add_header(std::string name, std::string value);
-
-        /**
-         * Enumerates each header in the request.
-         * @param callback The function to call for each header in the request.
-         */
-        void each_header(std::function<bool(std::string const&, std::string const&)> callback) const;
-
-        /**
-         * Gets a header by name.
-         * @param name The header name to get.
-         * @return Returns a pointer to the header's value or nullptr if the header is not present.
-         */
-        std::string* header(std::string const& name);
-
-        /**
-         * Removes a header from the request.
-         * @param name The name of the header to remove.
-         */
-        void remove_header(std::string const& name);
-
-        /**
-         * Adds a cookie to the request.
-         * @param name The cookie name.
-         * @param value The cookie value.
-         */
-        void add_cookie(std::string name, std::string value);
-
-        /**
-         * Enumerates each cookie in the request.
-         * @param callback The function to call for each cookie in the request.
-         */
-        void each_cookie(std::function<bool(std::string const&, std::string const&)> callback) const;
-
-        /**
-         * Gets a cookie by name.
-         * @param name The cookie name to get.
-         * @return Returns a pointer to the cookie's value or nullptr if the cookie is not present.
-         */
-        std::string* cookie(std::string const& name);
-
-        /**
-         * Removes a cookie from the request.
-         * @param name The name of the cookie to remove.
-         */
-        void remove_cookie(std::string const& name);
-
-        /**
-         * Sets the body of the request.
-         * @param body The body of the request.
-         * @param content_type The type of content (sets the Content-Type header).
-         */
-        void body(std::string body, std::string content_type);
-
-        /**
-         * Gets the body of the request.
-         * The type of the content is represented by the Content-Type header.
-         * @return Returns the body of the request.
-         */
-        std::string const& body() const;
-
-        /**
-         * Gets the overall request timeout, in milliseconds.
-         * @return Returns the overall request timeout, in milliseconds.
-         */
-        long timeout() const;
-
-        /**
-         * Sets the overall request timeout, in milliseconds.
-         * @param value The timeout value, in milliseconds.
-         */
-        void timeout(long value);
-
-        /**
-         * Gets the timeout for connecting to the remote host, in milliseconds.
-         * @return Returns the connection timeout, in milliseconds.
-         */
-        long connection_timeout() const;
-
-        /**
-         * Sets the timeout for connecting to the remote host, in milliseconds.
-         * @param value The timeout value, in milliseconds.
-         */
-        void connection_timeout(long value);
-
-     private:
-        std::string _url;
-        std::string _body;
-        long _timeout;
-        long _connection_timeout;
-        std::map<std::string, std::string> _headers;
-        std::map<std::string, std::string> _cookies;
-    };
-
-}}  // namespace leatherman::curl

data/ext/facter/leatherman/curl/inc/leatherman/curl/response.hpp

@@ -1,80 +0,0 @@
-/**
-* @file
-* Declares the HTTP response.
-*/
-#pragma once
-
-#include <string>
-#include <functional>
-#include <map>
-#include "export.h"
-
-namespace leatherman { namespace curl {
-
-    /**
-     * Implements the HTTP response.
-     */
-    struct LEATHERMAN_CURL_EXPORT response
-    {
-        /**
-         * Constructs a HTTP response.
-         */
-        response();
-
-        /**
-         * Adds a header to the response.
-         * @param name The header name.
-         * @param value The header value.
-         */
-        void add_header(std::string name, std::string value);
-
-        /**
-         * Enumerates each header in the response.
-         * @param callback The function to call for each header in the response.
-         */
-        void each_header(std::function<bool(std::string const&, std::string const&)> callback) const;
-
-        /**
-         * Gets a header by name.
-         * @param name The header name to get.
-         * @return Returns a pointer to the header's value or nullptr if the header is not present.
-         */
-        const std::string* header(std::string const& name) const;
-
-        /**
-         * Removes a header from the response.
-         * @param name The name of the header to remove.
-         */
-        void remove_header(std::string const& name);
-
-        /**
-         * Sets the body of the response.
-         * @param body The body of the response.
-         */
-        void body(std::string body);
-
-        /**
-         * Gets the body of the response.
-         * @return Returns the body of the response.
-         */
-        std::string const& body() const;
-
-        /**
-         * Sets the status code of the response.
-         * @param code The status code of the response.
-         */
-        void status_code(int code);
-
-        /**
-         * Gets the status code of the response.
-         * @return Returns the status code of the response.
-         */
-        int status_code() const;
-
-     private:
-        int _status_code;
-        std::string _body;
-        std::map<std::string, std::string> _headers;
-    };
-
-}}  // namespace leatherman::curl

data/ext/facter/leatherman/curl/src/client.cc

@@ -1,590 +0,0 @@
-#include <leatherman/curl/client.hpp>
-#include <leatherman/curl/request.hpp>
-#include <leatherman/curl/response.hpp>
-#include <leatherman/util/regex.hpp>
-#include <leatherman/file_util/file.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <boost/utility/string_ref.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/nowide/iostream.hpp>
-#include <boost/nowide/fstream.hpp>
-#include <sstream>
-
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-
-using namespace std;
-namespace fs = boost::filesystem;
-
-namespace leatherman { namespace curl {
-
-    // Helper for globally initializing curl
-    struct curl_init_helper
-    {
-        curl_init_helper()
-        {
-            _result = curl_global_init(CURL_GLOBAL_DEFAULT);
-        }
-
-        ~curl_init_helper()
-        {
-            if (_result == CURLE_OK) {
-                curl_global_cleanup();
-            }
-        }
-
-        CURLcode result() const
-        {
-            return _result;
-        }
-
-     private:
-        CURLcode _result;
-    };
-
-    curl_handle::curl_handle() :
-        scoped_resource(nullptr, cleanup)
-    {
-        // Perform initialization
-        static curl_init_helper init_helper;
-        if (init_helper.result() != CURLE_OK) {
-            throw http_exception(curl_easy_strerror(init_helper.result()));
-        }
-
-        _resource = curl_easy_init();
-    }
-
-    void curl_handle::cleanup(CURL* curl)
-    {
-        if (curl) {
-            curl_easy_cleanup(curl);
-        }
-    }
-
-    curl_list::curl_list() :
-        scoped_resource(nullptr, cleanup)
-    {
-    }
-
-    void curl_list::append(string const& value)
-    {
-        _resource = curl_slist_append(_resource, value.c_str());
-    }
-
-    void curl_list::cleanup(curl_slist* list)
-    {
-        if (list) {
-            curl_slist_free_all(list);
-        }
-    }
-
-    curl_escaped_string::curl_escaped_string(curl_handle const& handle, string const& str) :
-        scoped_resource(nullptr, cleanup)
-    {
-        _resource = curl_easy_escape(handle, str.c_str(), str.size());
-        if (!_resource) {
-            throw http_exception(_("curl_easy_escape failed to escape string."));
-        }
-    }
-
-    void curl_escaped_string::cleanup(char const* str)
-    {
-        if (str) {
-            curl_free(const_cast<char*>(str));
-        }
-    }
-
-    static std::string make_file_err_msg(std::string const& reason) {
-        return _("File operation error: {1}", reason);
-    }
-
-    download_temp_file::download_temp_file(request const& req, std::string const& file_path, boost::optional<boost::filesystem::perms> perms) :
-      _req(req),
-      _file_path(file_path)
-    {
-        try {
-            _temp_path = fs::path(file_path).parent_path() / fs::unique_path("temp_file_%%%%-%%%%-%%%%-%%%%");
-            _fp = boost::nowide::fopen(_temp_path.string().c_str(), "wb");
-            if (!_fp) {
-                throw http_file_operation_exception(_req, _file_path, make_file_err_msg(_("failed to open temporary file for writing")));
-            }
-            if (!perms) {
-                return;
-            }
-
-            boost::system::error_code ec;
-            fs::permissions(_temp_path.string(), *perms, ec);
-            if (ec) {
-                cleanup();
-                throw http_file_operation_exception(_req, _file_path, make_file_err_msg(_("failed to modify permissions of temporary file")));
-            }
-        } catch (fs::filesystem_error& e) {
-            throw http_file_operation_exception(_req, _file_path, make_file_err_msg(e.what()));
-        }
-    }
-
-    download_temp_file::~download_temp_file() {
-        cleanup();
-    }
-
-    FILE* download_temp_file::get_fp() {
-        return _fp;
-    }
-
-    void download_temp_file::write() {
-        LOG_DEBUG("Download completed, now writing result to file {1}", _file_path);
-        close_fp();
-        boost::system::error_code ec;
-        fs::rename(_temp_path, _file_path, ec);
-        if (ec) {
-            LOG_WARNING("Failed to write the results of the temporary file to the actual file {1}", _file_path);
-            throw http_file_operation_exception(_req, _file_path, make_file_err_msg(_("failed to move over the temporary file's downloaded contents")));
-        }
-    }
-
-    void download_temp_file::write(response& res) {
-        LOG_DEBUG("Writing the temp file's contents to the response body");
-        close_fp();
-        string res_body;
-        if (!leatherman::file_util::read(_temp_path.string(), res_body)) {
-            LOG_WARNING("Failed to write the contents of the temporary file to the response body.");
-            throw http_file_operation_exception(_req, _file_path, make_file_err_msg(_("failed to write the temporary file's contents to the response body")));
-        }
-        res.body(res_body);
-    }
-
-    void download_temp_file::close_fp() {
-      fclose(_fp);
-      _fp = nullptr;
-    }
-
-    void download_temp_file::cleanup() {
-        if (_fp) {
-            fclose(_fp);
-        }
-        boost::system::error_code ec;
-        fs::remove(_temp_path, ec);
-        if (ec) {
-            LOG_WARNING("Failed to properly clean-up the temporary file {1}", _temp_path);
-        }
-    }
-
-    client::client()
-    {
-        if (!_handle) {
-            throw http_exception(_("failed to create cURL handle."));
-        }
-    }
-
-    client::client(client && other)
-    {
-        *this = move(other);
-    }
-
-    client &client::operator=(client && other)
-    {
-        _handle = move(other._handle);
-        return *this;
-    }
-
-    response client::get(request const& req)
-    {
-        return perform(http_method::get, req);
-    }
-
-    response client::post(request const& req)
-    {
-        return perform(http_method::post, req);
-    }
-
-    response client::put(request const& req)
-    {
-        return perform(http_method::put, req);
-    }
-
-    response client::perform(http_method method, request const& req)
-    {
-        response res;
-        context ctx(req, res);
-
-        // Reset the options
-        curl_easy_reset(_handle);
-
-        // Set common options
-        curl_easy_setopt_maybe(ctx, CURLOPT_NOPROGRESS, 1);
-        curl_easy_setopt_maybe(ctx, CURLOPT_FOLLOWLOCATION, 1);
-
-        // Set tracing from libcurl if enabled (we don't care if this fails)
-        if (LOG_IS_DEBUG_ENABLED()) {
-            curl_easy_setopt(_handle, CURLOPT_DEBUGFUNCTION, debug);
-            curl_easy_setopt(_handle, CURLOPT_VERBOSE, 1);
-        }
-
-        // Setup the request
-        set_method(ctx, method);
-        set_url(ctx);
-        set_headers(ctx);
-        set_cookies(ctx);
-        set_body(ctx, method);
-        set_timeouts(ctx);
-        set_write_callbacks(ctx);
-        set_ca_info(ctx);
-        set_client_info(ctx);
-        set_client_protocols(ctx);
-        set_proxy_info(ctx);
-
-        // Perform the request
-        auto result = curl_easy_perform(_handle);
-        if (result != CURLE_OK) {
-            throw http_request_exception(req, curl_easy_strerror(result));
-        }
-
-        LOG_DEBUG("request completed (status {1}).", res.status_code());
-
-        // Set the body of the response
-        res.body(move(ctx.response_buffer));
-        return res;
-    }
-
-    void client::download_file(request const& req, std::string const& file_path, boost::optional<fs::perms> perms)
-    {
-        download_file_helper(req, file_path, {}, perms);
-    }
-
-    void client::download_file(request const& req, std::string const& file_path, response& res, boost::optional<fs::perms> perms)
-    {
-        download_file_helper(req, file_path, res, perms);
-    }
-
-    void client::download_file_helper(request const& req, std::string const& file_path, boost::optional<response&> res, boost::optional<fs::perms> perms)
-    {
-        response _res;
-        context ctx(req, _res);
-
-        // Reset the options
-        curl_easy_reset(_handle);
-
-        char errbuf[CURL_ERROR_SIZE] = { '\0' };
-        download_temp_file temp_file(req, file_path, perms);
-        curl_easy_setopt_maybe(ctx, CURLOPT_NOPROGRESS, 1);
-
-        // Setup the remaining request
-        set_url(ctx);
-        set_headers(ctx);
-        set_timeouts(ctx);
-        set_write_callbacks(ctx, temp_file.get_fp());
-        set_ca_info(ctx);
-        set_client_info(ctx);
-        set_client_protocols(ctx);
-        set_proxy_info(ctx);
-
-        // More detailed error messages
-        curl_easy_setopt_maybe(ctx, CURLOPT_ERRORBUFFER, errbuf);
-
-        // Perform the request
-        auto result = curl_easy_perform(_handle);
-        if (result == CURLE_WRITE_ERROR) {
-            throw http_file_operation_exception(req, file_path, make_file_err_msg(_("failed to write to the temporary file during download")));
-        } else if (result != CURLE_OK) {
-            throw http_file_download_exception(req, file_path, _("File download server side error: {1}", errbuf));
-        }
-
-        // Check the status code. If 400+, fill in the response
-        LOG_DEBUG("request completed (status {1}).", _res.status_code());
-        if (_res.status_code() >= 400 && res) {
-            temp_file.write(_res);
-        } else {
-            temp_file.write();
-        }
-
-        if (res) {
-            (*res) = move(_res);
-        }
-    }
-
-    void client::set_ca_cert(string const& cert_file)
-    {
-        _ca_cert = cert_file;
-    }
-
-    void client::set_proxy(string const& proxy)
-    {
-        _proxy = proxy;
-    }
-
-    void client::set_client_cert(string const& client_cert, string const& client_key)
-    {
-        _client_cert = client_cert;
-        _client_key = client_key;
-    }
-
-    void client::set_supported_protocols(long client_protocols) {
-        _client_protocols = client_protocols;
-    }
-
-    void client::set_method(context& ctx, http_method method)
-    {
-        switch (method) {
-            case http_method::get:
-                // Unnecessary since we're resetting the handle before calling this function
-                return;
-
-            case http_method::post: {
-                curl_easy_setopt_maybe(ctx, CURLOPT_POST, 1);
-                break;
-            }
-
-            case http_method::put: {
-                curl_easy_setopt_maybe(ctx, CURLOPT_UPLOAD, 1);
-                break;
-            }
-
-            default:
-                throw http_request_exception(ctx.req, _("unexpected HTTP method specified."));
-        }
-    }
-
-    void client::set_url(context& ctx)
-    {
-        // TODO: support an easy interface for setting escaped query parameters
-        curl_easy_setopt_maybe(ctx, CURLOPT_URL, ctx.req.url().c_str());
-        LOG_DEBUG("requesting {1}.", ctx.req.url());
-    }
-
-    void client::set_headers(context& ctx)
-    {
-        ctx.req.each_header([&](string const& name, string const& value) {
-            ctx.request_headers.append(name + ": " + value);
-            return true;
-        });
-        curl_easy_setopt_maybe(ctx, CURLOPT_HTTPHEADER, static_cast<curl_slist*>(ctx.request_headers));
-    }
-
-    void client::set_cookies(context& ctx)
-    {
-        ostringstream cookies;
-        ctx.req.each_cookie([&](string const& name, string const& value) {
-            if (cookies.tellp() != 0) {
-                cookies << "; ";
-            }
-            cookies << name << "=" << value;
-            return true;
-        });
-        curl_easy_setopt_maybe(ctx, CURLOPT_COOKIE, cookies.str().c_str());
-    }
-
-    void client::set_body(context& ctx, http_method method)
-    {
-        curl_easy_setopt_maybe(ctx, CURLOPT_READFUNCTION, read_body);
-        curl_easy_setopt_maybe(ctx, CURLOPT_READDATA, &ctx);
-        curl_easy_setopt_maybe(ctx, CURLOPT_SEEKFUNCTION, seek_body);
-        curl_easy_setopt_maybe(ctx, CURLOPT_SEEKDATA, &ctx);
-
-        switch (method) {
-            case http_method::post: {
-                curl_easy_setopt_maybe(ctx, CURLOPT_POSTFIELDSIZE_LARGE, ctx.req.body().size());
-                break;
-            }
-            case http_method::put: {
-                curl_easy_setopt_maybe(ctx, CURLOPT_INFILESIZE_LARGE, ctx.req.body().size());
-                break;
-            }
-            default:
-                break;
-        }
-    }
-
-    void client::set_timeouts(context& ctx)
-    {
-        curl_easy_setopt_maybe(ctx, CURLOPT_CONNECTTIMEOUT_MS, ctx.req.connection_timeout());
-        curl_easy_setopt_maybe(ctx, CURLOPT_TIMEOUT_MS, ctx.req.timeout());
-    }
-
-    void client::set_header_write_callbacks(context& ctx)
-    {
-        curl_easy_setopt_maybe(ctx, CURLOPT_HEADERFUNCTION, write_header);
-        curl_easy_setopt_maybe(ctx, CURLOPT_HEADERDATA, &ctx);
-    }
-
-    void client::set_write_callbacks(context& ctx)
-    {
-        set_header_write_callbacks(ctx);
-        curl_easy_setopt_maybe(ctx, CURLOPT_WRITEFUNCTION, write_body);
-        curl_easy_setopt_maybe(ctx, CURLOPT_WRITEDATA, &ctx);
-    }
-
-    void client::set_write_callbacks(context& ctx, FILE* fp)
-    {
-        set_header_write_callbacks(ctx);
-        curl_easy_setopt_maybe(ctx, CURLOPT_WRITEFUNCTION, write_file);
-        curl_easy_setopt_maybe(ctx, CURLOPT_WRITEDATA, fp);
-    }
-
-    void client::set_ca_info(context& ctx){
-        if (_ca_cert == "") {
-            return;
-        }
-
-        curl_easy_setopt_maybe(ctx, CURLOPT_CAINFO, _ca_cert.c_str());
-    }
-
-    void client::set_client_info(context &ctx) {
-        if (_client_cert == "" || _client_key == "") {
-          return;
-        }
-
-        curl_easy_setopt_maybe(ctx, CURLOPT_SSLCERT, _client_cert.c_str());
-        curl_easy_setopt_maybe(ctx, CURLOPT_SSLKEY, _client_key.c_str());
-    }
-
-    void client::set_proxy_info(context &ctx) {
-        if (_proxy == "") {
-          return;
-        }
-
-        curl_easy_setopt_maybe(ctx, CURLOPT_PROXY, _proxy.c_str());
-    }
-
-    void client::set_client_protocols(context& ctx) {
-        curl_easy_setopt_maybe(ctx, CURLOPT_PROTOCOLS, _client_protocols);
-    }
-
-    size_t client::read_body(char* buffer, size_t size, size_t count, void* ptr)
-    {
-        auto ctx = reinterpret_cast<context*>(ptr);
-        size_t requested = size * count;
-
-        auto const& body = ctx->req.body();
-
-        if (requested > (body.size() - ctx->read_offset)) {
-            requested = (body.size() - ctx->read_offset);
-        }
-        if (requested > 0) {
-            memcpy(buffer, body.c_str() + ctx->read_offset, requested);
-            ctx->read_offset += requested;
-        }
-        return requested;
-    }
-
-    int client::seek_body(void* ptr, curl_off_t offset, int origin)
-    {
-        auto ctx = reinterpret_cast<context*>(ptr);
-
-        // Only setting offset from the beginning is supported and the CURL docs
-        // claim this is the only way this gets called
-        if (origin != SEEK_SET) {
-            return CURL_SEEKFUNC_FAIL;
-        }
-
-        // Since we only support an absolute offset, we should not support
-        // negative offsets to prevent reading data from before the buffer
-        if (offset < 0) {
-            return CURL_SEEKFUNC_FAIL;
-        }
-
-        ctx->read_offset = offset;
-        return CURL_SEEKFUNC_OK;
-    }
-
-    size_t client::write_header(char* buffer, size_t size, size_t count, void* ptr)
-    {
-        size_t written = size * count;
-        boost::string_ref input(buffer, written);
-
-        auto ctx = reinterpret_cast<context*>(ptr);
-
-        // If the header starts with "HTTP/", then we have the response status
-        if (input.starts_with("HTTP/")) {
-            // Reset the response buffer
-            ctx->response_buffer.clear();
-
-            // Parse out the error code
-            static boost::regex regex("HTTP/\\d\\.\\d (\\d\\d\\d).*");
-            int status_code = 0;
-            if (util::re_search(input.to_string(), regex, &status_code)) {
-                ctx->res.status_code(status_code);
-            }
-            return written;
-        } else if (input == "\r\n") {
-            // Ignore the response delimiter
-            return written;
-        }
-
-        auto pos = input.find_first_of(':');
-        if (pos == boost::string_ref::npos) {
-            LOG_WARNING("unexpected HTTP response header: {1}.", input);
-            return written;
-        }
-
-        auto name = input.substr(0, pos).to_string();
-        auto value = input.substr(pos + 1).to_string();
-        boost::trim(name);
-        boost::trim(value);
-
-        // If this is the "Content-Length" header, reserve the response buffer as an optimization
-        if (name == "Content-Length") {
-            try {
-                ctx->response_buffer.reserve(stoi(value));
-            } catch (logic_error&) {
-            }
-        }
-
-        ctx->res.add_header(move(name), move(value));
-        return written;
-    }
-
-    size_t client::write_body(char* buffer, size_t size, size_t count, void* ptr)
-    {
-        size_t written = size * count;
-
-        auto ctx = reinterpret_cast<context*>(ptr);
-        if (written > 0) {
-            ctx->response_buffer.append(buffer, written);
-        }
-
-        return written;
-    }
-
-    size_t client::write_file(char *buffer, size_t size, size_t count, void* ptr)
-    {
-        return fwrite(buffer, size, count, reinterpret_cast<FILE*>(ptr));
-    }
-
-    int client::debug(CURL* handle, curl_infotype type, char* data, size_t size, void* ptr)
-    {
-        if (type > CURLINFO_DATA_OUT) {
-            return 0;
-        }
-        string str(data, size);
-        boost::trim(str);
-        if (str.empty()) {
-            return 0;
-        }
-
-        // Only log cURL's text to debug
-        if (type == CURLINFO_TEXT) {
-            LOG_DEBUG(str);
-            return 0;
-        } else if (!LOG_IS_TRACE_ENABLED()) {
-            return 0;
-        }
-
-        ostringstream header;
-        if (type == CURLINFO_HEADER_IN) {
-            header << "[response headers: " << size << " bytes]\n";
-        } else if (type == CURLINFO_HEADER_OUT) {
-            header << "[request headers: " << size << " bytes]\n";
-        } else if (type == CURLINFO_DATA_IN) {
-            header << "[response body: " << size << " bytes]\n";
-        } else if (type == CURLINFO_DATA_OUT) {
-            header << "[request body: " << size << " bytes]\n";
-        }
-        LOG_TRACE("{1}{2}", header.str(), str);
-        return 0;
-    }
-
-    curl_handle const& client::get_handle()
-    {
-        return _handle;
-    }
-}}  // leatherman::curl