fs.hxx

#pragma once
 
// C++
#include <optional>
#include <string_view>
 
// Linux
#include <sys/stat.h>
 
// cosmos
#include <cosmos/fs/DirEntry.hxx>
#include <cosmos/fs/FileStatus.hxx>
#include <cosmos/fs/filesystem.hxx>
#include <cosmos/utils.hxx>
 
// clues
#include <clues/items/fcntl.hxx>
#include <clues/items/items.hxx>
#include <clues/SystemCallItem.hxx>
#include <clues/types.hxx>
 
namespace clues::item {
 
using AtSemantics = cosmos::NamedBool<struct at_semantics_t, false>;

class CLUES_API FileDescriptor :
                public SystemCallItem {
 
public: // functions

        explicit FileDescriptor(const ItemType type = ItemType::PARAM_IN,
                                const AtSemantics at_semantics = AtSemantics{false},
                                const std::string_view short_name = "fd",
                                const std::string_view long_name = "file descriptor") :
                        SystemCallItem{type, short_name, long_name},
                        m_at_semantics{at_semantics} {
        }
 
        std::string str() const override;
 
        auto fd() const {
                return m_fd;
        }


        const std::optional<FDInfo>& info() const {
                return m_info;
        }
 
protected: // functions
 
        void processValue(const Tracee &) override;
 
protected: // data
 
        cosmos::FileNum m_fd;
 
        std::optional<FDInfo> m_info; 
 
        const AtSemantics m_at_semantics = AtSemantics{false};
};

class CLUES_API OpenFlagsValue :
                public SystemCallItem {
public:
        explicit OpenFlagsValue(const ItemType type = ItemType::PARAM_IN) :
                        SystemCallItem{type, "flags", "open flags"} {
        }
 
        std::string str() const override;
 
        cosmos::OpenMode mode() const {
                return m_mode;
        }
 
        cosmos::OpenFlags flags() const {
                return m_flags;
        }
 
protected: // functions
 
        void processValue(const Tracee&) override;
 
protected: // data
 
        cosmos::OpenMode m_mode;
        cosmos::OpenFlags m_flags;
};

class CLUES_API AtFlagsValue :
                public SystemCallItem {
public: // types
 
        enum class AtFlag : int {
                EMPTY_PATH       = AT_EMPTY_PATH,
                SYMLINK_NOFOLLOW = AT_SYMLINK_NOFOLLOW,
                SYMLINK_FOLLOW   = AT_SYMLINK_FOLLOW,
                REMOVEDIR        = AT_REMOVEDIR, 
                EACCESS          = AT_EACCESS, 
                NO_AUTOMOUNT     = AT_NO_AUTOMOUNT, 
        };
 
        using AtFlags = cosmos::BitMask<AtFlag>;
 
public: // functions
 
        AtFlagsValue() :
                        SystemCallItem{ItemType::PARAM_IN, "flags", "*at flags"} {
        }
 
        std::string str() const override;
 
        AtFlags flags() const {
                return m_flags;
        }
 
protected: // functions
 
        void processValue(const Tracee&) override;
 
protected: // data
 
        AtFlags m_flags;
};

class CLUES_API AccessModeParameter :
                public item::ValueInParameter {
public:
        explicit AccessModeParameter() :
                        item::ValueInParameter{"check", "access check"} {
        }
 
        std::string str() const override;
 
        cosmos::fs::AccessChecks checks() const {
                return m_checks;
        }
 
protected: // functions
 
        void processValue(const Tracee&) override;
 
protected: // data
 
        cosmos::fs::AccessChecks m_checks;
};

class CLUES_API FileModeParameter :
                public item::ValueInParameter {
public:
 
        FileModeParameter() :
                        item::ValueInParameter{"mode", "file-mode"} {
        }
 
        std::string str() const override;
 
        auto mode() const {
                return m_mode;
        }
 
protected: // functions
 
        void processValue(const Tracee&) override {
                m_mode = cosmos::FileMode{valueAs<cosmos::ModeT>()};
        }
 
protected: // data
 
        cosmos::FileMode m_mode;
};

class CLUES_API StatParameter :
                public PointerOutValue {
public: // functions
        explicit StatParameter() :
                        PointerOutValue{"stat", "struct stat"} {
        }
 
        std::string str() const override;


        const std::optional<cosmos::FileStatus>& status() const {
                return m_stat;
        }
 
protected: // functions
 
        void processValue(const Tracee &) override {
                m_stat.reset();
        }
 
        void updateData(const Tracee &proc) override;

        bool isOldStat() const;

        bool isStat64() const;

        bool isRegularStat() const;
 
protected: // data
 
        std::optional<cosmos::FileStatus> m_stat;
};

class CLUES_API DirEntries :
                public PointerOutValue {
public: // types
 
        struct Entry {
                uint64_t inode;
                /* for getdents() this is an unsigned type, for getdents64()
                 * it is a signed type. I guess using a signed type (off_t)
                 * makes sense. */
                int64_t offset;
                std::string_view name;
                cosmos::DirEntry::Type type;
        };
 
public: // functions
 
        explicit DirEntries() :
                        PointerOutValue{"dirent", "struct linux_dirent"}
        {}
 
        std::string str() const override;
 
        const auto& entries() const {
                return m_entries;
        }
 
protected: // functions
 
        void processValue(const Tracee &) override {
                m_entries.clear();
                m_buffer.reset();
        }
 
        void updateData(const Tracee &proc) override;


        template <typename DIRENT>
        void parseEntries32(const size_t bytes);

        void parseEntries64(const size_t bytes);
 
protected: // data
 
        std::vector<Entry> m_entries;
        std::unique_ptr<char[]> m_buffer;
};
 
} // end ns