HttpRequestHandler.hpp

Go to the documentation of this file.

#pragma once
#ifndef _KURLYK_HTTP_REQUEST_HANDLER_HPP_INCLUDED
#define _KURLYK_HTTP_REQUEST_HANDLER_HPP_INCLUDED

 
namespace kurlyk {

    class HttpRequestHandler {
    public:

        explicit HttpRequestHandler(std::unique_ptr<HttpRequestContext> context)
            : m_request_context(std::move(context)) {
            std::fill(m_error_buffer, m_error_buffer + CURL_ERROR_SIZE, '\0');
#           if __cplusplus >= 201402L
            m_response = std::make_unique<HttpResponse>();
#           else
            m_response = std::unique_ptr<HttpResponse>(new HttpResponse());
#           endif
            init_curl();
        }

        ~HttpRequestHandler() {
            if (m_curl) {
                curl_easy_cleanup(m_curl);
                curl_slist_free_all(m_headers);
            }
            if (!m_callback_called && m_response && m_request_context) {
                m_response->error_code = utils::make_error_code(utils::ClientError::AbortedDuringDestruction);
                m_response->status_code = 499; // Client closed request
                m_response->ready = true;
                m_request_context->callback(std::move(m_response));
            }
        }

        static size_t write_http_response_body(char* data, size_t size, size_t nmemb, void* userdata) {
            size_t total_size = size * nmemb;
            auto* handler = static_cast<HttpRequestHandler*>(userdata);
            if (handler) return handler->write_response_body(data, total_size);
            return total_size;
        }

        static size_t parse_http_response_header(char* buffer, size_t size, size_t nitems, void* userdata) {
            size_t buffer_size = size * nitems;
            auto* headers = static_cast<Headers*>(userdata);
            std::string key, value;
            utils::parse_http_header_pair(buffer, buffer_size, key, value);
            if (!key.empty()) {
                headers->emplace(key, value);
            }
            return buffer_size;
        }

        bool handle_curl_message(CURLMsg* message) {
            if (!m_response) return true;
 
            m_response->error_message = std::string(m_error_buffer, std::strlen(m_error_buffer));
            // m_response->error_code = utils::make_error_code(message->data.result);
            curl_easy_getinfo(m_curl, CURLINFO_RESPONSE_CODE, &m_response->status_code);
 
            // If a timeout occurred, override the HTTP response code.
            if (message->data.result == CURLE_OPERATION_TIMEDOUT) {
                m_response->status_code = 499; // Client Closed Request
            }
 
            if (m_response->status_code == 0 &&
                message->data.result != CURLE_OK) {
                m_response->status_code = 451; // Unavailable For Legal Reasons
            }
 
            if (message->data.result != CURLE_OK) {
                m_response->error_code = utils::make_error_code(message->data.result);
            } else 
            if (m_response->status_code >= 400) {
                m_response->error_code = utils::make_http_error(m_response->status_code);
            } else {
                m_response->error_code = {};
            }
 
            const auto& valid_statuses = m_request_context->request->valid_statuses;
            long retry_attempts = m_request_context->request->retry_attempts;
            long& retry_attempt = m_request_context->retry_attempt;
            ++retry_attempt;
 
            m_response->retry_attempt = retry_attempt;
            const bool has_curl_error = message->data.result != CURLE_OK;
            const bool has_valid_status = valid_statuses.count(m_response->status_code) > 0;
            const bool should_retry =
                retry_attempts &&
                (has_curl_error || !has_valid_status) &&
                retry_attempt < retry_attempts &&
                !m_has_stream_chunk;
 
            if (!should_retry) {
                fill_response_timings();
                m_response->ready = true;
                m_request_context->callback(std::move(m_response));
                m_callback_called = true;
                return true;
            }
            m_request_context->start_time = std::chrono::steady_clock::now();
            m_request_context->callback(std::move(m_response));
            m_callback_called = true;
            return false;
        }

        CURL* get_curl() noexcept { return m_curl; }

        std::unique_ptr<HttpRequestContext> get_request_context() { return std::move(m_request_context); }

        uint64_t get_request_id() { return m_request_context ? m_request_context->request->request_id : 0; }

        void cancel() {
            if (!m_callback_called) {
                m_response->error_code = utils::make_error_code(utils::ClientError::CancelledByUser);
                m_response->status_code = 499; // Client closed request
                m_response->ready = true;
                if (m_request_context) {
                    m_request_context->callback(std::move(m_response));
                }
                m_callback_called = true;
            }
        }
 
