MemBlock.h

#pragma once

#include "../Include/Winheaders.h"
#include "../Include/Macro.h"
#include "../Include/Types.h"

#include <stdint.h>
#include <map>
#include <set>

namespace blackbone
{

inline DWORD CastProtection( DWORD prot, bool bDEP )
{
    if (bDEP == true)
    {
        return prot;
    }
    else
    {
        if (prot == PAGE_EXECUTE_READ)
            return PAGE_READONLY;
        else if (prot == PAGE_EXECUTE_READWRITE)
            return PAGE_READWRITE;
        else if (prot == PAGE_EXECUTE_WRITECOPY)
            return PAGE_WRITECOPY;
        else
            return prot;
    }
}

class MemBlock
{
public:

    BLACKBONE_API MemBlock();

    BLACKBONE_API MemBlock( class ProcessMemory* mem, ptr_t ptr, bool own = true );

    BLACKBONE_API MemBlock( class ProcessMemory* mem, ptr_t ptr, 
                            size_t size, DWORD prot, bool own = true, 
                            bool physical = false );

    BLACKBONE_API ~MemBlock();

    BLACKBONE_API static MemBlock Allocate( class ProcessMemory& process, size_t size, ptr_t desired = 0, DWORD protection = PAGE_EXECUTE_READWRITE );

    BLACKBONE_API ptr_t Realloc( size_t size, ptr_t desired = 0, DWORD protection = PAGE_EXECUTE_READWRITE );

    BLACKBONE_API NTSTATUS Protect( DWORD protection, size_t offset = 0, size_t size = 0, DWORD* pOld = nullptr );

    BLACKBONE_API NTSTATUS Free( size_t size = 0 );

    BLACKBONE_API NTSTATUS Read( size_t offset, size_t size, PVOID pResult, bool handleHoles = false );

    BLACKBONE_API NTSTATUS Write( size_t offset, size_t size, const void* pData );

    template<class T>
    T Read( size_t offset, const T& def_val )
    {
        T res = def_val;
        Read( offset, sizeof(T), &res );
        return res;
    };

    template<class T>
    NTSTATUS Write( size_t offset, const T& data )
    {
        return Write( offset, sizeof(T), &data );
    }

    BLACKBONE_API void Reset();

    BLACKBONE_API inline void Release() { _own = false; }

    template< typename T = ptr_t >
    inline T ptr() const { return (T)_ptr; }

    BLACKBONE_API inline size_t size() const { return _size; }

    BLACKBONE_API inline DWORD  protection() const { return _protection; }

    BLACKBONE_API inline bool valid() const { return (_memory != nullptr && _ptr != 0); }

    BLACKBONE_API inline operator ptr_t() const  { return _ptr; }

    BLACKBONE_API MemBlock& operator =(const MemBlock& other)
    {
        _memory = other._memory;
        _ptr = other._ptr;
        _size = other._size;
        _protection = other._protection;
        _own = true;

        // Transfer memory ownership
        const_cast<MemBlock&>(other).Release();

        return *this;
    }

private:
    ptr_t  _ptr = 0;                // Raw memory pointer
    size_t _size = 0;               // Region size
    DWORD  _protection = 0;         // Region protection
    bool   _own = true;             // Memory will be freed in destructor
    bool   _physical = false;       // Memory allocated as direct physical
    class ProcessMemory* _memory;   // Target process routines
};

}