sys.h

#ifndef WREPORT_SYS_H
#define WREPORT_SYS_H

#include <dirent.h>
#include <fcntl.h>
#include <filesystem>
#include <iterator>
#include <memory>
#include <string>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

namespace wreport::sys {

std::filesystem::path with_suffix(const std::filesystem::path& path,
                                  const std::string& suffix);

std::unique_ptr<struct stat> stat(const char* pathname);

std::unique_ptr<struct stat> stat(const std::string& pathname);

std::unique_ptr<struct stat> stat(const std::filesystem::path& path);

void stat(const char* pathname, struct stat& st);

void stat(const std::string& pathname, struct stat& st);

void stat(const std::filesystem::path& path, struct stat& st);

[[deprecated("Use std::filesystem::is_directory")]] bool
isdir(const std::string& pathname);

[[deprecated("Use std::filesystem::is_block_file")]] bool
isblk(const std::string& pathname);

[[deprecated("Use std::filesystem::is_character_file")]] bool
ischr(const std::string& pathname);

[[deprecated("Use std::filesystem::is_fifo")]] bool
isfifo(const std::string& pathname);

[[deprecated("Use std::filesystem::is_symlink")]] bool
islnk(const std::string& pathname);

[[deprecated("Use std::filesystem::is_regular_file")]] bool
isreg(const std::string& pathname);

[[deprecated("Use std::filesystem::is_socket")]] bool
issock(const std::string& pathname);

time_t timestamp(const std::filesystem::path& file);

time_t timestamp(const std::filesystem::path& file, time_t def);

size_t size(const std::filesystem::path& file);

size_t size(const std::filesystem::path& file, size_t def);

ino_t inode(const std::filesystem::path& file);

ino_t inode(const std::filesystem::path& file, ino_t def);

bool access(const std::filesystem::path& s, int m);

[[deprecated("Use std::filesystem::exists")]] bool exists(const std::string& s);

[[deprecated("Use std::filesystem::current_path")]] std::string getcwd();

[[deprecated("Use std::filesystem::current_path")]] void
chdir(const std::string& dir);

void chroot(const std::filesystem::path& dir);

mode_t umask(mode_t mask);

std::filesystem::path abspath(const std::filesystem::path& path);
[[deprecated("Use abspath(const std::filesystem::path&)")]] std::string
abspath(const std::string& pathname);
std::filesystem::path abspath(const char* path);

class MMap
{
    void* addr;
    size_t length;

public:
    MMap(const MMap&) = delete;
    MMap(MMap&&);
    MMap(void* addr, size_t length);
    ~MMap();

    MMap& operator=(const MMap&) = delete;
    MMap& operator=(MMap&&);

    size_t size() const { return length; }

    void munmap();

    template <typename T> operator const T*() const
    {
        return reinterpret_cast<const T*>(addr);
    }

    template <typename T> operator T*() const
    {
        return reinterpret_cast<T*>(addr);
    }
};

class FileDescriptor
{
protected:
    int fd = -1;

public:
    FileDescriptor();
    FileDescriptor(FileDescriptor&& o);
    explicit FileDescriptor(int fd);
    virtual ~FileDescriptor();

    // We can copy at the FileDescriptor level because the destructor does not
    // close fd
    FileDescriptor(const FileDescriptor& o)            = default;
    FileDescriptor& operator=(const FileDescriptor& o) = default;

    [[noreturn]] virtual void throw_error(const char* desc);

    [[noreturn]] virtual void throw_error_string(const std::string& desc);

    [[noreturn]] virtual void throw_runtime_error(const char* desc);

    bool is_open() const;

    void close();

    void fstat(struct stat& st);
    void fchmod(mode_t mode);

    void futimens(const ::timespec ts[2]);

    void fsync();
    void fdatasync();

    int dup();

    size_t read(void* buf, size_t count);

    bool read_all_or_retry(void* buf, size_t count);

    void read_all_or_throw(void* buf, size_t count);

    size_t write(const void* buf, size_t count);

    template <typename Container> size_t write(const Container& c)
    {
        return write(c.data(),
                     c.size() * sizeof(typename Container::value_type));
    }

