util.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_UTIL_HEADER
#define LIBFILEZILLA_UTIL_HEADER

#include "libfilezilla.hpp"
#include "time.hpp"

#include <cstdint>

namespace fz {

void FZ_PUBLIC_SYMBOL sleep(duration const& d);

void FZ_PUBLIC_SYMBOL yield();

int64_t FZ_PUBLIC_SYMBOL random_number(int64_t min, int64_t max);

std::vector<uint8_t> FZ_PUBLIC_SYMBOL random_bytes(size_t size);

void FZ_PUBLIC_SYMBOL random_bytes(size_t size, uint8_t* destination);

class buffer;
void FZ_PUBLIC_SYMBOL random_bytes(size_t size, buffer& destination);

uint64_t FZ_PUBLIC_SYMBOL bitscan(uint64_t v);

uint64_t FZ_PUBLIC_SYMBOL bitscan_reverse(uint64_t v);

bool FZ_PUBLIC_SYMBOL equal_consttime(std::basic_string_view<uint8_t> const& lhs, std::basic_string_view<uint8_t> const& rhs);

template <typename First, typename Second,
          std::enable_if_t<sizeof(typename First::value_type) == sizeof(uint8_t) &&
                          sizeof(typename Second::value_type) == sizeof(uint8_t)>* = nullptr>
inline bool equal_consttime(First const& lhs, Second const& rhs)
{
    return equal_consttime(std::basic_string_view<uint8_t>(reinterpret_cast<uint8_t const*>(lhs.data()), lhs.size()),
                           std::basic_string_view<uint8_t>(reinterpret_cast<uint8_t const*>(rhs.data()), rhs.size()));
}

template<typename T, typename std::enable_if_t<std::is_final_v<T>>* = nullptr>
T& move_assign_through_move_constructor(T* p, T&& op) noexcept
{
    p->~T();
    new (p)T(std::move(op));
    return *p;
}

void FZ_PUBLIC_SYMBOL wipe(void* p, size_t n);

void FZ_PUBLIC_SYMBOL wipe(std::string & s);
void FZ_PUBLIC_SYMBOL wipe(std::wstring & s);
void FZ_PUBLIC_SYMBOL wipe(std::vector<uint8_t> & v);

template<typename T>
struct scoped_wiper final
{
    [[nodiscard]] scoped_wiper(T& v)
        : v_(v)
    {}

    ~scoped_wiper()
    {
        wipe(v_);
    }

    T& v_;
};

void FZ_PUBLIC_SYMBOL wipe_unused(std::string & s);
void FZ_PUBLIC_SYMBOL wipe_unused(std::wstring & s);
void FZ_PUBLIC_SYMBOL wipe_unused(std::vector<uint8_t> & v);

template<class A, class B>
constexpr bool cmp_less(A a, B b) noexcept
{
    static_assert(std::is_integral_v<A>);
    static_assert(std::is_integral_v<B>);
    if constexpr (std::is_signed_v<A> == std::is_signed_v<B>) {
        return a < b;
    }
    else if constexpr (std::is_signed_v<A>) {
        if (a < 0) {
            return true;
        }
        else {
            return std::make_unsigned_t<A>(a) < b;
        }
    }
    else {
        if (b < 0) {
            return false;
        }
        else {
            return a < std::make_unsigned_t<B>(b);
        }
    }
}

template<typename Out, typename In>
constexpr Out clamped_cast(In in) noexcept
{
    if (cmp_less(in, std::numeric_limits<Out>::min())) {
        return std::numeric_limits<Out>::min();
    }
    if (cmp_less(std::numeric_limits<Out>::max(), in)) {
        return std::numeric_limits<Out>::max();
    }
    return static_cast<Out>(in);
}

}

#endif