dfhack/library/DFProcess.h

284 lines
11 KiB
C

/*
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
2010-02-26 14:22:10 -07:00
#include "Tranquility.h"
#include "Export.h"
2009-11-13 20:46:56 -07:00
namespace DFHack
{
2009-11-13 20:46:56 -07:00
class memory_info;
class Process;
2009-12-22 14:19:39 -07:00
class DFWindow;
class DfVector;
2009-11-13 20:46:56 -07:00
// 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()
{
cout << hex << start << " - " << end << "|" << (read ? "r" : "-") << (write ? "w" : "-") << (execute ? "x" : "-") << "|" << name << endl;
}
};
class DFHACK_EXPORT Process
2009-12-22 14:19:39 -07:00
{
public:
// this is the single most important destructor ever. ~px
virtual ~Process(){};
// Set up stuff so we can read memory, suspends synchronously
2009-12-22 14:19:39 -07:00
virtual bool attach() = 0;
// detach from DF, resume its execution if it's suspended
2009-12-22 14:19:39 -07:00
virtual bool detach() = 0;
// synchronous suspend
// waits for DF to be actually suspended,
// this might take a while depending on implementation
2009-12-22 14:19:39 -07:00
virtual bool suspend() = 0;
// asynchronous suspend to use together with polling and timers
virtual bool asyncSuspend() = 0;
// resume DF execution
2009-12-22 14:19:39 -07:00
virtual bool resume() = 0;
// force-resume DF execution
2009-12-22 14:19:39 -07:00
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;
2009-12-22 14:19:39 -07:00
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;
2009-12-22 14:19:39 -07:00
// 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;
// read a vector from memory
virtual DfVector readVector (uint32_t offset, uint32_t item_size) = 0;
2010-02-18 18:48:03 -07:00
// get class name of an object with rtti/type info
virtual string readClassName(uint32_t vptr) = 0;
2009-12-22 14:19:39 -07:00
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
2009-12-22 14:19:39 -07:00
virtual bool getThreadIDs(vector<uint32_t> & threads ) = 0;
// get virtual memory ranges of the process (what is mapped where)
2009-12-22 14:19:39 -07:00
virtual void getMemRanges( vector<t_memrange> & ranges ) = 0;
// get the flattened Memory.xml entry of this process
2009-12-22 14:19:39 -07:00
virtual memory_info *getDescriptor() = 0;
// get the DF's window (first that can be found ~_~)
2009-12-22 14:19:39 -07:00
virtual DFWindow * getWindow() = 0;
// get the DF Process ID
2009-12-22 14:19:39 -07:00
virtual int getPID() = 0;
};
class DFHACK_EXPORT NormalProcess : virtual public Process
2009-11-13 20:46:56 -07:00
{
friend class ProcessEnumerator;
class Private;
private:
Private * const d;
public:
NormalProcess(uint32_t pid, vector <memory_info *> & known_versions);
2009-12-22 14:19:39 -07:00
~NormalProcess();
2009-11-13 20:46:56 -07:00
bool attach();
bool detach();
bool suspend();
bool asyncSuspend();
bool resume();
2009-11-18 18:48:18 -07:00
bool forceresume();
2009-12-22 14:19:39 -07:00
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);
2009-12-22 14:19:39 -07:00
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);
2009-12-22 14:19:39 -07:00
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){};
// read a vector from memory
DfVector readVector (uint32_t offset, uint32_t item_size);
2010-02-18 18:48:03 -07:00
// get class name of an object with rtti/type info
string readClassName(uint32_t vptr);
2009-12-22 14:19:39 -07:00
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();
};
class DFHACK_EXPORT SHMProcess : virtual public Process
{
friend class ProcessEnumerator;
class Private;
private:
Private * const d;
public:
SHMProcess(vector <memory_info *> & known_versions);
2009-12-22 14:19:39 -07:00
~SHMProcess();
// Set up stuff so we can read memory
bool attach();
bool detach();
bool suspend();
bool asyncSuspend();
2009-12-22 14:19:39 -07:00
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);
2009-12-22 14:19:39 -07:00
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);
// read a vector from memory
DfVector readVector (uint32_t offset, uint32_t item_size);
2010-02-18 18:48:03 -07:00
// 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();
};
#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);
2009-12-22 14:19:39 -07:00
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);
2009-12-22 14:19:39 -07:00
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){};
// read a vector from memory
DfVector readVector (uint32_t offset, uint32_t item_size);
2010-02-18 18:48:03 -07:00
// get class name of an object with rtti/type info
string readClassName(uint32_t vptr);
2009-12-22 14:19:39 -07:00
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 );
2009-11-13 20:46:56 -07:00
memory_info *getDescriptor();
2009-12-22 14:19:39 -07:00
DFWindow * getWindow();
int getPID();
2009-11-13 20:46:56 -07:00
};
#endif
2009-11-13 20:46:56 -07:00
}
#endif