7 files changed, 463 insertions, 0 deletions

diff --git a/src/web_service/CMakeLists.txt b/src/web_service/CMakeLists.txt
new file mode 100644
index 000000000..1c83e9c34
--- /dev/null
+++ b/src/web_service/CMakeLists.txt
@@ -0,0 +1,16 @@
+add_library(web_service STATIC
+    telemetry_json.cpp
+    telemetry_json.h
+    verify_login.cpp
+    verify_login.h
+    web_backend.cpp
+    web_backend.h
+)
+
+create_target_directory_groups(web_service)
+
+get_directory_property(OPENSSL_LIBS
+        DIRECTORY ${CMAKE_SOURCE_DIR}/externals/libressl
+        DEFINITION OPENSSL_LIBS)
+target_compile_definitions(web_service PUBLIC -DCPPHTTPLIB_OPENSSL_SUPPORT)
+target_link_libraries(web_service PRIVATE common json-headers ${OPENSSL_LIBS} httplib lurlparser)
diff --git a/src/web_service/telemetry_json.cpp b/src/web_service/telemetry_json.cpp
new file mode 100644
index 000000000..033ea1ea4
--- /dev/null
+++ b/src/web_service/telemetry_json.cpp
@@ -0,0 +1,99 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <thread>
+#include "common/assert.h"
+#include "common/detached_tasks.h"
+#include "web_service/telemetry_json.h"
+#include "web_service/web_backend.h"
+
+namespace WebService {
+
+TelemetryJson::TelemetryJson(const std::string& host, const std::string& username,
+                             const std::string& token)
+    : host(std::move(host)), username(std::move(username)), token(std::move(token)) {}
+TelemetryJson::~TelemetryJson() = default;
+
+template <class T>
+void TelemetryJson::Serialize(Telemetry::FieldType type, const std::string& name, T value) {
+    sections[static_cast<u8>(type)][name] = value;
+}
+
+void TelemetryJson::SerializeSection(Telemetry::FieldType type, const std::string& name) {
+    TopSection()[name] = sections[static_cast<unsigned>(type)];
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<bool>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<double>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<float>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<u8>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<u16>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<u32>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<u64>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<s8>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<s16>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<s32>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<s64>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<std::string>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<const char*>& field) {
+    Serialize(field.GetType(), field.GetName(), std::string(field.GetValue()));
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<std::chrono::microseconds>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue().count());
+}
+
+void TelemetryJson::Complete() {
+    SerializeSection(Telemetry::FieldType::App, "App");
+    SerializeSection(Telemetry::FieldType::Session, "Session");
+    SerializeSection(Telemetry::FieldType::Performance, "Performance");
+    SerializeSection(Telemetry::FieldType::UserFeedback, "UserFeedback");
+    SerializeSection(Telemetry::FieldType::UserConfig, "UserConfig");
+    SerializeSection(Telemetry::FieldType::UserSystem, "UserSystem");
+
+    auto content = TopSection().dump();
+    // Send the telemetry async but don't handle the errors since they were written to the log
+    Common::DetachedTasks::AddTask(
+        [host{this->host}, username{this->username}, token{this->token}, content]() {
+            Client{host, username, token}.PostJson("/telemetry", content, true);
+        });
+}
+
+} // namespace WebService
diff --git a/src/web_service/telemetry_json.h b/src/web_service/telemetry_json.h
new file mode 100644
index 000000000..0fe6f9a3e
--- /dev/null
+++ b/src/web_service/telemetry_json.h
@@ -0,0 +1,58 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <string>
+#include <json.hpp>
+#include "common/telemetry.h"
+#include "common/web_result.h"
+
+namespace WebService {
+
+/**
+ * Implementation of VisitorInterface that serialized telemetry into JSON, and submits it to the
+ * yuzu web service
+ */
+class TelemetryJson : public Telemetry::VisitorInterface {
+public:
+    TelemetryJson(const std::string& host, const std::string& username, const std::string& token);
+    ~TelemetryJson();
+
+    void Visit(const Telemetry::Field<bool>& field) override;
+    void Visit(const Telemetry::Field<double>& field) override;
+    void Visit(const Telemetry::Field<float>& field) override;
+    void Visit(const Telemetry::Field<u8>& field) override;
+    void Visit(const Telemetry::Field<u16>& field) override;
+    void Visit(const Telemetry::Field<u32>& field) override;
+    void Visit(const Telemetry::Field<u64>& field) override;
+    void Visit(const Telemetry::Field<s8>& field) override;
+    void Visit(const Telemetry::Field<s16>& field) override;
+    void Visit(const Telemetry::Field<s32>& field) override;
+    void Visit(const Telemetry::Field<s64>& field) override;
+    void Visit(const Telemetry::Field<std::string>& field) override;
+    void Visit(const Telemetry::Field<const char*>& field) override;
+    void Visit(const Telemetry::Field<std::chrono::microseconds>& field) override;
+
+    void Complete() override;
+
+private:
+    nlohmann::json& TopSection() {
+        return sections[static_cast<u8>(Telemetry::FieldType::None)];
+    }
+
+    template <class T>
+    void Serialize(Telemetry::FieldType type, const std::string& name, T value);
+
+    void SerializeSection(Telemetry::FieldType type, const std::string& name);
+
+    nlohmann::json output;
+    std::array<nlohmann::json, 7> sections;
+    std::string host;
+    std::string username;
+    std::string token;
+};
+
+} // namespace WebService
diff --git a/src/web_service/verify_login.cpp b/src/web_service/verify_login.cpp
new file mode 100644
index 000000000..124aa3863
--- /dev/null
+++ b/src/web_service/verify_login.cpp
@@ -0,0 +1,27 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <json.hpp>
+#include "web_service/verify_login.h"
+#include "web_service/web_backend.h"
+
+namespace WebService {
+
+bool VerifyLogin(const std::string& host, const std::string& username, const std::string& token) {
+    Client client(host, username, token);
+    auto reply = client.GetJson("/profile", false).returned_data;
+    if (reply.empty()) {
+        return false;
+    }
+    nlohmann::json json = nlohmann::json::parse(reply);
+    const auto iter = json.find("username");
+
+    if (iter == json.end()) {
+        return username.empty();
+    }
+
+    return username == *iter;
+}
+
+} // namespace WebService
diff --git a/src/web_service/verify_login.h b/src/web_service/verify_login.h
new file mode 100644
index 000000000..39db32dbb
--- /dev/null
+++ b/src/web_service/verify_login.h
@@ -0,0 +1,22 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <future>
+#include <string>
+
+namespace WebService {
+
+/**
+ * Checks if username and token is valid
+ * @param host the web API URL
+ * @param username yuzu username to use for authentication.
+ * @param token yuzu token to use for authentication.
+ * @returns a bool indicating whether the verification succeeded
+ */
+bool VerifyLogin(const std::string& host, const std::string& username, const std::string& token);
+
+} // namespace WebService
diff --git a/src/web_service/web_backend.cpp b/src/web_service/web_backend.cpp
new file mode 100644
index 000000000..787b0fbcb
--- /dev/null
+++ b/src/web_service/web_backend.cpp
@@ -0,0 +1,149 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstdlib>
+#include <string>
+#include <thread>
+#include <LUrlParser.h>
+#include "common/logging/log.h"
+#include "common/web_result.h"
+#include "core/settings.h"
+#include "web_service/web_backend.h"
+
+namespace WebService {
+
+constexpr std::array<const char, 1> API_VERSION{'1'};
+
+constexpr u32 HTTP_PORT = 80;
+constexpr u32 HTTPS_PORT = 443;
+
+constexpr u32 TIMEOUT_SECONDS = 30;
+
+Client::JWTCache Client::jwt_cache{};
+
+Client::Client(const std::string& host, const std::string& username, const std::string& token)
+    : host(host), username(username), token(token) {
+    std::lock_guard<std::mutex> lock(jwt_cache.mutex);
+    if (username == jwt_cache.username && token == jwt_cache.token) {
+        jwt = jwt_cache.jwt;
+    }
+}
+
+Common::WebResult Client::GenericJson(const std::string& method, const std::string& path,
+                                      const std::string& data, const std::string& jwt,
+                                      const std::string& username, const std::string& token) {
+    if (cli == nullptr) {
+        auto parsedUrl = LUrlParser::clParseURL::ParseURL(host);
+        int port;
+        if (parsedUrl.m_Scheme == "http") {
+            if (!parsedUrl.GetPort(&port)) {
+                port = HTTP_PORT;
+            }
+            cli =
+                std::make_unique<httplib::Client>(parsedUrl.m_Host.c_str(), port, TIMEOUT_SECONDS);
+        } else if (parsedUrl.m_Scheme == "https") {
+            if (!parsedUrl.GetPort(&port)) {
+                port = HTTPS_PORT;
+            }
+            cli = std::make_unique<httplib::SSLClient>(parsedUrl.m_Host.c_str(), port,
+                                                       TIMEOUT_SECONDS);
+        } else {
+            LOG_ERROR(WebService, "Bad URL scheme {}", parsedUrl.m_Scheme);
+            return Common::WebResult{Common::WebResult::Code::InvalidURL, "Bad URL scheme"};
+        }
+    }
+    if (cli == nullptr) {
+        LOG_ERROR(WebService, "Invalid URL {}", host + path);
+        return Common::WebResult{Common::WebResult::Code::InvalidURL, "Invalid URL"};
+    }
+
+    httplib::Headers params;
+    if (!jwt.empty()) {
+        params = {
+            {std::string("Authorization"), fmt::format("Bearer {}", jwt)},
+        };
+    } else if (!username.empty()) {
+        params = {
+            {std::string("x-username"), username},
+            {std::string("x-token"), token},
+        };
+    }
+
+    params.emplace(std::string("api-version"), std::string(API_VERSION.begin(), API_VERSION.end()));
+    if (method != "GET") {
+        params.emplace(std::string("Content-Type"), std::string("application/json"));
+    };
+
+    httplib::Request request;
+    request.method = method;
+    request.path = path;
+    request.headers = params;
+    request.body = data;
+
+    httplib::Response response;
+
+    if (!cli->send(request, response)) {
+        LOG_ERROR(WebService, "{} to {} returned null", method, host + path);
+        return Common::WebResult{Common::WebResult::Code::LibError, "Null response"};
+    }
+
+    if (response.status >= 400) {
+        LOG_ERROR(WebService, "{} to {} returned error status code: {}", method, host + path,
+                  response.status);
+        return Common::WebResult{Common::WebResult::Code::HttpError,
+                                 std::to_string(response.status)};
+    }
+
+    auto content_type = response.headers.find("content-type");
+
+    if (content_type == response.headers.end()) {
+        LOG_ERROR(WebService, "{} to {} returned no content", method, host + path);
+        return Common::WebResult{Common::WebResult::Code::WrongContent, ""};
+    }
+
+    if (content_type->second.find("application/json") == std::string::npos &&
+        content_type->second.find("text/html; charset=utf-8") == std::string::npos) {
+        LOG_ERROR(WebService, "{} to {} returned wrong content: {}", method, host + path,
+                  content_type->second);
+        return Common::WebResult{Common::WebResult::Code::WrongContent, "Wrong content"};
+    }
+    return Common::WebResult{Common::WebResult::Code::Success, "", response.body};
+}
+
+void Client::UpdateJWT() {
+    if (!username.empty() && !token.empty()) {
+        auto result = GenericJson("POST", "/jwt/internal", "", "", username, token);
+        if (result.result_code != Common::WebResult::Code::Success) {
+            LOG_ERROR(WebService, "UpdateJWT failed");
+        } else {
+            std::lock_guard<std::mutex> lock(jwt_cache.mutex);
+            jwt_cache.username = username;
+            jwt_cache.token = token;
+            jwt_cache.jwt = jwt = result.returned_data;
+        }
+    }
+}
+
+Common::WebResult Client::GenericJson(const std::string& method, const std::string& path,
+                                      const std::string& data, bool allow_anonymous) {
+    if (jwt.empty()) {
+        UpdateJWT();
+    }
+
+    if (jwt.empty() && !allow_anonymous) {
+        LOG_ERROR(WebService, "Credentials must be provided for authenticated requests");
+        return Common::WebResult{Common::WebResult::Code::CredentialsMissing, "Credentials needed"};
+    }
+
+    auto result = GenericJson(method, path, data, jwt);
+    if (result.result_string == "401") {
+        // Try again with new JWT
+        UpdateJWT();
+        result = GenericJson(method, path, data, jwt);
+    }
+
+    return result;
+}
+
+} // namespace WebService
diff --git a/src/web_service/web_backend.h b/src/web_service/web_backend.h
new file mode 100644
index 000000000..d75fbcc15
--- /dev/null
+++ b/src/web_service/web_backend.h
@@ -0,0 +1,92 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <mutex>
+#include <string>
+#include <tuple>
+#include <httplib.h>
+#include "common/common_types.h"
+#include "common/web_result.h"
+
+namespace httplib {
+class Client;
+}
+
+namespace WebService {
+
+class Client {
+public:
+    Client(const std::string& host, const std::string& username, const std::string& token);
+
+    /**
+     * Posts JSON to the specified path.
+     * @param path the URL segment after the host address.
+     * @param data String of JSON data to use for the body of the POST request.
+     * @param allow_anonymous If true, allow anonymous unauthenticated requests.
+     * @return the result of the request.
+     */
+    Common::WebResult PostJson(const std::string& path, const std::string& data,
+                               bool allow_anonymous) {
+        return GenericJson("POST", path, data, allow_anonymous);
+    }
+
+    /**
+     * Gets JSON from the specified path.
+     * @param path the URL segment after the host address.
+     * @param allow_anonymous If true, allow anonymous unauthenticated requests.
+     * @return the result of the request.
+     */
+    Common::WebResult GetJson(const std::string& path, bool allow_anonymous) {
+        return GenericJson("GET", path, "", allow_anonymous);
+    }
+
+    /**
+     * Deletes JSON to the specified path.
+     * @param path the URL segment after the host address.
+     * @param data String of JSON data to use for the body of the DELETE request.
+     * @param allow_anonymous If true, allow anonymous unauthenticated requests.
+     * @return the result of the request.
+     */
+    Common::WebResult DeleteJson(const std::string& path, const std::string& data,
+                                 bool allow_anonymous) {
+        return GenericJson("DELETE", path, data, allow_anonymous);
+    }
+
+private:
+    /// A generic function handles POST, GET and DELETE request together
+    Common::WebResult GenericJson(const std::string& method, const std::string& path,
+                                  const std::string& data, bool allow_anonymous);
+
+    /**
+     * A generic function with explicit authentication method specified
+     * JWT is used if the jwt parameter is not empty
+     * username + token is used if jwt is empty but username and token are not empty
+     * anonymous if all of jwt, username and token are empty
+     */
+    Common::WebResult GenericJson(const std::string& method, const std::string& path,
+                                  const std::string& data, const std::string& jwt = "",
+                                  const std::string& username = "", const std::string& token = "");
+
+    // Retrieve a new JWT from given username and token
+    void UpdateJWT();
+
+    std::string host;
+    std::string username;
+    std::string token;
+    std::string jwt;
+    std::unique_ptr<httplib::Client> cli;
+
+    struct JWTCache {
+        std::mutex mutex;
+        std::string username;
+        std::string token;
+        std::string jwt;
+    };
+    static JWTCache jwt_cache;
+};
+
+} // namespace WebService