confighttp.h

Go to the documentation of this file.

#pragma once
 
// standard includes
#include <filesystem>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
 
// lib includes
#include <libvirtualhid/license.hpp>
#include <nlohmann/json.hpp>
#include <Simple-Web-Server/server_https.hpp>
 
// local includes
#include "thread_safe.h"

#define WEB_DIR SUNSHINE_ASSETS_DIR "/web/"
 
namespace confighttp {
  constexpr auto PORT_HTTPS = 1;  
 
  // Type aliases for HTTPS server components
  using https_server_t = SimpleWeb::Server<SimpleWeb::HTTPS>;
  using resp_https_t = std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTPS>::Response>;
  using req_https_t = std::shared_ptr<typename SimpleWeb::ServerBase<SimpleWeb::HTTPS>::Request>;
 
  // Main server start function
  void start();
 
  void print_req(const req_https_t &request);
  void send_response(const resp_https_t &response, const nlohmann::json &output_tree);
  void send_unauthorized(const resp_https_t &response, const req_https_t &request);
  void send_redirect(const resp_https_t &response, const req_https_t &request, const char *path);
  bool authenticate(const resp_https_t &response, const req_https_t &request);
  void not_found(const resp_https_t &response, const req_https_t &request, const std::string &error_message = "Not Found");
  void bad_request(const resp_https_t &response, const req_https_t &request, const std::string &error_message = "Bad Request");
  bool check_content_type(const resp_https_t &response, const req_https_t &request, const std::string_view &contentType);
  std::string generate_csrf_token(const std::string &client_id);
  bool validate_csrf_token(const resp_https_t &response, const req_https_t &request, const std::string &client_id);
  std::string get_client_id(const req_https_t &request);
  bool check_app_index(const resp_https_t &response, const req_https_t &request, int index);
  void getPage(const resp_https_t &response, const req_https_t &request, const char *html_file, bool require_auth = true, bool redirect_if_username = false);
  void getAsset(const resp_https_t &response, const req_https_t &request);
  void browseDirectory(const resp_https_t &response, const req_https_t &request);
  void getLocale(const resp_https_t &response, const req_https_t &request);
  void getCSRFToken(const resp_https_t &response, const req_https_t &request);

  void getPendingPairings(const resp_https_t &response, const req_https_t &request);

  void cancelPairing(const resp_https_t &response, const req_https_t &request);

  void savePin(const resp_https_t &response, const req_https_t &request);

  bool is_driver_version_development(std::string_view version);

  bool is_driver_version_supported(std::string_view version, std::string_view minimum_version);

  nlohmann::json build_driver_status(bool installed, const std::string &version, std::string_view minimum_version);

  nlohmann::json build_virtualhid_license_status(const lvh::LicenseResult &result);

  nlohmann::json get_virtualhid_driver_status();

  nlohmann::json get_vigembus_driver_status();
 
  void getVirtualInputStatus(const resp_https_t &response, const req_https_t &request);
 
  void getVirtualInputLicense(const resp_https_t &response, const req_https_t &request);
 
  void updateVirtualInputLicense(const resp_https_t &response, const req_https_t &request);
 
  void resetPortalToken(const resp_https_t &response, const req_https_t &request);
 
#ifdef SUNSHINE_TESTS
  using virtual_input_license_status_provider_t = std::function<lvh::LicenseResult()>;  
  using portal_token_path_provider_t = std::function<std::filesystem::path()>;  

  void set_virtual_input_license_status_provider_for_testing(virtual_input_license_status_provider_t status_provider);

  void reset_virtual_input_license_status_provider_for_testing();

  void set_portal_token_path_provider_for_testing(portal_token_path_provider_t path_provider);

  void reset_portal_token_path_provider_for_testing();

  void clear_sensitive_string_for_testing(std::string &value);
#endif
 
  // Browse helper functions (also exposed for unit testing)
  bool is_browsable_executable(const std::filesystem::directory_entry &entry, const std::filesystem::file_status &status);

  nlohmann::json build_browse_entries(const std::filesystem::path &dir_path, const std::string &type_str);
 
#ifdef _WIN32
  nlohmann::json get_windows_drives();
#endif
}  // namespace confighttp
 
// mime types map
const std::map<std::string, std::string> mime_types = {
  {"css", "text/css"},
  {"gif", "image/gif"},
  {"htm", "text/html"},
  {"html", "text/html"},
  {"ico", "image/x-icon"},
  {"jpeg", "image/jpeg"},
  {"jpg", "image/jpeg"},
  {"js", "application/javascript"},
  {"json", "application/json"},
  {"png", "image/png"},
  {"svg", "image/svg+xml"},
  {"ttf", "font/ttf"},
  {"txt", "text/plain"},
  {"woff2", "font/woff2"},
  {"xml", "text/xml"},
};