filesystem.hxx

Go to the documentation of this file.

#pragma once
 
// Linux
#include <linux/close_range.h>
 
// C++
#include <optional>
#include <string>
#include <string_view>
#include <utility>
 
// cosmos
#include <cosmos/SysString.hxx>
#include <cosmos/dso_export.h>
#include <cosmos/error/errno.hxx>
#include <cosmos/fs/DirFD.hxx>
#include <cosmos/fs/FileDescriptor.hxx>
#include <cosmos/fs/types.hxx>
#include <cosmos/types.hxx>
 
namespace cosmos::fs {
 
 
COSMOS_API FileDescriptor open(
                const SysString path, const OpenMode mode,
                const OpenFlags flags, const std::optional<FileMode> fmode = {});
 
 
COSMOS_API FileDescriptor open_at(
                const DirFD dir_fd, const SysString path,
                const OpenMode mode, const OpenFlags flags,
                const std::optional<FileMode> fmode = {});
 
enum class CloseRangeFlag : unsigned int {
        CLOEXEC = CLOSE_RANGE_CLOEXEC,
        UNSHARE = CLOSE_RANGE_UNSHARE
};
enum class CloseRangeFlag : unsigned int {…};
 
using CloseRangeFlags = BitMask<CloseRangeFlag>;
 
 
COSMOS_API void close_range(const FileNum first,
                const FileNum last = FileNum::MAX_FD,
                const CloseRangeFlags flags = CloseRangeFlags{});
 
 
COSMOS_API std::pair<FileDescriptor, std::string> make_tempfile(
                const SysString _template, const OpenFlags flags = OpenFlags{OpenFlag::CLOEXEC});
 
 
COSMOS_API std::string make_tempdir(const SysString _template);
 
 
COSMOS_API void make_fifo(const SysString path, const FileMode mode);
 
 
COSMOS_API void make_fifo_at(const DirFD dir_fd, const SysString path,
                const FileMode mode);
 
 
COSMOS_API FileMode set_umask(const FileMode mode);
 
 
COSMOS_API bool exists_file(const SysString path);
 
 
COSMOS_API void unlink_file(const SysString path);
 
 
COSMOS_API void unlink_file_at(const DirFD dir_fd, const SysString path);
 
 
COSMOS_API void change_dir(const SysString path);
 
 
COSMOS_API std::string get_working_dir();
 
 
COSMOS_API std::optional<std::string> which(const std::string_view exec_base) noexcept;
 
 
COSMOS_API void make_dir(const SysString path, const FileMode mode);
 
 
COSMOS_API void make_dir_at(const DirFD dir_fd, const SysString path, const FileMode mode);
 
 
COSMOS_API void remove_dir(const SysString path);
 
 
COSMOS_API void remove_dir_at(const DirFD dir_fd, const SysString path);
 
 
COSMOS_API Errno make_all_dirs(const SysString path, const FileMode mode);
 
 
COSMOS_API void remove_tree(const SysString path);
 
 
COSMOS_API void change_mode(const SysString path, const FileMode mode);
 
 
COSMOS_API void change_mode(const FileDescriptor fd, const FileMode mode);
 
 
COSMOS_API void change_owner(const SysString path, const UserID uid, const GroupID gid = GroupID::INVALID);
 
 
COSMOS_API void change_owner(const FileDescriptor fd, const UserID uid, const GroupID gid = GroupID::INVALID);
 
 
COSMOS_API void change_owner(const SysString path, const SysString user,
                const SysString group = {});
 
 
COSMOS_API void change_owner(const FileDescriptor fd, const SysString user,
                const SysString group = {});
 
inline void change_group(const FileDescriptor fd, const GroupID id) {
        change_owner(fd, UserID::INVALID, id);
}
inline void change_group(const FileDescriptor fd, const GroupID id) {…}
 
inline void change_group(const FileDescriptor fd, const SysString group) {
        change_owner(fd, {}, group);
}
inline void change_group(const FileDescriptor fd, const SysString group) {…}
 
inline void change_group(const SysString path, const GroupID id) {
        change_owner(path, UserID::INVALID, id);
}
inline void change_group(const SysString path, const GroupID id) {…}
 
inline void change_group(const SysString path, const SysString group) {
        change_owner(path, {}, group);
}
inline void change_group(const SysString path, const SysString group) {…}
 
 
COSMOS_API void change_owner_nofollow(const SysString path, const UserID uid,
                const GroupID gid = GroupID::INVALID);
 
 
COSMOS_API void change_owner_nofollow(const SysString path, const SysString user,
                const SysString group = {});
 
 
COSMOS_API void make_symlink(const SysString target, const SysString path);
 
 
COSMOS_API void make_symlink_at(const SysString target, const DirFD dir_fd,
                const SysString path);
 
 
COSMOS_API std::string read_symlink(const SysString path);
 
 
COSMOS_API std::string read_symlink_at(const DirFD dir_fd, const SysString path);
 
 
COSMOS_API void link(const SysString old_path, const SysString new_path);
 
 
COSMOS_API void linkat(const DirFD old_dir, const SysString old_path,
                const DirFD new_dir, const SysString new_path,
                const FollowSymlinks follow_old = FollowSymlinks{false});
 
 
COSMOS_API void linkat_fd(const FileDescriptor fd, const DirFD new_dir,
                const SysString new_path);
 
 
COSMOS_API void linkat_proc_fd(const FileDescriptor fd, const DirFD new_dir,
                const SysString new_path);
 
 
COSMOS_API void truncate(const FileDescriptor fd, off_t length);
 
 
COSMOS_API void truncate(const SysString path, off_t length);
 
struct CopyFileRangeParameters {
        FileDescriptor in;
        FileDescriptor out;
        size_t len;
        std::optional<off_t> off_in;
        std::optional<off_t> off_out;
};
struct CopyFileRangeParameters {…};
 
 
COSMOS_API size_t copy_file_range(CopyFileRangeParameters &pars);
 
 
COSMOS_API size_t copy_file_range(
                const FileDescriptor fd_in, const FileDescriptor fd_out, const size_t len);
 
enum class AccessCheck : int {
         READ_OK = R_OK, 
        WRITE_OK = W_OK, 
         EXEC_OK = X_OK  
};
enum class AccessCheck : int {…};
 
using AccessChecks = BitMask<AccessCheck>;
 
 
COSMOS_API void check_access(const SysString path, const AccessChecks checks = {});
 
enum class AccessFlag : int {
        EFFECTIVE_CREDS = AT_EACCESS,         
        NO_FOLLOW       = AT_SYMLINK_NOFOLLOW 
};
enum class AccessFlag : int {…};
 
using AccessFlags = BitMask<AccessFlag>;
 
 
COSMOS_API void check_access_at(const DirFD dir_fd, const SysString path,
                const AccessChecks checks = {}, const AccessFlags flags = {});
 
 
COSMOS_API void check_access_fd(const FileDescriptor fd, const AccessChecks check = {},
                const AccessFlags flags = {});
 
enum class LockOperation : int {
        LOCK_SHARED    = LOCK_SH, 
        LOCK_EXCLUSIVE = LOCK_EX, 
        UNLOCK         = LOCK_UN  
};
enum class LockOperation : int {…};
 
enum class LockFlag : int {
        LOCK_NONBLOCK = LOCK_NB 
};
enum class LockFlag : int {…};
 
using LockFlags = BitMask<LockFlag>;
 
 
COSMOS_API void flock(const FileDescriptor fd, const LockOperation operation, const LockFlags flags = {});
 
} // end ns