add HttpResponse

src/logic/scripting/lua/libs/libnetwork.cpp

@@ -115,16 +115,24 @@ static int l_request(lua::State* L, network::Network& network) {
     }
 
     int currentRequestId = request_id++;
-    request.onResponse = [currentRequestId](std::vector<char> bytes) {
+    request.onResponse = [currentRequestId](network::HttpResponse response) {
         push_event(NetworkEvent(
             RESPONSE,
-            ResponseEventDto {200, false, currentRequestId, std::move(bytes)}
+            ResponseEventDto {
+                response.status,
+                false,
+                currentRequestId,
+                std::move(response.body)}
         ));
     };
-    request.onReject = [currentRequestId](int code, std::vector<char> bytes) {
+    request.onReject = [currentRequestId](network::HttpResponse response) {
         push_event(NetworkEvent(
             RESPONSE,
-            ResponseEventDto {code, false, currentRequestId, std::move(bytes)}
+            ResponseEventDto {
+                response.status,
+                false,
+                currentRequestId,
+                std::move(response.body)}
         ));
     };
 

src/network/Curl.cpp

@@ -23,11 +23,28 @@ static size_t write_callback(
     return size * nmemb;
 }
 
+static size_t header_callback(
+    char* buffer, size_t size, size_t nitems, void* userdata
+) {
+    auto* headers = static_cast<std::vector<std::string>*>(userdata);
+    size_t len = size * nitems;
+    std::string header(buffer, len);
+
+    while (!header.empty() &&
+           (header.back() == '\r' || header.back() == '\n')) {
+        header.pop_back();
+    }
+
+    headers->push_back(std::move(header));
+    return len;
+}
+
 struct ProcessingRequest {
     CURLM* multiHandle;
     CURL* curl;
     HttpRequest request;
     std::vector<char> buffer;
+    std::vector<std::string> headers;
 
     ProcessingRequest(CURLM* multiHandle) : multiHandle(multiHandle) {
         curl = curl_easy_init();
@@ -81,6 +98,8 @@ public:
         curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, request.followLocation);
         curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
         curl_easy_setopt(curl, CURLOPT_WRITEDATA, &entry->buffer);
+        curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, header_callback);
+        curl_easy_setopt(curl, CURLOPT_HEADERDATA, &entry->headers);
         curl_easy_setopt(curl, CURLOPT_USERAGENT, "curl/7.81.0");
         if (request.timeoutMs > 0) {
             curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, request.timeoutMs);
@@ -102,7 +121,7 @@ public:
             auto message = curl_multi_strerror(res);
             logger.error() << message << " (" << request.url << ")";
             if (request.onReject) {
-                request.onReject(HTTP_BAD_GATEWAY, {});
+                request.onReject({HTTP_BAD_GATEWAY, {}, {}});
             }
         }
         entry->request = std::move(request);
@@ -112,17 +131,20 @@ public:
     void update() override {
         int messagesLeft;
         int running;
-        CURLMsg* msg;
         CURLMcode res = curl_multi_perform(multiHandle, &running);
         if (res != CURLM_OK) {
             auto message = curl_multi_strerror(res);
             logger.error() << message;
             return;
         }
-        if ((msg = curl_multi_info_read(multiHandle, &messagesLeft)) != nullptr) {
+        CURLMsg* msg = curl_multi_info_read(multiHandle, &messagesLeft);
+        if (msg == nullptr) {
+            return;
+        }
         auto curl = msg->easy_handle;
         auto found = std::find_if(
-                requests.begin(), requests.end(),
+            requests.begin(),
+            requests.end(),
             [curl](const std::unique_ptr<ProcessingRequest>& entry) {
                 return entry->curl == curl;
             }
@@ -136,12 +158,13 @@ public:
 
         requests.erase(found);
 
-            if(msg->msg == CURLMSG_DONE) {
+        if (msg->msg == CURLMSG_DONE) {
             curl_multi_remove_handle(multiHandle, curl);
         }
         int response = -1;
         CURLcode result = msg->data.result;
         curl_easy_getinfo(msg->easy_handle, CURLINFO_RESPONSE_CODE, &response);
+        auto headers = std::move(entry->headers);
         if (response == HTTP_OK) {
             long size;
             if (!curl_easy_getinfo(curl, CURLINFO_REQUEST_SIZE, &size)) {
@@ -152,29 +175,34 @@ public:
             }
             totalDownload += entry->buffer.size();
             if (req.onResponse) {
-                    req.onResponse(std::move(entry->buffer));
+                req.onResponse({
+                    response,
+                    std::move(headers),
+                    std::move(entry->buffer),
+                });
             }
         } else if (response == 0) {
             auto message = std::string(curl_easy_strerror(result));
             logger.error() << message << " (" << req.url << ")";
             if (req.onReject) {
                 req.onReject(
-                        response,
+                    {response,
+                     std::move(headers),
                      std::vector<char>(
                          message.data(), message.data() + message.size()
-                        )
+                     )}
                 );
             }
         } else {
-                logger.error()
+            logger.error() << "response code " << response << " (" << req.url
-                    << "response code " << response << " (" << req.url << ")"
+                           << ")"
                            << (entry->buffer.empty()
                                    ? ""
-                            : std::to_string(entry->buffer.size()) + " byte(s)");
+                                   : std::to_string(entry->buffer.size()) +
+                                         " byte(s)");
             totalDownload += entry->buffer.size();
             if (req.onReject) {
-                    req.onReject(response, std::move(entry->buffer));
+                req.onReject({response, {}, std::move(entry->buffer)});
-                }
             }
         }
     }

src/network/commons.hpp

@@ -10,8 +10,10 @@
 #include <mutex>
 
 namespace network {
-    using OnResponse = std::function<void(std::vector<char>)>;
+    struct HttpResponse;
-    using OnReject = std::function<void(int, std::vector<char>)>;
+
+    using OnResponse = std::function<void(HttpResponse)>;
+    using OnReject = std::function<void(HttpResponse)>;
     using ConnectCallback = std::function<void(u64id_t, u64id_t)>;
     using ConnectErrorCallback = std::function<void(u64id_t, std::string)>;
     using ServerDatagramCallback = std::function<void(u64id_t sid, const std::string& addr, int port, const char* buffer, size_t length)>;
@@ -31,6 +33,12 @@ namespace network {
         long timeoutMs = 0;
     };
 
+    struct HttpResponse {
+        int status;
+        std::vector<std::string> headers;
+        std::vector<char> body;
+    };
+
     class Requests {
     public:
         virtual ~Requests() {}

test/network/curltest.cpp

@@ -10,11 +10,12 @@ TEST(curltest, curltest) {
     network::HttpRequest request {};
     request.url = "https://raw.githubusercontent.com/MihailRis/VoxelEngine-Cpp/refs/"
                   "heads/curl/res/content/base/blocks/lamp.json";
-    request.onResponse = [](std::vector<char> data) {
+    request.onResponse = [](network::HttpResponse response) {
-        if (data.empty()) {
+        if (response.body.empty()) {
             return;
         }
-        auto view = std::string_view(data.data(), data.size());
+        auto view =
+            std::string_view(response.body.data(), response.body.size());
         auto value = json::parse(view);
         std::cout << value << std::endl;
     };