filesystem.hpp

#ifndef MAAT_FS_HPP
#define MAAT_FS_HPP
 
#include <memory>
#include "memory.hpp"
#include "env/os.hpp"
#include "snapshot.hpp"
 
namespace maat
{
namespace env
{
 
class PhysicalFile;
typedef std::shared_ptr<PhysicalFile> physical_file_t;
 
typedef int filehandle_t;
 
class FileAccessor
{
friend class FileSystem;
public:
    struct State
    {
        addr_t read_ptr; 
        addr_t write_ptr; 
    };
protected:
    filehandle_t _handle;
    int flags; // TODO ? 
    physical_file_t physical_file;
    addr_t _alloc_addr; // Address where the EnvFile's fileno has been allocated in memory ??? TODO
    State state;
public:
    bool deleted; 
public:
    FileAccessor(physical_file_t physical_file, filehandle_t handle);
    unsigned int write_buffer(const std::vector<Expr>& buffer);
    unsigned int write_buffer(uint8_t* buffer, int len);
    unsigned int read_buffer(std::vector<Expr>& buffer, unsigned int nb_elems, unsigned int elem_size);
public:
    filehandle_t handle() const;
};
 
 
enum class FileSystemAction
{
    CREATE_FILE, 
    DELETE_FILE, 
    CREATE_DIR, 
    DELETE_DIR 
};
 
// Env Snapshot
class Snapshot
{
public:
    std::list<std::pair<std::shared_ptr<PhysicalFile>, SavedMemState>> saved_file_contents;
    // <path, action>
    std::list<std::pair<std::string, FileSystemAction>> fs_actions;
    std::list<env::FileAccessor> file_accessors;
public:
    Snapshot() = default;
    Snapshot(const Snapshot& other) = delete;
    Snapshot& operator=(const Snapshot& other) = delete;
public:
    void add_saved_file_content(std::shared_ptr<PhysicalFile> file, SavedMemState&& content);
    void add_filesystem_action(std::string path, FileSystemAction action);
};
 
 
 
typedef unsigned node_status_t;
namespace node
{
    static constexpr node_status_t none = 0;
 
    static constexpr node_status_t exists = 1 << 0;
    static constexpr node_status_t is_file = 1 << 1;
    static constexpr node_status_t is_symlink = 1 << 2;
    static constexpr node_status_t is_dir = 1 << 3;
 
