Added some basic HTTP and ip address parsing.

source/mijin/net/http.cpp

@@ -0,0 +1,169 @@
+
+#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