http_types.cpp

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#include "internal/http/http_types.h"
#include <algorithm>
#include <cctype>
 
namespace kcenon::network::internal
{
    namespace
    {
        // Convert string to lowercase for case-insensitive comparison
        auto to_lower(std::string str) -> std::string
        {
            std::transform(str.begin(), str.end(), str.begin(),
                [](unsigned char c) { return std::tolower(c); });
            return str;
        }
    }
 
    // http_request methods
 
    auto http_request::get_header(const std::string& name) const -> std::optional<std::string>
    {
        auto lower_name = to_lower(name);
        for (const auto& [key, value] : headers)
        {
            if (to_lower(key) == lower_name)
            {
                return value;
            }
        }
        return std::nullopt;
    }
 
    auto http_request::set_header(const std::string& name, const std::string& value) -> void
    {
        // Remove existing header with same name (case-insensitive)
        auto lower_name = to_lower(name);
        for (auto it = headers.begin(); it != headers.end();)
        {
            if (to_lower(it->first) == lower_name)
            {
                it = headers.erase(it);
            }
            else
            {
                ++it;
            }
        }
 
        // Add new header
        headers[name] = value;
    }
 
    auto http_request::get_body_string() const -> std::string
    {
        return std::string(body.begin(), body.end());
    }
 
    auto http_request::set_body_string(const std::string& content) -> void
    {
        body.assign(content.begin(), content.end());
    }
 
    // http_response methods
 
    auto http_response::get_header(const std::string& name) const -> std::optional<std::string>
    {
        auto lower_name = to_lower(name);
        for (const auto& [key, value] : headers)
        {
            if (to_lower(key) == lower_name)
            {
                return value;
            }
        }
        return std::nullopt;
    }
 
    auto http_response::set_header(const std::string& name, const std::string& value) -> void
    {
        // Remove existing header with same name (case-insensitive)
        auto lower_name = to_lower(name);
        for (auto it = headers.begin(); it != headers.end();)
        {
            if (to_lower(it->first) == lower_name)
            {
                it = headers.erase(it);
            }
            else
            {
                ++it;
            }
        }
 
        // Add new header
        headers[name] = value;
    }
 
    auto http_response::get_body_string() const -> std::string
    {
        return std::string(body.begin(), body.end());
    }
 
    auto http_response::set_body_string(const std::string& content) -> void
    {
        body.assign(content.begin(), content.end());
    }
 
    // Helper functions
 
    auto http_method_to_string(http_method method) -> std::string
    {
        switch (method)
        {
            case http_method::HTTP_GET:     return "GET";
            case http_method::HTTP_POST:    return "POST";
            case http_method::HTTP_PUT:     return "PUT";
            case http_method::HTTP_DELETE:  return "DELETE";
            case http_method::HTTP_HEAD:    return "HEAD";
            case http_method::HTTP_OPTIONS: return "OPTIONS";
            case http_method::HTTP_PATCH:   return "PATCH";
            case http_method::HTTP_CONNECT: return "CONNECT";
            case http_method::HTTP_TRACE:   return "TRACE";
            default:                        return "GET";
        }
    }
 
    auto string_to_http_method(const std::string& method_str) -> ::kcenon::network::internal::Result<http_method>
    {
        auto upper_method = method_str;
        std::transform(upper_method.begin(), upper_method.end(), upper_method.begin(),
            [](unsigned char c) { return std::toupper(c); });
 
        if (upper_method == "GET")     return ::kcenon::network::ok(http_method::HTTP_GET);
        if (upper_method == "POST")    return ::kcenon::network::ok(http_method::HTTP_POST);
        if (upper_method == "PUT")     return ::kcenon::network::ok(http_method::HTTP_PUT);
        if (upper_method == "DELETE")  return ::kcenon::network::ok(http_method::HTTP_DELETE);
        if (upper_method == "HEAD")    return ::kcenon::network::ok(http_method::HTTP_HEAD);
        if (upper_method == "OPTIONS") return ::kcenon::network::ok(http_method::HTTP_OPTIONS);
        if (upper_method == "PATCH")   return ::kcenon::network::ok(http_method::HTTP_PATCH);
        if (upper_method == "CONNECT") return ::kcenon::network::ok(http_method::HTTP_CONNECT);
        if (upper_method == "TRACE")   return ::kcenon::network::ok(http_method::HTTP_TRACE);
 
        return ::kcenon::network::error<http_method>(
            ::kcenon::network::error_codes::common_errors::invalid_argument,
            "Unknown HTTP method: " + method_str,
            "http_types");
    }
 
