/*

www.sourceforge.net/projects/dfhack

Copyright (c) 2009 Petr Mrázek (peterix), Kenneth Ferland (Impaler[WrG]), dorf

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any

damages arising from the use of this software.

Permission is granted to anyone to use this software for any

purpose, including commercial applications, and to alter it and

redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must

not claim that you wrote the original software. If you use this

software in a product, an acknowledgment in the product documentation

would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and

must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source

distribution.

*/

#ifndef PROCESS_H_INCLUDED

#define PROCESS_H_INCLUDED

#include "Tranquility.h"

#include "Export.h"

#include <iostream>

namespace DFHack

{

class memory_info;

class Process;

class DFWindow;

class DfVector;

// structure describing a memory range

struct DFHACK_EXPORT t_memrange

{

uint64_t start;

uint64_t end;

// memory range name (if any)

char name[1024];

// permission to read

bool read;

// permission to write

bool write;

// permission to execute

bool execute;

inline bool isInRange( uint64_t address)

{

if (address >= start && address <= end) return true;

return false;

}

inline void print()

{

std::cout << std::hex << start << " - " << end << "|" << (read ? "r" : "-") << (write ? "w" : "-") << (execute ? "x" : "-") << "|" << name << std::endl;

}

};

class DFHACK_EXPORT Process

{

public:

// this is the single most important destructor ever. ~px

virtual ~Process(){};

// Set up stuff so we can read memory, suspends synchronously

virtual bool attach() = 0;

// detach from DF, resume its execution if it's suspended

virtual bool detach() = 0;

// synchronous suspend

// waits for DF to be actually suspended,

// this might take a while depending on implementation

virtual bool suspend() = 0;

// asynchronous suspend to use together with polling and timers

virtual bool asyncSuspend() = 0;

// resume DF execution

virtual bool resume() = 0;

// force-resume DF execution

virtual bool forceresume() = 0;

virtual uint32_t readDWord(const uint32_t address) = 0;

virtual void readDWord(const uint32_t address, uint32_t & value) = 0;

virtual uint16_t readWord(const uint32_t address) = 0;

virtual void readWord(const uint32_t address, uint16_t & value) = 0;

virtual uint8_t readByte(const uint32_t address) = 0;

virtual void readByte(const uint32_t address, uint8_t & value) = 0;

virtual void read( uint32_t address, uint32_t length, uint8_t* buffer) = 0;

virtual void writeDWord(const uint32_t address, const uint32_t value) = 0;

virtual void writeWord(const uint32_t address, const uint16_t value) = 0;

virtual void writeByte(const uint32_t address, const uint8_t value) = 0;

virtual void write(uint32_t address, uint32_t length, uint8_t* buffer) = 0;

// read a string

virtual const string readSTLString (uint32_t offset) = 0;

virtual size_t readSTLString (uint32_t offset, char * buffer, size_t bufcapacity) = 0;

virtual void writeSTLString(const uint32_t address, const std::string writeString) = 0;

// get class name of an object with rtti/type info

virtual string readClassName(uint32_t vptr) = 0;

virtual const std::string readCString (uint32_t offset) = 0;

virtual bool isSuspended() = 0;

virtual bool isAttached() = 0;

virtual bool isIdentified() = 0;

// find the thread IDs of the process

virtual bool getThreadIDs(vector<uint32_t> & threads ) = 0;

// get virtual memory ranges of the process (what is mapped where)

virtual void getMemRanges( vector<t_memrange> & ranges ) = 0;

// get the flattened Memory.xml entry of this process

virtual memory_info *getDescriptor() = 0;

// get the DF's window (first that can be found ~_~)

virtual DFWindow * getWindow() = 0;

// get the DF Process ID

virtual int getPID() = 0;

// get module index by name and version. bool 1 = error

virtual bool getModuleIndex (const char * name, const uint32_t version, uint32_t & OUTPUT) = 0;

// get the SHM start if available

virtual char * getSHMStart (void) = 0;

// set a SHM command and wait for a response, return 0 on error or throw exception

virtual bool SetAndWait (uint32_t state) = 0;

/*

// wait while SHM command == state. returns 0 without the SHM

virtual bool waitWhile (uint32_t state) = 0;

// set SHM command.

virtual void setCmd (uint32_t newstate) = 0;

*/

};

class DFHACK_EXPORT NormalProcess : virtual public Process

{

friend class ProcessEnumerator;

class Private;

private:

Private * const d;

public:

NormalProcess(uint32_t pid, vector <memory_info *> & known_versions);

~NormalProcess();

bool attach();

bool detach();

bool suspend();

bool asyncSuspend();

bool resume();

bool forceresume();

uint32_t readDWord(const uint32_t address);

void readDWord(const uint32_t address, uint32_t & value);

uint16_t readWord(const uint32_t address);

void readWord(const uint32_t address, uint16_t & value);

uint8_t readByte(const uint32_t address);

void readByte(const uint32_t address, uint8_t & value);

void read( uint32_t address, uint32_t length, uint8_t* buffer);

void writeDWord(const uint32_t address, const uint32_t value);

void writeWord(const uint32_t address, const uint16_t value);

void writeByte(const uint32_t address, const uint8_t value);

void write(uint32_t address, uint32_t length, uint8_t* buffer);

const string readSTLString (uint32_t offset);

size_t readSTLString (uint32_t offset, char * buffer, size_t bufcapacity);

void writeSTLString(const uint32_t address, const std::string writeString){};

// get class name of an object with rtti/type info

string readClassName(uint32_t vptr);

const std::string readCString (uint32_t offset);

bool isSuspended();

bool isAttached();

bool isIdentified();

bool getThreadIDs(vector<uint32_t> & threads );

void getMemRanges( vector<t_memrange> & ranges );

memory_info *getDescriptor();

DFWindow * getWindow();

int getPID();

// get module index by name and version. bool 1 = error

bool getModuleIndex (const char * name, const uint32_t version, uint32_t & OUTPUT) { OUTPUT=0; return false;};

// get the SHM start if available

char * getSHMStart (void){return 0;};

// set a SHM command and wait for a response

bool SetAndWait (uint32_t state){return false;};

/*

// wait for a SHM state. returns 0 without the SHM

bool waitWhile (uint32_t state){return false;};

// set SHM command.

void setCmd (uint32_t newstate){};

*/

};

class DFHACK_EXPORT SHMProcess : virtual public Process

{

friend class ProcessEnumerator;

class Private;

private:

Private * const d;

public:

SHMProcess(uint32_t PID, vector <memory_info *> & known_versions);

~SHMProcess();

// Set up stuff so we can read memory

bool attach();

bool detach();

bool suspend();

bool asyncSuspend();

bool resume();

bool forceresume();

uint32_t readDWord(const uint32_t address);

void readDWord(const uint32_t address, uint32_t & value);

uint16_t readWord(const uint32_t address);

void readWord(const uint32_t address, uint16_t & value);

uint8_t readByte(const uint32_t address);

void readByte(const uint32_t address, uint8_t & value);

void read( uint32_t address, uint32_t length, uint8_t* buffer);

void writeDWord(const uint32_t address, const uint32_t value);

void writeWord(const uint32_t address, const uint16_t value);

void writeByte(const uint32_t address, const uint8_t value);

void write(uint32_t address, uint32_t length, uint8_t* buffer);

const string readSTLString (uint32_t offset);

size_t readSTLString (uint32_t offset, char * buffer, size_t bufcapacity);

void writeSTLString(const uint32_t address, const std::string writeString);

// get class name of an object with rtti/type info

string readClassName(uint32_t vptr);

const std::string readCString (uint32_t offset);

bool isSuspended();

bool isAttached();

bool isIdentified();

bool getThreadIDs(vector<uint32_t> & threads );

void getMemRanges( vector<t_memrange> & ranges );

memory_info *getDescriptor();

DFWindow * getWindow();

int getPID();

// get module index by name and version. bool 1 = error

bool getModuleIndex (const char * name, const uint32_t version, uint32_t & OUTPUT);

// get the SHM start if available

char * getSHMStart (void);

bool SetAndWait (uint32_t state);

/*

// wait for a SHM state. returns 0 without the SHM

bool waitWhile (uint32_t state);

// set SHM command.

void setCmd (uint32_t newstate);

*/

};

#ifdef LINUX_BUILD

class DFHACK_EXPORT WineProcess : virtual public Process

{

friend class ProcessEnumerator;

class Private;

private:

Private * const d;

public:

WineProcess(uint32_t pid, vector <memory_info *> & known_versions);

~WineProcess();

bool attach();

bool detach();

bool suspend();

bool asyncSuspend();

bool resume();

bool forceresume();

uint32_t readDWord(const uint32_t address);

void readDWord(const uint32_t address, uint32_t & value);

uint16_t readWord(const uint32_t address);

void readWord(const uint32_t address, uint16_t & value);

uint8_t readByte(const uint32_t address);

void readByte(const uint32_t address, uint8_t & value);

void read( uint32_t address, uint32_t length, uint8_t* buffer);

void writeDWord(const uint32_t address, const uint32_t value);

void writeWord(const uint32_t address, const uint16_t value);

void writeByte(const uint32_t address, const uint8_t value);

void write(uint32_t address, uint32_t length, uint8_t* buffer);

const string readSTLString (uint32_t offset);

size_t readSTLString (uint32_t offset, char * buffer, size_t bufcapacity);

void writeSTLString(const uint32_t address, const std::string writeString){};

// get class name of an object with rtti/type info

string readClassName(uint32_t vptr);

const std::string readCString (uint32_t offset);

bool isSuspended();

bool isAttached();

bool isIdentified();

bool getThreadIDs(vector<uint32_t> & threads );

void getMemRanges( vector<t_memrange> & ranges );

memory_info *getDescriptor();

DFWindow * getWindow();

int getPID();

// get module index by name and version. bool 1 = error

bool getModuleIndex (const char * name, const uint32_t version, uint32_t & OUTPUT) {OUTPUT=0; return false;};

// get the SHM start if available

char * getSHMStart (void){return 0;};

bool SetAndWait (uint32_t state){return false;};

/*

// wait for a SHM state. returns 0 without the SHM

bool waitWhile (uint32_t state){return false;};

// set SHM command.

void setCmd (uint32_t newstate){};

*/

};

#endif

}

#endif