oauth_device.h

#ifndef SOURCEMETA_CORE_OAUTH_DEVICE_H_
#define SOURCEMETA_CORE_OAUTH_DEVICE_H_
 
#ifndef SOURCEMETA_CORE_OAUTH_EXPORT
#include <sourcemeta/core/oauth_export.h>
#endif
 
#include <sourcemeta/core/crypto.h>
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/oauth_authorization.h>
#include <sourcemeta/core/oauth_error.h>
 
#include <array>       // std::array
#include <chrono>      // std::chrono::seconds, std::chrono::system_clock
#include <cstdint>     // std::uint8_t
#include <optional>    // std::optional
#include <span>        // std::span
#include <string>      // std::string
#include <string_view> // std::string_view
 
namespace sourcemeta::core {
 
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif

SOURCEMETA_CORE_OAUTH_EXPORT
auto oauth_build_device_authorization_request(
    const std::string_view client_id, const std::string_view scope,
    const std::span<const OAuthParameter> resources, std::string &sink) -> void;

SOURCEMETA_CORE_OAUTH_EXPORT
auto oauth_build_token_request_device(
    const std::string_view device_code,
    const std::span<const OAuthParameter> resources, SecureString &sink)
    -> void;

class SOURCEMETA_CORE_OAUTH_EXPORT OAuthDeviceAuthorizationResponse {
public:
  explicit OAuthDeviceAuthorizationResponse(const JSON &data);

  [[nodiscard]] auto device_code() const -> std::optional<std::string_view>;
  [[nodiscard]] auto user_code() const -> std::optional<std::string_view>;
  [[nodiscard]] auto verification_uri() const
      -> std::optional<std::string_view>;
  [[nodiscard]] auto verification_uri_complete() const
      -> std::optional<std::string_view>;
  [[nodiscard]] auto expires_in() const -> std::optional<std::chrono::seconds>;
  [[nodiscard]] auto interval() const -> std::chrono::seconds;

  [[nodiscard]] auto data() const -> const JSON &;
 
private:
  const JSON *data_;
};

enum class OAuthDevicePollDecision : std::uint8_t {
  Continue,
  RetryWithNonce,
  Denied,
  Expired,
  Error
};

class SOURCEMETA_CORE_OAUTH_EXPORT OAuthDevicePoller {
public:
  OAuthDevicePoller(const std::chrono::seconds interval,
                    const std::chrono::seconds lifetime,
                    const std::chrono::steady_clock::time_point start) noexcept;

  [[nodiscard]] auto interval() const noexcept -> std::chrono::seconds;

  [[nodiscard]] auto
  expired(const std::chrono::steady_clock::time_point now) const noexcept
      -> bool;

  auto observe(const OAuthTokenError error) noexcept -> OAuthDevicePollDecision;
 
private:
  std::chrono::seconds interval_;
  std::chrono::seconds lifetime_;
  std::chrono::steady_clock::time_point start_;
};
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif

SOURCEMETA_CORE_OAUTH_EXPORT
auto oauth_make_device_authorization_response(
    const std::string_view device_code, const std::string_view user_code,
    const std::string_view verification_uri,
    const std::string_view verification_uri_complete,
    const std::chrono::seconds expires_in, const std::chrono::seconds interval)
    -> std::optional<JSON>;

SOURCEMETA_CORE_OAUTH_EXPORT
auto oauth_device_user_code() -> std::array<char, 8>;

SOURCEMETA_CORE_OAUTH_EXPORT
auto oauth_device_user_code_matches(const std::string_view presented,
                                    const std::string_view stored) -> bool;
 
} // namespace sourcemeta::core
 
#endif