impersonation.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_IMPERSONATION_HEADER
#define LIBFILEZILLA_IMPERSONATION_HEADER

 
#include <array>
#include <cstddef>
#include <functional>
#include <initializer_list>
#include <memory>
#include <variant>
#include <type_traits>
#include <utility>
 
#include "string.hpp"
#include "logger.hpp"
 
#ifdef FZ_WINDOWS
#include "glue/windows.hpp"
#endif
 
namespace fz {
 
class logger_interface;
 
class FZ_PUBLIC_SYMBOL user
{
    // An invalid user. Used only during default construction
    struct FZ_PUBLIC_SYMBOL invalid
    {
        explicit operator bool() const;
    };
 
public:
    struct FZ_PUBLIC_SYMBOL name
    {
        fz::native_string value;
 
        name() = default;
        name(fz::native_string v);
 
        explicit operator bool() const;
    };

    struct FZ_PUBLIC_SYMBOL id
    {
        std::string value;
 
        explicit operator bool() const;
    };
 
    user() = default;
 
    template <typename T, std::enable_if_t<std::is_constructible_v<name, T>>* = nullptr>
    user(T && user_name)
        : value_(name{std::forward<T>(user_name)})
    {
    }
 
    user(id user_id);
 
    explicit operator bool() const;
 
    fz::native_string const *get_name() const;
 
    std::string const *get_id() const;
 
private:
    std::variant<invalid, name, id> value_;
};
 
#if FZ_WINDOWS
namespace impersonation_desktop
{
    struct automatic {};

    struct isolated {
        std::wstring desktop_name_prefix;
    };

    struct named {
        std::wstring name;
    };

    using mode = std::variant<automatic, isolated, named>;
};
 
enum class impersonation_profile_mode
{
    skip,

    require_if_roaming,

    require
};
#endif
 
struct impersonation_options
{
    struct pwless_type{};
    static constexpr pwless_type pwless{};
 
#if FZ_WINDOWS
    impersonation_desktop::mode desktop = impersonation_desktop::automatic{};

    impersonation_profile_mode profile = impersonation_profile_mode::require;

    bool drop_admin_privileges = true;
#else
    fz::native_string group;
#endif
};
 
class impersonation_token_impl;
class impersonation_token;
 
enum class impersonation_capability : std::size_t
{
    password,

    passwordless,

    user_profile
};
 
enum class impersonation_capability_state
{
    not_requested,

    not_applicable,

    indeterminate,

    unavailable,

    available
};
 
class FZ_PUBLIC_SYMBOL impersonation_capabilities final
{
public:
    impersonation_capability_state operator[](impersonation_capability capability) const;
 
private:
    friend class impersonation_token;
 
    std::array<impersonation_capability_state, 3> states_{};
};

class FZ_PUBLIC_SYMBOL impersonation_token final
{
public:
    impersonation_token();
 
    impersonation_token(impersonation_token&&) noexcept;
    impersonation_token& operator=(impersonation_token&&) noexcept;

    explicit impersonation_token(fz::user const& user, fz::native_string const &password, fz::logger_interface& logger = get_null_logger(), impersonation_options const& opts = {});
    explicit impersonation_token(fz::user const& user, impersonation_options::pwless_type, fz::logger_interface& logger = get_null_logger(), impersonation_options const& opts = {});

    static impersonation_capabilities get_capabilities(std::initializer_list<impersonation_capability> requested);
 
    ~impersonation_token() noexcept;
 
    explicit operator bool() const {
        return impl_.operator bool();
    }
 
    bool operator==(impersonation_token const&) const;
    bool operator<(impersonation_token const&) const;

    fz::native_string username() const;

    fz::native_string home() const;

    std::size_t hash() const noexcept;

    std::string uid() const;
 
private:
    impersonation_token(fz::user const& user, fz::native_string const *password, fz::logger_interface& logger = get_null_logger(), impersonation_options const& opts = {});
 
    friend class impersonation_token_impl;
    std::unique_ptr<impersonation_token_impl> impl_;
};
 
#if !FZ_WINDOWS
bool FZ_PUBLIC_SYMBOL set_process_impersonation(impersonation_token const& token);
#else
HANDLE FZ_PUBLIC_SYMBOL get_handle(impersonation_token const& token);
#endif

native_string FZ_PUBLIC_SYMBOL current_username();

std::string FZ_PUBLIC_SYMBOL get_user_id(native_string const& name);

native_string FZ_PUBLIC_SYMBOL get_user_name(std::string const& id);
 
}
 
namespace std {

template <>
struct hash<fz::impersonation_token>
{
    std::size_t operator()(fz::impersonation_token const& op) const noexcept
    {
        return op.hash();
    }
};
 
}
 
#endif