    void write_all_or_retry(const void* buf, size_t count);

    template <typename Container> void write_all_or_retry(const Container& c)
    {
        write_all_or_retry(c.data(),
                           c.size() * sizeof(typename Container::value_type));
    }

    void write_all_or_throw(const void* buf, size_t count);

    template <typename Container> void write_all_or_throw(const Container& c)
    {
        write_all_or_throw(c.data(),
                           c.size() * sizeof(typename Container::value_type));
    }

    off_t lseek(off_t offset, int whence = SEEK_SET);

    size_t pread(void* buf, size_t count, off_t offset);
    size_t pwrite(const void* buf, size_t count, off_t offset);

    template <typename Container>
    size_t pwrite(const Container& c, off_t offset)
    {
        return pwrite(c.data(),
                      c.size() * sizeof(typename Container::value_type),
                      offset);
    }

    void ftruncate(off_t length);

    MMap mmap(size_t length, int prot, int flags, off_t offset = 0);

    bool ofd_setlk(::flock&);

    bool ofd_setlkw(::flock&, bool retry_on_signal = true);

    bool ofd_getlk(::flock&);

    int getfl();

    void setfl(int flags);

    operator int() const { return fd; }
};

class PreserveFileTimes
{
protected:
    FileDescriptor fd;
    ::timespec ts[2];

public:
    explicit PreserveFileTimes(FileDescriptor fd);
    ~PreserveFileTimes();
};

class NamedFileDescriptor : public FileDescriptor
{
protected:
    std::filesystem::path path_;

public:
    NamedFileDescriptor(int fd, const std::filesystem::path& path);
    NamedFileDescriptor(NamedFileDescriptor&&);
    NamedFileDescriptor& operator=(NamedFileDescriptor&&);

    // We can copy at the NamedFileDescriptor level because the destructor does
    // not close fd
    NamedFileDescriptor(const NamedFileDescriptor& o)            = default;
    NamedFileDescriptor& operator=(const NamedFileDescriptor& o) = default;

    [[noreturn]] virtual void throw_error(const char* desc) override;
    [[noreturn]] virtual void
    throw_error_string(const std::string& desc) override;
    [[noreturn]] virtual void throw_runtime_error(const char* desc) override;

    [[deprecated("use path() instead")]] std::string name() const
    {
        return path_.string();
    }
    const std::filesystem::path& path() const { return path_; }
};

struct ManagedNamedFileDescriptor : public NamedFileDescriptor
{
    using NamedFileDescriptor::NamedFileDescriptor;

    ManagedNamedFileDescriptor(ManagedNamedFileDescriptor&&)      = default;
    ManagedNamedFileDescriptor(const ManagedNamedFileDescriptor&) = delete;

    ~ManagedNamedFileDescriptor();

    ManagedNamedFileDescriptor&
    operator=(const ManagedNamedFileDescriptor&) = delete;
    ManagedNamedFileDescriptor& operator=(ManagedNamedFileDescriptor&&);
};

struct Path : public ManagedNamedFileDescriptor
{
    struct iterator
    {
        using iterator_category = std::input_iterator_tag;
        using value_type        = ::dirent;
        using difference_type   = int;
        using pointer           = ::dirent*;
        using reference         = ::dirent&;

        Path* path          = nullptr;
        DIR* dir            = nullptr;
        ::dirent* cur_entry = nullptr;

        // End iterator
        iterator();
        // Start iteration on dir
        explicit iterator(Path& dir);
        iterator(iterator&) = delete;
        iterator(iterator&& o) : dir(o.dir), cur_entry(o.cur_entry)
        {
            o.dir       = nullptr;
            o.cur_entry = nullptr;
        }
        ~iterator();
        iterator& operator=(iterator&)  = delete;
        iterator& operator=(iterator&&) = delete;

        bool operator==(const iterator& i) const;
        bool operator!=(const iterator& i) const;
        ::dirent& operator*() const { return *cur_entry; }
        ::dirent* operator->() const { return cur_entry; }
        iterator& operator++();

        bool isdir() const;

        bool isblk() const;

        bool ischr() const;

        bool isfifo() const;

        bool islnk() const;