    bool check_is_file(node_status_t s);
    bool check_is_symlink(node_status_t s);
    bool check_is_dir(node_status_t s);
}
 
typedef std::vector<std::string> fspath_t;
 
class PhysicalFile: public std::enable_shared_from_this<PhysicalFile>
{
friend class FileSystem;
public:
    enum class Type
    {
        REGULAR, 
        IOSTREAM, 
        SYMLINK 
    };
 
protected:
    std::shared_ptr<MemSegment> data;
    int flags;
    bool deleted; 
    addr_t _size; 
    std::string _symlink; 
    Type type;
private:
    addr_t istream_read_offset; 
private:
    SnapshotManager<env::Snapshot>* snapshots; 
public:
    std::optional<std::reference_wrapper<std::ostream>> flush_stream;
public:
    PhysicalFile(SnapshotManager<env::Snapshot>* snapshots, Type type = Type::REGULAR);
    unsigned int write_buffer(const std::vector<Expr>& buffer, addr_t& offset);
    unsigned int write_buffer(uint8_t* buffer, addr_t& offset, int len);
    unsigned int read_buffer(std::vector<Expr>& buffer, addr_t& offset, unsigned int nb_elems, unsigned int elem_size);
    unsigned int size();
    unsigned int copy_real_file(const std::string& filename);
public:
    node_status_t status();
public:
    void set_deleted(bool deleted);
    bool is_deleted();
    bool is_symlink();
    const std::string& symlink();
 
private:
    // Used by streams
    void _adjust_read_offset(addr_t& offset);
    void _adjust_write_offset(addr_t& offset);
 
private:
    // Snapshoting
    void record_write(addr_t offset, int nb_bytes);
 
protected:
    void _set_symlink(const std::string& target);
};
 
 
 
class Directory;
typedef std::shared_ptr<Directory> directory_t;
 
class Directory
{
friend class FileSystem;
protected:
    bool deleted;
private:
    std::map<std::string, physical_file_t> files;
    std::map<std::string, directory_t> subdirs;
    std::map<std::string, fspath_t> symlinks;
private:
    SnapshotManager<env::Snapshot>* snapshots; 
private:
    // Return True if 'name' is an existing file or subdir or symlink
    bool _contains_name(const std::string& name);
public:
    Directory(SnapshotManager<env::Snapshot>* snapshots); 
    bool create_file(fspath_t path, bool create_path = false); // TODO snapshot manager ?
    physical_file_t get_file(fspath_t path);
    bool delete_file(fspath_t path, bool weak=true);
    bool create_dir(fspath_t path);
    directory_t get_dir(fspath_t path);
    bool delete_dir(fspath_t path, bool weak=true);
    node_status_t get_node_status(fspath_t path);
    void delete_self(bool recursive=true, bool weak=true); // TODO Snapshot, FileSystem, not used anymore?
public:
    void print(std::ostream& os, const std::string& indent) const;
};
 
 
 
class FileSystem
{
friend class EnvEmulator;
friend class LinuxEmulator;
 
private:
    filehandle_t _handle_cnt;
    std::string path_separator;
    std::string rootdir_prefix;
    char orphan_file_wildcard;
    Directory root;
    Directory orphan_files; // Stdin, stdout, stderr, network streams, ...
    // TODO: returning references to FAs in this list is 
    // probably not safe if the list is modified before they
    // are used....
    std::list<FileAccessor> fa_list;
    std::vector<filehandle_t> reserved_handles;
private:
    SnapshotManager<env::Snapshot> snapshots;
public:
    FileSystem(OS system);
 
public:
    // Physical files
    // get_fa_by_* functions don't check whether the path is marked as 'deleted' !
 
    physical_file_t get_file(const std::string& path, bool follow_symlink=true);
     physical_file_t get_file_by_handle(filehandle_t handle);
    bool create_file(const std::string& path, bool create_path=false);
    bool delete_file(const std::string& path, bool weak=true);
    bool file_exists(const std::string& path);
 
    // Symlinks
    bool create_symlink(const std::string& link, const std::string& pointed_file, bool create_path=false);
 
    // Handles (FILE*)
    filehandle_t new_fa(const std::string& path);
    FileAccessor& get_fa_by_handle(filehandle_t handle);
    void delete_fa(filehandle_t handle, bool weak=true);
 
    // Dir
    bool create_dir(const std::string& path);
    directory_t get_dir(const std::string& path);
    bool delete_dir(const std::string& path, bool weak=true);
 
    // Utils
    std::string path_from_fspath(const fspath_t& path);
    fspath_t fspath_from_path(const std::string& path);
    fspath_t fspath_from_path_relative_to(std::string rel_path, fspath_t path_base);
    std::string path_from_relative_path(std::string rel_path, std::string path_base);
    std::string pointed_path_from_symlink(std::string symlink_file);
    bool is_relative_path(const std::string& path);
 
    node_status_t get_node_status(const std::string& path);
 
public:
    std::string get_stdin_for_pid(int pid);
    std::string get_stdout_for_pid(int pid);
    std::string get_stderr_for_pid(int pid);
 
public:
    friend std::ostream& operator<<(std::ostream& os, const FileSystem& fs);
 
private:
    filehandle_t get_free_handle();
    void _new_fa(const std::string& path, filehandle_t handle);
 
public:
    using snapshot_t = int;
    snapshot_t take_snapshot();
    void restore_snapshot(snapshot_t snapshot, bool remove=false);
    void restore_last_snapshot(bool remove=false);
};
 
 
 // Doxygen group env
    
} // namespace env
} // namespace maat
 
#endif