http2_request.h

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.
 
#pragma once
 
#include "hpack.h"
 
#include <algorithm>
#include <cctype>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace kcenon::network::protocols::http2
{
    struct http2_request
    {
        std::string method;                      
        std::string path;                        
        std::string authority;                   
        std::string scheme;                      
        std::vector<http_header> headers;        
        std::vector<uint8_t> body;               
 
        [[nodiscard]] auto get_header(std::string_view name) const
            -> std::optional<std::string>
        {
            auto it = std::find_if(headers.begin(), headers.end(),
                [&name](const http_header& h) {
                    if (h.name.size() != name.size()) return false;
                    for (size_t i = 0; i < h.name.size(); ++i) {
                        if (std::tolower(static_cast<unsigned char>(h.name[i])) !=
                            std::tolower(static_cast<unsigned char>(name[i]))) {
                            return false;
                        }
                    }
                    return true;
                });
            if (it != headers.end()) {
                return it->value;
            }
            return std::nullopt;
        }
 
        [[nodiscard]] auto content_type() const -> std::optional<std::string>
        {
            return get_header("content-type");
        }
 
        [[nodiscard]] auto content_length() const -> std::optional<size_t>
        {
            auto value = get_header("content-length");
            if (!value) {
                return std::nullopt;
            }
            try {
                return static_cast<size_t>(std::stoull(*value));
            } catch (...) {
                return std::nullopt;
            }
        }
 
        [[nodiscard]] auto get_body_string() const -> std::string
        {
            return std::string(body.begin(), body.end());
        }
 
        [[nodiscard]] auto is_valid() const -> bool
        {
            if (method.empty()) {
                return false;
            }
            // CONNECT requests have special rules
            if (method == "CONNECT") {
                return !authority.empty();
            }
            // Normal requests require :method, :scheme, and :path
            return !scheme.empty() && !path.empty();
        }
 
        static auto from_headers(const std::vector<http_header>& parsed_headers)
            -> http2_request
        {
            http2_request request;
            for (const auto& header : parsed_headers) {
                if (header.name.empty()) {
                    continue;
                }
                if (header.name[0] == ':') {
                    // Pseudo-header
                    if (header.name == ":method") {
                        request.method = header.value;
                    } else if (header.name == ":path") {
                        request.path = header.value;
                    } else if (header.name == ":scheme") {
                        request.scheme = header.value;
                    } else if (header.name == ":authority") {
                        request.authority = header.value;
                    }
                    // Ignore unknown pseudo-headers
                } else {
                    // Regular header
                    request.headers.push_back(header);
                }
            }
            return request;
        }
    };
 
} // namespace kcenon::network::protocols::http2