        bool isreg() const;

        bool issock() const;

        Path open_path(int flags = 0) const;
    };

    using ManagedNamedFileDescriptor::ManagedNamedFileDescriptor;

    explicit Path(const std::filesystem::path& pathname, int flags = 0,
                  mode_t mode = 0777);
    Path(Path& parent, const char* pathname, int flags = 0, mode_t mode = 0777);
    Path(const Path&)            = delete;
    Path(Path&&)                 = default;
    Path& operator=(const Path&) = delete;
    Path& operator=(Path&&)      = default;

    void open(int flags, mode_t mode = 0777);

    DIR* fdopendir();

    iterator begin();

    iterator end();

    int openat(const char* pathname, int flags, mode_t mode = 0777);

    int openat_ifexists(const char* pathname, int flags, mode_t mode = 0777);

    bool faccessat(const char* pathname, int mode, int flags = 0);

    void fstatat(const char* pathname, struct stat& st);

    bool fstatat_ifexists(const char* pathname, struct stat& st);

    void lstatat(const char* pathname, struct stat& st);

    bool lstatat_ifexists(const char* pathname, struct stat& st);

    void unlinkat(const char* pathname);

    void mkdirat(const char* pathname, mode_t mode = 0777);

    void rmdirat(const char* pathname);

    void symlinkat(const char* target, const char* linkpath);

    std::string readlinkat(const char* pathname);

    void rmtree();

    static std::string mkdtemp(const std::filesystem::path& prefix);
    [[deprecated(
        "Use mkdtemp(const std::filesystem::path&)")]] static std::string
    mkdtemp(const std::string& prefix);
    static std::string mkdtemp(const char* prefix);
    static std::string mkdtemp(char* pathname_template);
};

class File : public ManagedNamedFileDescriptor
{
public:
    using ManagedNamedFileDescriptor::ManagedNamedFileDescriptor;

    File(File&&)      = default;
    File(const File&) = delete;

    explicit File(const std::filesystem::path& path);
    explicit File(const char* path);
    [[deprecated("Use File(const std::filesystem::path&)")]] explicit File(
        const std::string& path);

    File(const std::filesystem::path& path, int flags, mode_t mode = 0777);

    File& operator=(const File&) = delete;
    File& operator=(File&&)      = default;

    void open(int flags, mode_t mode = 0777);

    bool open_ifexists(int flags, mode_t mode = 0777);

    static File mkstemp(const std::filesystem::path& prefix);
    [[deprecated("Use mkstemp(const std::filesysten::path&)")]] static File
    mkstemp(const std::string& prefix);
    static File mkstemp(const char* prefix);
    static File mkstemp(char* pathname_template);
};

class Tempfile : public File
{
protected:
    bool m_unlink_on_exit = true;

public:
    Tempfile();
    explicit Tempfile(const std::filesystem::path& prefix);
    [[deprecated("Use Tempfile(const std::string&)")]] explicit Tempfile(
        const std::string& prefix);
    explicit Tempfile(const char* prefix);
    ~Tempfile();

    void unlink_on_exit(bool val);

    void unlink();
};

class Tempdir : public Path
{
protected:
    bool m_rmtree_on_exit = true;

public:
    Tempdir();
    explicit Tempdir(const std::filesystem::path& prefix);
    [[deprecated(
        "Use Tempdir(const "
        "std::filesystem::path&)")]] explicit Tempdir(const std::string&
                                                          prefix);
    explicit Tempdir(const char* prefix);
    ~Tempdir();

