KittyMemOp.hpp

#pragma once
 
#include "KittyUtils.hpp"
#include "KittyIOFile.hpp"

enum EKittyMemOP
{
    EK_MEM_OP_NONE = 0,
    EK_MEM_OP_SYSCALL,
    EK_MEM_OP_IO
};

enum class MemMode
{
    Normal,
 

    SkipInaccessiblePages
};

class IKittyMemOp
{
protected:
    pid_t _pid;
    int _lastErrno;
 
public:
    IKittyMemOp() : _pid(0)
    {
    }
    virtual ~IKittyMemOp() = default;

    virtual bool init(pid_t pid) = 0;

    inline pid_t processID() const
    {
        return _pid;
    }

    virtual size_t Read(uintptr_t address, void *buffer, size_t len, MemMode mode = MemMode::Normal) = 0;

    virtual size_t Write(uintptr_t address, void *buffer, size_t len, MemMode mode = MemMode::Normal) = 0;

    inline int lastErrno() const
    {
        return _lastErrno;
    }

    std::string ReadUTF8(uintptr_t address, size_t maxLen);

    std::u16string ReadUTF16(uintptr_t address, size_t maxLen);

    std::u32string ReadUTF32(uintptr_t address, size_t maxLen);

    std::wstring ReadWStr(uintptr_t address, size_t maxLen)
    {
        if constexpr (sizeof(wchar_t) == 2)
        {
            auto str = ReadUTF16(address, maxLen * sizeof(wchar_t));
            return std::wstring(reinterpret_cast<const wchar_t *>(str.data()), str.size());
        }
        else
        {
            auto str = ReadUTF32(address, maxLen * sizeof(wchar_t));
            return std::wstring(reinterpret_cast<const wchar_t *>(str.data()), str.size());
        }
    }

    inline std::string ReadStr(uintptr_t address, size_t maxLen)
    {
        return ReadUTF8(address, maxLen);
    }

    inline bool WriteStr(uintptr_t address, std::string str)
    {
        const size_t len = str.size() + 1;
        return Write(address, &str[0], len) == len;
    }

    inline bool WriteWStr(uintptr_t address, std::wstring str)
    {
        const size_t len = (str.size() + 1) * sizeof(wchar_t);
        return Write(address, &str[0], len) == len;
    }
};

class KittyMemSys : public IKittyMemOp
{
public:
    bool init(pid_t pid);

    size_t Read(uintptr_t address, void *buffer, size_t len, MemMode mode = MemMode::Normal);

    size_t Write(uintptr_t address, void *buffer, size_t len, MemMode mode = MemMode::Normal);
};

class KittyMemIO : public IKittyMemOp
{
private:
    std::unique_ptr<KittyIOFile> _pMem;
 
public:
    bool init(pid_t pid);

    size_t Read(uintptr_t address, void *buffer, size_t len, MemMode mode = MemMode::Normal);
 

    size_t Write(uintptr_t address, void *buffer, size_t len, MemMode mode = MemMode::Normal);
};