1 files changed, 113 insertions, 25 deletions

diff --git a/src/web_service/web_backend.cpp b/src/web_service/web_backend.cpp
index 13e4555ac..b17d82f9c 100644
--- a/src/web_service/web_backend.cpp
+++ b/src/web_service/web_backend.cpp
@@ -2,51 +2,139 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#ifdef _WIN32
+#include <winsock.h>
+#endif
+
+#include <cstdlib>
+#include <thread>
 #include <cpr/cpr.h>
-#include <stdlib.h>
 #include "common/logging/log.h"
 #include "web_service/web_backend.h"
 
 namespace WebService {
 
 static constexpr char API_VERSION[]{"1"};
-static constexpr char ENV_VAR_USERNAME[]{"CITRA_WEB_SERVICES_USERNAME"};
-static constexpr char ENV_VAR_TOKEN[]{"CITRA_WEB_SERVICES_TOKEN"};
 
-static std::string GetEnvironmentVariable(const char* name) {
-    const char* value{getenv(name)};
-    if (value) {
-        return value;
+static std::unique_ptr<cpr::Session> g_session;
+
+void Win32WSAStartup() {
+#ifdef _WIN32
+    // On Windows, CPR/libcurl does not properly initialize Winsock. The below code is used to
+    // initialize Winsock globally, which fixes this problem. Without this, only the first CPR
+    // session will properly be created, and subsequent ones will fail.
+    WSADATA wsa_data;
+    const int wsa_result{WSAStartup(MAKEWORD(2, 2), &wsa_data)};
+    if (wsa_result) {
+        LOG_CRITICAL(WebService, "WSAStartup failed: %d", wsa_result);
     }
-    return {};
+#endif
 }
 
-const std::string& GetUsername() {
-    static const std::string username{GetEnvironmentVariable(ENV_VAR_USERNAME)};
-    return username;
-}
+void PostJson(const std::string& url, const std::string& data, bool allow_anonymous,
+              const std::string& username, const std::string& token) {
+    if (url.empty()) {
+        LOG_ERROR(WebService, "URL is invalid");
+        return;
+    }
+
+    const bool are_credentials_provided{!token.empty() && !username.empty()};
+    if (!allow_anonymous && !are_credentials_provided) {
+        LOG_ERROR(WebService, "Credentials must be provided for authenticated requests");
+        return;
+    }
 
-const std::string& GetToken() {
-    static const std::string token{GetEnvironmentVariable(ENV_VAR_TOKEN)};
-    return token;
+    Win32WSAStartup();
+
+    // Built request header
+    cpr::Header header;
+    if (are_credentials_provided) {
+        // Authenticated request if credentials are provided
+        header = {{"Content-Type", "application/json"},
+                  {"x-username", username.c_str()},
+                  {"x-token", token.c_str()},
+                  {"api-version", API_VERSION}};
+    } else {
+        // Otherwise, anonymous request
+        header = cpr::Header{{"Content-Type", "application/json"}, {"api-version", API_VERSION}};
+    }
+
+    // Post JSON asynchronously
+    static std::future<void> future;
+    future = cpr::PostCallback(
+        [](cpr::Response r) {
+            if (r.error) {
+                LOG_ERROR(WebService, "POST returned cpr error: %u:%s",
+                          static_cast<u32>(r.error.code), r.error.message.c_str());
+                return;
+            }
+            if (r.status_code >= 400) {
+                LOG_ERROR(WebService, "POST returned error status code: %u", r.status_code);
+                return;
+            }
+            if (r.header["content-type"].find("application/json") == std::string::npos) {
+                LOG_ERROR(WebService, "POST returned wrong content: %s",
+                          r.header["content-type"].c_str());
+                return;
+            }
+        },
+        cpr::Url{url}, cpr::Body{data}, header);
 }
 
-void PostJson(const std::string& url, const std::string& data) {
+template <typename T>
+std::future<T> GetJson(std::function<T(const std::string&)> func, const std::string& url,
+                       bool allow_anonymous, const std::string& username,
+                       const std::string& token) {
     if (url.empty()) {
         LOG_ERROR(WebService, "URL is invalid");
-        return;
+        return std::async(std::launch::async, [func{std::move(func)}]() { return func(""); });
     }
 
-    if (GetUsername().empty() || GetToken().empty()) {
-        LOG_ERROR(WebService, "Environment variables %s and %s must be set to POST JSON",
-                  ENV_VAR_USERNAME, ENV_VAR_TOKEN);
-        return;
+    const bool are_credentials_provided{!token.empty() && !username.empty()};
+    if (!allow_anonymous && !are_credentials_provided) {
+        LOG_ERROR(WebService, "Credentials must be provided for authenticated requests");
+        return std::async(std::launch::async, [func{std::move(func)}]() { return func(""); });
     }
 
-    cpr::PostAsync(cpr::Url{url}, cpr::Body{data}, cpr::Header{{"Content-Type", "application/json"},
-                                                               {"x-username", GetUsername()},
-                                                               {"x-token", GetToken()},
-                                                               {"api-version", API_VERSION}});
+    Win32WSAStartup();
+
+    // Built request header
+    cpr::Header header;
+    if (are_credentials_provided) {
+        // Authenticated request if credentials are provided
+        header = {{"Content-Type", "application/json"},
+                  {"x-username", username.c_str()},
+                  {"x-token", token.c_str()},
+                  {"api-version", API_VERSION}};
+    } else {
+        // Otherwise, anonymous request
+        header = cpr::Header{{"Content-Type", "application/json"}, {"api-version", API_VERSION}};
+    }
+
+    // Get JSON asynchronously
+    return cpr::GetCallback(
+        [func{std::move(func)}](cpr::Response r) {
+            if (r.error) {
+                LOG_ERROR(WebService, "GET returned cpr error: %u:%s",
+                          static_cast<u32>(r.error.code), r.error.message.c_str());
+                return func("");
+            }
+            if (r.status_code >= 400) {
+                LOG_ERROR(WebService, "GET returned error code: %u", r.status_code);
+                return func("");
+            }
+            if (r.header["content-type"].find("application/json") == std::string::npos) {
+                LOG_ERROR(WebService, "GET returned wrong content: %s",
+                          r.header["content-type"].c_str());
+                return func("");
+            }
+            return func(r.text);
+        },
+        cpr::Url{url}, header);
 }
 
+template std::future<bool> GetJson(std::function<bool(const std::string&)> func,
+                                   const std::string& url, bool allow_anonymous,
+                                   const std::string& username, const std::string& token);
+
 } // namespace WebService