    void rmtree_on_exit(bool val);
};

std::string read_file(const std::filesystem::path& file);
[[deprecated("Use read_file(const std::filesystem::path&)")]] std::string
read_file(const std::string& file);
std::string read_file(const char* file);

void write_file(const std::filesystem::path& file, const std::string& data,
                mode_t mode = 0777);
[[deprecated("Use write_file(const std::filesystem::path&, …)")]] void
write_file(const std::string& file, const std::string& data,
           mode_t mode = 0777);
void write_file(const char* file, const std::string& data, mode_t mode = 0777);

void write_file(const std::filesystem::path& file, const void* data,
                size_t size, mode_t mode = 0777);
[[deprecated("Use write_file(const std::filesystem::path&, …)")]] void
write_file(const std::string& file, const void* data, size_t size,
           mode_t mode = 0777);
void write_file(const char* file, const void* data, size_t size,
                mode_t mode = 0777);

void write_file_atomically(const std::filesystem::path& file,
                           const std::string& data, mode_t mode = 0777);
[[deprecated(
    "Use write_file_atomically(const std::filesystem::path&, …)")]] void
write_file_atomically(const std::string& file, const std::string& data,
                      mode_t mode = 0777);
void write_file_atomically(const char* file, const std::string& data,
                           mode_t mode = 0777);

void write_file_atomically(const std::filesystem::path& file, const void* data,
                           size_t size, mode_t mode = 0777);
[[deprecated(
    "Use write_file_atomically(const std::filesystem::path&, …)")]] void
write_file_atomically(const std::string& file, const void* data, size_t size,
                      mode_t mode = 0777);

#if 0
// Create a temporary directory based on a template.
std::string mkdtemp(std::string templ);

void mkFilePath(const std::string& file);
#endif

[[deprecated("use std::filesystem::remove")]] bool
unlink_ifexists(const char* file);
[[deprecated("use std::filesystem::remove")]] bool
unlink_ifexists(const std::string& file);
[[deprecated("use std::filesystem::remove")]] bool
unlink_ifexists(const std::filesystem::path& file);

bool rename_ifexists(const std::filesystem::path& src,
                     const std::filesystem::path& dst);

[[deprecated("use std::filesystem::create_directory")]] bool
mkdir_ifmissing(const std::filesystem::path& path);

[[deprecated("use std::filesystem::create_directories")]] bool
makedirs(const std::filesystem::path& path);

std::filesystem::path which(const std::string& name);

void unlink(const std::filesystem::path& pathname);

void rmdir(const std::filesystem::path& pathname);

void rmtree(const std::filesystem::path& pathname);

bool rmtree_ifexists(const std::filesystem::path& pathname);
[[deprecated("use rmtree_ifexists(const std::filesystem::path&)")]] bool
rmtree_ifexists(const std::string& pathname);
bool rmtree_ifexists(const char* pathname);

[[deprecated("use std::filesystem::rename")]] void
rename(const std::string& src_pathname, const std::string& dst_pathname);

void touch(const std::filesystem::path& pathname, time_t ts);

bool touch_ifexists(const std::filesystem::path& pathname, time_t ts);

void clock_gettime(::clockid_t clk_id, ::timespec& ts);

unsigned long long timesec_elapsed(const ::timespec& begin,
                                   const ::timespec& until);

struct Clock
{
    ::clockid_t clk_id;
    ::timespec ts;

    explicit Clock(::clockid_t clk_id);

    unsigned long long elapsed();
};

void getrlimit(int resource, ::rlimit& rlim);

void setrlimit(int resource, const ::rlimit& rlim);

struct OverrideRlimit
{
    int resource;
    ::rlimit orig;

    OverrideRlimit(int resource, rlim_t rlim);
    ~OverrideRlimit();

    void set(rlim_t rlim);
};

struct OverrideEnvironment
{
    std::string name;
    bool was_set = false;
    std::string orig_value;

    // Unset the variable
    explicit OverrideEnvironment(const std::string& name);
    // Set the variable to the given value
    OverrideEnvironment(const std::string& name, const std::string& value);
    ~OverrideEnvironment();
};

template <typename T = char> class TempBuffer
{
    T* buffer = nullptr;

public:
    explicit TempBuffer(size_t size) : buffer(new T[size]) {}
    ~TempBuffer() { delete[] buffer; }
    TempBuffer(const TempBuffer&)            = delete;
    TempBuffer(TempBuffer&&)                 = delete;
    TempBuffer& operator=(const TempBuffer&) = delete;
    TempBuffer& operator=(TempBuffer&&)      = delete;

    T* data() { return buffer; }
    const T* data() const { return buffer; }
    operator T*() { return buffer; }
    operator const T*() const { return buffer; }
};

void breakpoint();

} // namespace wreport::sys

#endif