file_system_manager.hpp

Go to the documentation of this file.

#ifndef ARION_FS_MANAGER_HPP
#define ARION_FS_MANAGER_HPP
 
#include <arion/common/global_defs.hpp>
#include <map>
#include <memory>
#include <regex>
#include <string>
#include <vector>
 
namespace arion
{
 
class Arion;
 
struct ARION_EXPORT ARION_FILE
{
    int fd;
    std::string path;
    int flags;
    mode_t mode;
    bool blocking = true;
    off_t saved_off = 0;
    /*
     * Builder for ARION_FILE instances.
     */
    ARION_FILE() {};
    /*
     * Builder for ARION_FILE instances.
     * @param[in] fd The UNIX file descriptor.
     * @param[in] path Path to the file.
     * @param[in] flags Flags which were used to open the file (like in "open" syscall).
     * @param[in] mode Mode which was used to open the file (like in "open" syscall).
     */
    ARION_FILE(int fd, std::string path, int flags, mode_t mode) : fd(fd), path(path), flags(flags), mode(mode) {};
    /*
     * Builder for ARION_FILE instances. Used to clone an ARION_FILE instance.
     * @param[in] arion_f The ARION_FILE to be cloned.
     */
    ARION_FILE(std::shared_ptr<ARION_FILE> arion_f)
        : fd(arion_f->fd), path(arion_f->path), flags(arion_f->flags), mode(arion_f->mode), blocking(arion_f->blocking),
          saved_off(arion_f->saved_off) {};
    /*
     * Builder for ARION_FILE instances. Used to clone an ARION_FILE instance.
     * @param[in] arion_f The ARION_FILE to be cloned.
     */
    ARION_FILE(ARION_FILE *arion_f)
        : fd(arion_f->fd), path(arion_f->path), flags(arion_f->flags), mode(arion_f->mode), blocking(arion_f->blocking),
          saved_off(arion_f->saved_off) {};
};
/*
 * Serializes an ARION_FILE instance into a vector of bytes.
 * @param[in] arion_f The ARION_FILE to be serialized.
 * @return The serialized vector of bytes.
 */
std::vector<BYTE> serialize_arion_file(ARION_FILE *arion_f);
/*
 * Deserializes an ARION_FILE instance from a vector of bytes.
 * @param[in] srz_file The serialized vector of bytes.
 * @return The deserialized ARION_FILE.
 */
ARION_FILE *deserialize_arion_file(std::vector<BYTE> srz_file);
 
class ProcFSManager
{
  private:
    static const inline std::regex PROCFS_REGEX = std::regex(R"(^/proc/([0-9]+|self)/([^/]+)$)");
    std::weak_ptr<Arion> arion;
 
  public:
    /*
     * Instanciates and initializes new ProcFSManager objects with some parameters.
     * @param[in] arion The Arion instance used for emulation.
     * @return A new ProcFSManager instance.
     */
    static std::unique_ptr<ProcFSManager> initialize(std::weak_ptr<Arion> arion);
    ProcFSManager(std::weak_ptr<Arion> arion) : arion(arion) {};
    bool is_procfs_path(std::string path);
    std::string convert(std::string path);
};
 
class ARION_EXPORT FileSystemManager
{
  private:
    std::weak_ptr<Arion> arion;
    std::string fs_path;
    std::string cwd_path;
    std::unique_ptr<ProcFSManager> procfs;
    bool can_access_file(std::string path);
 
  public:
    std::map<int, std::shared_ptr<ARION_FILE>> files;
    static std::unique_ptr<FileSystemManager> initialize(std::weak_ptr<Arion> arion, std::string fs_path,
                                                         std::string cwd_path);
    static std::string find_fd_path(int fd);
    FileSystemManager(std::weak_ptr<Arion> arion, std::string fs_path, std::string cwd_path);
    std::string ARION_EXPORT get_fs_path();
    std::string ARION_EXPORT get_cwd_path();
    void ARION_EXPORT set_cwd_path(std::string cwd_path);
    void ARION_EXPORT add_file_entry(int target_fd, std::shared_ptr<ARION_FILE> file, bool safe = true);
    bool ARION_EXPORT has_file_entry(int target_fd);
    void ARION_EXPORT rm_file_entry(int target_fd);
    std::shared_ptr<ARION_FILE> ARION_EXPORT get_arion_file(int target_fd);
    bool ARION_EXPORT is_in_fs(std::string path);
    std::string ARION_EXPORT to_fs_path(std::string path);
};
 
}; // namespace arion
 
#endif // ARION_FS_MANAGER_HPP