items.hxx

#pragma once
 
// C++
#include <vector>
 
// clues
#include <clues/SystemCallItem.hxx>
 
/*
 * Various specializations of SystemCallItem are found in this header
 */
 
namespace clues::item {

class ReturnValue :
                public SystemCallItem {
public:
        explicit ReturnValue(const std::string_view short_name, const std::string_view long_name = {}) :
                SystemCallItem{ItemType::RETVAL, short_name, long_name}
        {}
};


class ValueParameter :
                public SystemCallItem {
public: // functions
 
        explicit ValueParameter(
                const ItemType type,
                const std::string_view short_name,
                const std::string_view long_name = {}) :
                        SystemCallItem{type, short_name, long_name} {
        }
};

class ValueInParameter :
                public ValueParameter {
public: // functions
 
        explicit ValueInParameter(
                const std::string_view short_name,
                const std::string_view long_name = {}) :
                        ValueParameter{ItemType::PARAM_IN, short_name, long_name} {
        }
};

class ValueOutParameter :
                public ValueParameter {
public: // functions
 
        explicit ValueOutParameter(
                const std::string_view short_name,
                const std::string_view long_name) :
                        ValueParameter{ItemType::PARAM_OUT, short_name, long_name} {
        }
};


class PointerValue :
                public SystemCallItem {
public: // functions
 
        explicit PointerValue(
                const ItemType type,
                const std::string_view short_name,
                const std::string_view long_name) :
                        SystemCallItem{type, short_name, long_name} {
        }
};


class PointerOutValue :
                public PointerValue {
public: // functions
 
        explicit PointerOutValue(
                const std::string_view short_name,
                const std::string_view long_name = {},
                const ItemType type = ItemType::PARAM_OUT) :
                        PointerValue{type, short_name, long_name} {
        }
};


class PointerInValue :
                public PointerValue {
public: // functions
 
        explicit PointerInValue(
                const std::string_view short_name,
                const std::string_view long_name = {}) :
                        PointerValue{ItemType::PARAM_IN, short_name, long_name} {
        }
};
 
class CLUES_API GenericPointerValue :
                public PointerValue {
public: // functions
 
        explicit GenericPointerValue(
                const std::string_view short_name,
                const std::string_view long_name = {},
                const ItemType type = ItemType::PARAM_IN) :
                        PointerValue{type, short_name, long_name} {
        }
 
        std::string str() const override;
 
        ForeignPtr ptr() const {
                return ForeignPtr{valueAs<uintptr_t>()};
        }
 
protected: // functions
 
        void processValue(const Tracee &) override {}
        void updateData(const Tracee &) override {}
};


class CLUES_API BufferPointer :
                public PointerValue {
public: // functions
 
        explicit BufferPointer(
                const SystemCallItem &size_par,
                const ItemType type,
                const std::string_view short_name,
                const std::string_view long_name = {}) :
                        PointerValue{type, short_name, long_name},
                        m_size_par{size_par} {
                if (type == ItemType::PARAM_IN) {
                        /*
                         * currently needed for write(), but other system
                         * calls might be affected, too.
                         */
                        m_flags.set(Flag::DEFER_FILL);
                }
        }
 
        const auto& data() const {
                return m_data;
        }


        size_t availableBytes() const;
 
        std::string str() const override;
 
protected: // functions
 
        void processValue(const Tracee &) override;
        void updateData(const Tracee &) override;
 
        void fillBuffer(const Tracee &);
 
protected: // data
 
        const SystemCallItem &m_size_par;
        std::vector<uint8_t> m_data;
};


template <typename INT>
class CLUES_API PointerToScalar :
                public PointerValue {
public: // functions
 
        explicit PointerToScalar(
                const std::string_view short_name,
                const std::string_view long_name = {},
                const ItemType type = ItemType::PARAM_OUT) :
                        PointerValue{type, short_name, long_name} {
        }
 
        ForeignPtr pointer() const {
                return m_ptr;
        }
 
        std::optional<INT> value() const {
                return m_val;
        }
 
        std::string str() const override;
 
        void setBase(const Base base) {
                m_base = base;
        }
 
protected: // functions
 
        void processValue(const Tracee &tracee) override {
                m_ptr = valueAs<ForeignPtr>();
 
                if (isIn() || isInOut()) {
                        fetchValue(tracee);
                } else {
                        m_val.reset();
                }
        }
 
        void updateData(const Tracee &tracee) override {
                if (needsUpdate()) {
                        fetchValue(tracee);
                }
        }
 
        void fetchValue(const Tracee &tracee);
 
        virtual std::string scalarToString() const;
 
protected: // data
 
        ForeignPtr m_ptr = ForeignPtr{};
        std::optional<INT> m_val;
        Base m_base = Base::DEC;
};

template <typename INT>
class CLUES_API IntValueT :
                public ValueParameter {
public: // functions
 
        explicit IntValueT(
                const std::string_view short_name,
                const std::string_view long_name = {},
                const ItemType type = ItemType::PARAM_IN) :
                        ValueParameter{type, short_name, long_name} {
        }
 
        INT value() const {
                return m_value;
        }
 
        std::string str() const override;
 
        void setBase(const Base base) {
                m_base = base;
        }
 
protected: // functions
 
        void processValue(const Tracee &) override {
                m_value = valueAs<INT>();
        }
 
protected: // data
 
        INT m_value = 0;
        Base m_base = Base::DEC;
};
 
using IntValue = IntValueT<int>;
using UintValue = IntValueT<unsigned int>;
using Uint32Value = IntValueT<uint32_t>;
using ULongValue = IntValueT<unsigned long>;
using SizeValue = IntValueT<size_t>;
using OffsetValue = IntValueT<off_t>;


CLUES_API extern SystemCallItem unused;
 
inline bool is_unused_par(const SystemCallItem &item) {
        return &item == &unused;
}

struct UnknownItem :
                public ValueInParameter {
 
        UnknownItem() :
                ValueInParameter{"unknown"} {
        }
 
        std::string str() const override {
                return "<yet unsupported system call>";
        }
};
 
} // end ns