mijin2/source/mijin/net/http.cpp

#include "./http.hpp"

#include "../util/iterators.hpp"
#include "../util/string.hpp"

#define MIJIN_HTTP_WRITE(text)                                                                      \
do                                                                                                  \
{                                                                                                   \
    if (const StreamError error = co_await base_->c_writeText(text); error != StreamError::SUCCESS) \
    {                                                                                               \
        co_return error;                                                                            \
    }                                                                                               \
} while(false)

#define MIJIN_HTTP_CHECKREAD(read)                                                                 \
do                                                                                                 \
{                                                                                                  \
    if (const StreamError error = co_await read; error != StreamError::SUCCESS) \
    {                                                                                              \
        co_return error;                                                                           \
    }                                                                                              \
} while(false)

#define MIJIN_HTTP_READLINE(text) MIJIN_HTTP_CHECKREAD(base_->c_readLine(text)); text = trim(text)

namespace mijin
{
namespace
{
inline constexpr std::size_t CONTENT_LENGTH_LIMIT = 100 << 20; // 100MiB
bool parseHTTPVersion(std::string_view version, HTTPVersion& outVersion) noexcept
{
    std::vector<std::string_view> parts = split(version, ".");
    if (parts.size() != 2)
    {
        return false;
    }
    return toNumber(parts[0], outVersion.major) && toNumber(parts[1], outVersion.minor);
}
}

Task<StreamResult<HTTPResponse>> HTTPStream::c_request(HTTPRequest request) noexcept
{
    if (const StreamError error = co_await c_writeRequest(request); error != StreamError::SUCCESS)
    {
        co_return error;
    }
    co_return co_await c_readResponse();
}

Task<StreamError> HTTPStream::c_writeRequest(const mijin::HTTPRequest& request) noexcept
{
    std::map<std::string, std::string> moreHeaders;
    if (!request.body.empty())
    {
        auto itLength = request.headers.find("content-length");
        if (itLength == request.headers.end())
        {
            moreHeaders.emplace("content-length", std::to_string(request.body.size()));
        }
        else
        {
            std::size_t headerValue = 0;
            if (!toNumber(itLength->second, headerValue) || headerValue != request.body.size())
            {
                co_return StreamError::PROTOCOL_ERROR;
            }
        }
    }

    MIJIN_HTTP_WRITE(request.method);
    MIJIN_HTTP_WRITE(" ");
    MIJIN_HTTP_WRITE(request.address);
    MIJIN_HTTP_WRITE(" HTTP/1.0\n");
    for (const auto& [key, value] : moreHeaders)
    {
        MIJIN_HTTP_WRITE(key);
        MIJIN_HTTP_WRITE(": ");
        MIJIN_HTTP_WRITE(value);
        MIJIN_HTTP_WRITE("\n");
    }
    for (const auto& [key, value] : request.headers)
    {
        MIJIN_HTTP_WRITE(key);
        MIJIN_HTTP_WRITE(": ");
        MIJIN_HTTP_WRITE(value);
        MIJIN_HTTP_WRITE("\n");
    }

    MIJIN_HTTP_WRITE("\n");
    if (!request.body.empty())
    {
        MIJIN_HTTP_WRITE(request.body);
    }

    co_return StreamError::SUCCESS;
}

Task<StreamResult<HTTPResponse>> HTTPStream::c_readResponse() noexcept
{
    std::string line;
    MIJIN_HTTP_READLINE(line);

    std::vector<std::string_view> parts = split(line, " ", {.limitParts = 3});
    if (parts.size() != 3)
    {
        co_return StreamError::PROTOCOL_ERROR;
    }
    if (!parts[0].starts_with("HTTP/"))
    {
        co_return StreamError::PROTOCOL_ERROR;
    }

    HTTPResponse response;
    if (!parseHTTPVersion(parts[0].substr(5), response.version)
        || !toNumber(parts[1], response.status))
    {
        co_return StreamError::PROTOCOL_ERROR;
    }
    response.statusMessage = parts[2];

    decltype(response.headers)::iterator lastHeader;
    while (true)
    {
        MIJIN_HTTP_READLINE(line);
        if (line.empty()) {
            break;
        }
        if (line[0] == ' ' || line[0] == '\t')
        {
            // continuation
            if (lastHeader == response.headers.end())
            {
                co_return StreamError::PROTOCOL_ERROR;
            }
            lastHeader->second.push_back(' ');
            lastHeader->second.append(trim(line));
        }
        parts = split(line, ":", {.limitParts = 2});
        if (parts.size() != 2)
        {
            co_return StreamError::PROTOCOL_ERROR;
        }
        lastHeader = response.headers.emplace(toLower(trim(parts[0])), trim(parts[1]));
    }

    auto itContentLength = response.headers.find("content-length");
    if (itContentLength != response.headers.end())
    {
        std::size_t contentLength = 0;
        if (!toNumber(itContentLength->second, contentLength))
        {
            co_return StreamError::PROTOCOL_ERROR;
        }
        if (contentLength > CONTENT_LENGTH_LIMIT)
        {
            co_return StreamError::PROTOCOL_ERROR;
        }
        response.content.resize(contentLength);
        MIJIN_HTTP_CHECKREAD(base_->c_readRaw(response.content));
    }

    co_return response;
}
}

#undef MIJIN_HTTP_WRITE
#undef MIJIN_HTTP_READLINE