ProcessMemory.h

#pragma once

#include "../Include/Winheaders.h"
#include "RPC/RemoteMemory.h"
#include "MemBlock.h"

#include <vector>
#include <list>

namespace blackbone
{

class ProcessMemory : public RemoteMemory
{
public:
    BLACKBONE_API ProcessMemory( class Process* process );
    BLACKBONE_API ~ProcessMemory();

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

    BLACKBONE_API NTSTATUS Free( ptr_t pAddr, size_t size = 0, DWORD freeType = MEM_RELEASE );

    BLACKBONE_API NTSTATUS Query( ptr_t pAddr, PMEMORY_BASIC_INFORMATION64 pInfo );

    BLACKBONE_API NTSTATUS Protect( ptr_t pAddr, size_t size, DWORD flProtect, DWORD *pOld = NULL );

    BLACKBONE_API NTSTATUS Read( ptr_t dwAddress, size_t dwSize, PVOID pResult, bool handleHoles = false );

    BLACKBONE_API NTSTATUS Write( ptr_t pAddress, size_t dwSize, const void* pData );

    template<class T>
    inline T Read( ptr_t dwAddress )
    {
        T res; 
        Read( dwAddress, sizeof(T), &res );
        return res;
    };

    template<class T>
    inline NTSTATUS Read( ptr_t dwAddress, T& result )
    {
        return Read( dwAddress, sizeof( result ), &result );
    };

    template<class T>
    inline NTSTATUS Write( ptr_t dwAddress, const T& data )
    {
        return Write( dwAddress, sizeof(T), &data );
    }

    BLACKBONE_API size_t EnumRegions( std::list<MEMORY_BASIC_INFORMATION64>& results, bool includeFree = false );

    BLACKBONE_API inline class ProcessCore& core() { return _core; }
    BLACKBONE_API inline class Process* process()  { return _process; }

private:
    ProcessMemory( const ProcessMemory& ) = delete;
    ProcessMemory& operator =(const ProcessMemory&) = delete;

private:
    class Process* _process;    // Owning process object
    class ProcessCore& _core;   // Core routines
};

}