    private:
        std::unique_ptr<HttpRequestContext> m_request_context;  
        std::unique_ptr<HttpResponse>       m_response;         
        CURL*                               m_curl = nullptr;   
        struct curl_slist*                  m_headers = nullptr; 
        char                                m_error_buffer[CURL_ERROR_SIZE]; 
        bool                                m_callback_called = false; 
        bool                                m_has_stream_chunk = false; 
        mutable std::string                 m_ca_file; 

        void init_curl() {
            if (!m_request_context) return;
            const auto& request = m_request_context->request;
            m_curl = curl_easy_init();
            if (!m_curl) return;
 
            curl_easy_setopt(m_curl, CURLOPT_URL, request->url.c_str());
            curl_easy_setopt(m_curl, CURLOPT_NOSIGNAL, 1L); // Disable signals for thread safety.
            curl_easy_setopt(m_curl, CURLOPT_CUSTOMREQUEST, request->method.c_str());
            if (request->head_only) {
                curl_easy_setopt(m_curl, CURLOPT_NOBODY, 1L);
            }
            curl_easy_setopt(m_curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
 
            set_ssl_options(*request);
            set_request_options(*request);
 
            curl_easy_setopt(m_curl, CURLOPT_ERRORBUFFER, m_error_buffer);
            curl_easy_setopt(m_curl, CURLOPT_WRITEFUNCTION, write_http_response_body);
            curl_easy_setopt(m_curl, CURLOPT_WRITEDATA, this);
            curl_easy_setopt(m_curl, CURLOPT_HEADERDATA, &m_response->headers);
            curl_easy_setopt(m_curl, CURLOPT_HEADERFUNCTION, parse_http_response_header);
            curl_easy_setopt(m_curl, CURLOPT_PRIVATE, this);
        }

        size_t write_response_body(const char* data, size_t total_size) {
            if (m_response) {
                m_response->content.append(data, total_size);
            }
            emit_stream_chunk(data, total_size);
            return total_size;
        }

        void emit_stream_chunk(const char* data, size_t total_size) {
            if (!data || total_size == 0 || !m_request_context ||
                !m_request_context->request ||
                !m_request_context->request->streaming ||
                !m_request_context->callback) {
                return;
            }
 
#           if __cplusplus >= 201402L
            auto chunk = std::make_unique<HttpResponse>();
#           else
            auto chunk = std::unique_ptr<HttpResponse>(new HttpResponse());
#           endif
 
            if (m_response) {
                chunk->headers = m_response->headers;
            }
            chunk->content.assign(data, total_size);
            chunk->retry_attempt = m_request_context->retry_attempt + 1;
            chunk->ready = false;
            chunk->stream_chunk = true;
            if (m_curl) {
                curl_easy_getinfo(m_curl, CURLINFO_RESPONSE_CODE, &chunk->status_code);
            }
 
            m_has_stream_chunk = true;
 
            try {
                m_request_context->callback(std::move(chunk));
            } catch (const std::exception& e) {
                KURLYK_HANDLE_ERROR(e, "Unhandled exception in HttpRequestHandler streaming callback");
            } catch (...) {
                // Unknown fatal error in streaming callback
            }
        }
        
        void fill_response_timings() {
            curl_easy_getinfo(m_curl, CURLINFO_NAMELOOKUP_TIME,    &m_response->namelookup_time);
            curl_easy_getinfo(m_curl, CURLINFO_CONNECT_TIME,       &m_response->connect_time);
            curl_easy_getinfo(m_curl, CURLINFO_APPCONNECT_TIME,    &m_response->appconnect_time);
            curl_easy_getinfo(m_curl, CURLINFO_PRETRANSFER_TIME,   &m_response->pretransfer_time);
            curl_easy_getinfo(m_curl, CURLINFO_STARTTRANSFER_TIME, &m_response->starttransfer_time);
            curl_easy_getinfo(m_curl, CURLINFO_TOTAL_TIME,         &m_response->total_time);
        }

        void set_ssl_options(const HttpRequest& request) {
            if (!request.cert_file.empty()) {
                curl_easy_setopt(m_curl, CURLOPT_SSLCERT, request.cert_file.c_str());
            }
            if (!request.key_file.empty()) {
                curl_easy_setopt(m_curl, CURLOPT_SSLKEY, request.key_file.c_str());
            }
            if (!request.ca_file.empty()) {
                curl_easy_setopt(m_curl, CURLOPT_CAINFO, request.ca_file.c_str());
            } else {
                curl_easy_setopt(m_curl, CURLOPT_CAINFO, get_ca_file_path());
            }
            if (!request.ca_path.empty()) {
                curl_easy_setopt(m_curl, CURLOPT_CAPATH, request.ca_path.c_str());
            }
            curl_easy_setopt(m_curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_MAX_DEFAULT);
        }

        void set_request_options(const HttpRequest& request) {
            curl_easy_setopt(m_curl, CURLOPT_FOLLOWLOCATION, request.follow_location);
            curl_easy_setopt(m_curl, CURLOPT_MAXREDIRS, request.max_redirects);
            curl_easy_setopt(m_curl, CURLOPT_AUTOREFERER, request.auto_referer);
            curl_easy_setopt(m_curl, CURLOPT_TIMEOUT, request.timeout);
            curl_easy_setopt(m_curl, CURLOPT_CONNECTTIMEOUT, request.connect_timeout);
 
            set_custom_headers(request);
            set_proxy_options(request);
            set_cookie_options(request);
            set_request_body(request);
            if (request.use_interface && request.proxy_server.empty()) {
                curl_easy_setopt(m_curl, CURLOPT_INTERFACE, request.interface_name.c_str());
            }
            curl_easy_setopt(m_curl, CURLOPT_VERBOSE, request.verbose);
            curl_easy_setopt(m_curl, CURLOPT_HEADER, request.debug_header);
        }

        void set_custom_headers(const HttpRequest& request) {
            if (!request.user_agent.empty() && request.headers.count("User-Agent") == 0) {
                curl_easy_setopt(m_curl, CURLOPT_USERAGENT, request.user_agent.c_str());
            }
            if (!request.accept_encoding.empty() && request.headers.count("Accept-Encoding") == 0) {
                curl_easy_setopt(m_curl, CURLOPT_ACCEPT_ENCODING, request.accept_encoding.c_str());
            }
 
            for (const auto& header : request.headers) {
                std::string header_line = header.first + ": " + header.second;
                m_headers = curl_slist_append(m_headers, header_line.c_str());
                if (!m_headers) {
                    curl_slist_free_all(m_headers);
                    break;
                }
            }
            if (m_headers) {
                curl_easy_setopt(m_curl, CURLOPT_HTTPHEADER, m_headers);
            }
        }

        void set_proxy_options(const HttpRequest& request) {
            if (!request.proxy_server.empty()) {
                curl_easy_setopt(m_curl, CURLOPT_PROXY, request.proxy_server.c_str());
                curl_easy_setopt(m_curl, CURLOPT_PROXYTYPE, to_curl_proxy_type(request.proxy_type));
                curl_easy_setopt(m_curl, CURLOPT_HTTPPROXYTUNNEL, request.proxy_tunnel);
                if (!request.proxy_auth.empty()) {
                    curl_easy_setopt(m_curl, CURLOPT_PROXYUSERPWD, request.proxy_auth.c_str());
                    curl_easy_setopt(m_curl, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
                }
            }
        }

        void set_cookie_options(const HttpRequest& request) {
            if (!request.cookie.empty() && request.headers.count("Cookie") == 0) {
                curl_easy_setopt(m_curl, CURLOPT_COOKIE, request.cookie.c_str());
            } else if (!request.cookie_file.empty()) {
                curl_easy_setopt(m_curl, CURLOPT_COOKIEFILE, request.cookie_file.c_str());
                curl_easy_setopt(m_curl, CURLOPT_COOKIEJAR, request.cookie_file.c_str());
                if (request.clear_cookie_file) {
                    curl_easy_setopt(m_curl, CURLOPT_COOKIELIST, "ALL");
                }
            }
        }

        void set_request_body(const HttpRequest& request) {
            if (request.head_only) return;
            if (utils::case_insensitive_equal(request.method, "POST") ||
                utils::case_insensitive_equal(request.method, "PUT") ||
                utils::case_insensitive_equal(request.method, "PATCH") ||
                utils::case_insensitive_equal(request.method, "DELETE")) {
                curl_easy_setopt(m_curl, CURLOPT_POSTFIELDS, request.content.c_str());
                curl_easy_setopt(m_curl, CURLOPT_POSTFIELDSIZE, static_cast<long>(request.content.size()));
            }
        }

        const char* get_ca_file_path() const {
#           if defined(_WIN32)
            m_ca_file = utils::get_exec_dir() + "\\curl-ca-bundle.crt";
            m_ca_file = utils::utf8_to_ansi(m_ca_file);
#           else
            m_ca_file = utils::get_exec_dir() + "/curl-ca-bundle.crt";
#           endif
            return m_ca_file.c_str();
        }
    }; // HttpRequestHandler
 
} // namespace kurlyk
 
#endif // _KURLYK_HTTP_REQUEST_HANDLER_HPP_INCLUDED