    auto http_version_to_string(http_version version) -> std::string
    {
        switch (version)
        {
            case http_version::HTTP_1_0: return "HTTP/1.0";
            case http_version::HTTP_1_1: return "HTTP/1.1";
            case http_version::HTTP_2_0: return "HTTP/2.0";
            default:                     return "HTTP/1.1";
        }
    }
 
    auto string_to_http_version(const std::string& version_str) -> ::kcenon::network::internal::Result<http_version>
    {
        if (version_str == "HTTP/1.0") return ::kcenon::network::ok(http_version::HTTP_1_0);
        if (version_str == "HTTP/1.1") return ::kcenon::network::ok(http_version::HTTP_1_1);
        if (version_str == "HTTP/2.0") return ::kcenon::network::ok(http_version::HTTP_2_0);
        if (version_str == "HTTP/2")   return ::kcenon::network::ok(http_version::HTTP_2_0);
 
        return ::kcenon::network::error<http_version>(
            ::kcenon::network::error_codes::common_errors::invalid_argument,
            "Unknown HTTP version: " + version_str,
            "http_types");
    }
 
    auto get_status_message(int status_code) -> std::string
    {
        switch (status_code)
        {
            // 1xx Informational
            case 100: return "Continue";
            case 101: return "Switching Protocols";
 
            // 2xx Success
            case 200: return "OK";
            case 201: return "Created";
            case 202: return "Accepted";
            case 203: return "Non-Authoritative Information";
            case 204: return "No Content";
            case 205: return "Reset Content";
            case 206: return "Partial Content";
 
            // 3xx Redirection
            case 300: return "Multiple Choices";
            case 301: return "Moved Permanently";
            case 302: return "Found";
            case 303: return "See Other";
            case 304: return "Not Modified";
            case 307: return "Temporary Redirect";
            case 308: return "Permanent Redirect";
 
            // 4xx Client Error
            case 400: return "Bad Request";
            case 401: return "Unauthorized";
            case 402: return "Payment Required";
            case 403: return "Forbidden";
            case 404: return "Not Found";
            case 405: return "Method Not Allowed";
            case 406: return "Not Acceptable";
            case 407: return "Proxy Authentication Required";
            case 408: return "Request Timeout";
            case 409: return "Conflict";
            case 410: return "Gone";
            case 411: return "Length Required";
            case 412: return "Precondition Failed";
            case 413: return "Payload Too Large";
            case 414: return "URI Too Long";
            case 415: return "Unsupported Media Type";
            case 416: return "Range Not Satisfiable";
            case 417: return "Expectation Failed";
            case 429: return "Too Many Requests";
 
            // 5xx Server Error
            case 500: return "Internal Server Error";
            case 501: return "Not Implemented";
            case 502: return "Bad Gateway";
            case 503: return "Service Unavailable";
            case 504: return "Gateway Timeout";
            case 505: return "HTTP Version Not Supported";
 
            default:  return "Unknown";
        }
    }
 
    // cookie methods
    auto cookie::to_header_value() const -> std::string
    {
        std::string result = name + "=" + value;
 
        if (!path.empty()) {
            result += "; Path=" + path;
        }
        if (!domain.empty()) {
            result += "; Domain=" + domain;
        }
        if (!expires.empty()) {
            result += "; Expires=" + expires;
        }
        if (max_age >= 0) {
            result += "; Max-Age=" + std::to_string(max_age);
        }
        if (http_only) {
            result += "; HttpOnly";
        }
        if (secure) {
            result += "; Secure";
        }
        if (!same_site.empty()) {
            result += "; SameSite=" + same_site;
        }
 
        return result;
    }
 
    // http_response::set_cookie method
    auto http_response::set_cookie(const std::string& name, const std::string& value,
                                   const std::string& path, int max_age,
                                   bool http_only, bool secure,
                                   const std::string& same_site) -> void
    {
        cookie c;
        c.name = name;
        c.value = value;
        c.path = path;
        c.max_age = max_age;
        c.http_only = http_only;
        c.secure = secure;
        c.same_site = same_site;
        set_cookies.push_back(c);
    }
 
} // namespace kcenon::network::internal