#include <RMonoAPI_Def.h>

Inheritance diagram for remotemono::RMonoAPI:

Collaboration diagram for remotemono::RMonoAPI:

[legend]

Public Member Functions
void	free (rmono_voidp p)

General
	RMonoAPI (blackbone::Process &process)

virtual	~RMonoAPI ()

void	attach ()

void	detach ()

bool	isAttached () const

bool	isAPIFunctionSupported (const std::string &name) const

Mono API - JIT Functions
RMonoDomainPtr	jitInit (const std::string_view &filename)

void	jitCleanup (RMonoDomainPtr domain)

Mono API - Domains
RMonoDomainPtr	getRootDomain ()

bool	domainSet (RMonoDomainPtr domain, bool force)

RMonoDomainPtr	domainGet ()

std::vector< RMonoDomainPtr >	domainList ()

RMonoDomainPtr	domainCreateAppdomain (const std::string_view &friendlyName, const std::string_view &configFile=std::string_view())

RMonoAssemblyPtr	domainAssemblyOpen (RMonoDomainPtr domain, const std::string_view &name)

void	domainUnload (RMonoDomainPtr domain)

std::string	domainGetFriendlyName (RMonoDomainPtr domain)

Mono API - Threads
RMonoThreadPtr	threadAttach (RMonoDomainPtr domain)

void	threadDetach (RMonoThreadPtr thread)

Mono API - Assemblies
void	assemblyClose (RMonoAssemblyPtr assembly)

std::vector< RMonoAssemblyPtr >	assemblyList ()

RMonoImagePtr	assemblyGetImage (RMonoAssemblyPtr assembly)

RMonoAssemblyNamePtr	assemblyGetName (RMonoAssemblyPtr assembly)

RMonoAssemblyNamePtr	assemblyNameNew (const std::string_view &name)

bool	assemblyNameParse (const std::string_view &name, RMonoAssemblyNamePtr aname)

void	assemblyNameFree (RMonoAssemblyNamePtrRaw name)

std::string	assemblyNameGetName (RMonoAssemblyNamePtr assembly)

std::string	assemblyNameGetCulture (RMonoAssemblyNamePtr assembly)

uint16_t	assemblyNameGetVersion (RMonoAssemblyNamePtr assembly, uint16_t minor, uint16_t build, uint16_t *revision)

std::string	stringifyAssemblyName (RMonoAssemblyNamePtr assembly)

std::string	assemblyNameStringify (RMonoAssemblyNamePtr assembly)

RMonoAssemblyPtr	assemblyLoaded (RMonoAssemblyNamePtr name)

RMonoAssemblyPtr	assemblyLoaded (const std::string_view &name)

Mono API - Images
std::string	imageGetName (RMonoImagePtr image)

std::string	imageGetFilename (RMonoImagePtr image)

RMonoTableInfoPtr	imageGetTableInfo (RMonoImagePtr image, rmono_int tableID)

rmono_int	tableInfoGetRows (RMonoTableInfoPtr table)

rmono_voidp	imageRVAMap (RMonoImagePtr image, uint32_t addr)

Mono API - Metadata Tables
uint32_t	metadataDecodeRowCol (RMonoTableInfoPtr table, rmono_int idx, rmono_uint col)

rmono_voidp	metadataGuidHeap (RMonoImagePtr image, uint32_t idx, uint8_t *outGuid=nullptr)

std::string	metadataStringHeap (RMonoImagePtr image, uint32_t idx)

rmono_voidp	metadataStringHeapRaw (RMonoImagePtr image, uint32_t idx)

rmono_voidp	metadataBlobHeap (RMonoImagePtr image, uint32_t idx)

std::string	metadataUserString (RMonoImagePtr image, uint32_t idx)

rmono_voidp	metadataUserStringRaw (RMonoImagePtr image, uint32_t idx)

uint32_t	metadataDecodeBlobSize (rmono_voidp blobPtr, rmono_voidp *outBlobPtr)

Mono API - Standard Classes
RMonoClassPtr	getObjectClass ()

RMonoClassPtr	getInt16Class ()

RMonoClassPtr	getInt32Class ()

RMonoClassPtr	getInt64Class ()

RMonoClassPtr	getDoubleClass ()

RMonoClassPtr	getSingleClass ()

RMonoClassPtr	getStringClass ()

RMonoClassPtr	getThreadClass ()

RMonoClassPtr	getUInt16Class ()

RMonoClassPtr	getUInt32Class ()

RMonoClassPtr	getUInt64Class ()

RMonoClassPtr	getVoidClass ()

RMonoClassPtr	getArrayClass ()

RMonoClassPtr	getBooleanClass ()

RMonoClassPtr	getByteClass ()

RMonoClassPtr	getSByteClass ()

RMonoClassPtr	getCharClass ()

RMonoClassPtr	getExceptionClass ()

Mono API - Classes
RMonoVTablePtr	classVTable (RMonoDomainPtr domain, RMonoClassPtr cls)

RMonoVTablePtr	classVTable (RMonoClassPtr cls)

void	runtimeClassInit (RMonoVTablePtr vtable)

RMonoClassPtr	classGetParent (RMonoClassPtr cls)

RMonoTypePtr	classGetType (RMonoClassPtr cls)

RMonoClassPtr	classFromName (RMonoImagePtr image, const std::string_view &nameSpace, const std::string_view &name)

RMonoClassPtr	classFromMonoType (RMonoTypePtr type)

std::string	classGetName (RMonoClassPtr cls)

std::string	classGetNamespace (RMonoClassPtr cls)

std::vector< RMonoClassFieldPtr >	classGetFields (RMonoClassPtr cls)

std::vector< RMonoMethodPtr >	classGetMethods (RMonoClassPtr cls)

std::vector< RMonoPropertyPtr >	classGetProperties (RMonoClassPtr cls)

RMonoClassFieldPtr	classGetFieldFromName (RMonoClassPtr cls, const std::string_view &name)

RMonoMethodPtr	classGetMethodFromName (RMonoClassPtr cls, const std::string_view &name, int32_t paramCount=-1)

RMonoPropertyPtr	classGetPropertyFromName (RMonoClassPtr cls, const std::string_view &name)

RMonoClassPtr	classGetElementClass (RMonoClassPtr cls)

uint32_t	classGetFlags (RMonoClassPtr cls)

rmono_int	classGetRank (RMonoClassPtr cls)

bool	classIsValueType (RMonoClassPtr cls)

uint32_t	classDataSize (RMonoClassPtr cls)

uint32_t	classInstanceSize (RMonoClassPtr cls)

int32_t	classValueSize (RMonoClassPtr cls, uint32_t *align=nullptr)

Mono API - Types
RMonoReflectionTypePtr	typeGetObject (RMonoDomainPtr domain, RMonoTypePtr type)

RMonoReflectionTypePtr	typeGetObject (RMonoTypePtr type)

std::string	typeGetName (RMonoTypePtr type)

RMonoClassPtr	typeGetClass (RMonoTypePtr type)

rmono_int	typeGetType (RMonoTypePtr type)

bool	typeIsByRef (RMonoTypePtr type)

bool	typeIsPointer (RMonoTypePtr type)

bool	typeIsReference (RMonoTypePtr type)

bool	typeIsStruct (RMonoTypePtr type)

bool	typeIsVoid (RMonoTypePtr type)

rmono_int	typeSize (RMonoTypePtr type, rmono_int *align=nullptr)

rmono_int	typeStackSize (RMonoTypePtr type, rmono_int *align=nullptr)

Mono API - Fields
RMonoClassPtr	fieldGetParent (RMonoClassFieldPtr field)

RMonoTypePtr	fieldGetType (RMonoClassFieldPtr field)

std::string	fieldGetName (RMonoClassFieldPtr field)

uint32_t	fieldGetFlags (RMonoClassFieldPtr field)

void	fieldSetValue (RMonoObjectPtr obj, RMonoClassFieldPtr field, const RMonoVariant &val)

void	fieldGetValue (RMonoObjectPtr obj, RMonoClassFieldPtr field, RMonoVariant &val)

void	fieldGetValue (RMonoObjectPtr obj, RMonoClassFieldPtr field, RMonoVariant &&val)

template<typename T >
T	fieldGetValue (RMonoObjectPtr obj, RMonoClassFieldPtr field)

RMonoObjectPtr	fieldGetValueObject (RMonoDomainPtr domain, RMonoClassFieldPtr field, RMonoObjectPtr obj=nullptr)

RMonoObjectPtr	fieldGetValueObject (RMonoClassFieldPtr field, RMonoObjectPtr obj=nullptr)

void	fieldStaticSetValue (RMonoVTablePtr vtable, RMonoClassFieldPtr field, const RMonoVariant &val)

void	fieldStaticGetValue (RMonoVTablePtr vtable, RMonoClassFieldPtr field, RMonoVariant &val)

void	fieldStaticGetValue (RMonoVTablePtr vtable, RMonoClassFieldPtr field, RMonoVariant &&val)

template<typename T >
T	fieldStaticGetValue (RMonoVTablePtr vtable, RMonoClassFieldPtr field)

uint32_t	fieldGetOffset (RMonoClassFieldPtr field)

Mono API - Methods
RMonoClassPtr	methodGetClass (RMonoMethodPtr method)

std::string	methodGetName (RMonoMethodPtr method)

std::string	methodFullName (RMonoMethodPtr method, bool signature)

uint32_t	methodGetFlags (RMonoMethodPtr method, uint32_t *iflags=nullptr)

RMonoMethodSignaturePtr	methodSignature (RMonoMethodPtr method)

RMonoMethodHeaderPtr	methodGetHeader (RMonoMethodPtr method)

rmono_voidp	methodHeaderGetCode (RMonoMethodHeaderPtr header, uint32_t codeSize, uint32_t maxStack)

RMonoMethodDescPtr	methodDescNew (const std::string_view &name, bool includeNamespace)

void	methodDescFree (RMonoMethodDescPtrRaw desc)

bool	methodDescMatch (RMonoMethodDescPtr desc, RMonoMethodPtr method)

RMonoMethodPtr	methodDescSearchInClass (RMonoMethodDescPtr desc, RMonoClassPtr cls)

RMonoMethodPtr	methodDescSearchInClass (const std::string_view &desc, bool includeNamespace, RMonoClassPtr cls)

RMonoMethodPtr	methodDescSearchInImage (RMonoMethodDescPtr desc, RMonoImagePtr image)

RMonoMethodPtr	methodDescSearchInImage (const std::string_view &desc, bool includeNamespace, RMonoImagePtr image)

RMonoObjectPtr	runtimeInvoke (RMonoMethodPtr method, const RMonoVariant &obj, RMonoVariantArray &params, bool catchExceptions=true)

RMonoObjectPtr	runtimeInvoke (RMonoMethodPtr method, const RMonoVariant &obj=nullptr, RMonoVariantArray &&params=RMonoVariantArray(), bool catchExceptions=true)

rmono_voidp	compileMethod (RMonoMethodPtr method)

Mono API - Properties
std::string	propertyGetName (RMonoPropertyPtr prop)

uint32_t	propertyGetFlags (RMonoPropertyPtr prop)

RMonoClassPtr	propertyGetParent (RMonoPropertyPtr prop)

RMonoMethodPtr	propertyGetSetMethod (RMonoPropertyPtr prop)

RMonoMethodPtr	propertyGetGetMethod (RMonoPropertyPtr prop)

RMonoObjectPtr	propertyGetValue (RMonoPropertyPtr prop, const RMonoVariant &obj, RMonoVariantArray &params, bool catchExceptions=true)

RMonoObjectPtr	propertyGetValue (RMonoPropertyPtr prop, const RMonoVariant &obj=nullptr, RMonoVariantArray &&params=RMonoVariantArray(), bool catchExceptions=true)

void	propertySetValue (RMonoPropertyPtr prop, const RMonoVariant &obj, RMonoVariantArray &params, bool catchExceptions=true)

void	propertySetValue (RMonoPropertyPtr prop, const RMonoVariant &obj=nullptr, RMonoVariantArray &&params=RMonoVariantArray(), bool catchExceptions=true)

Mono API - Method Signatures
RMonoTypePtr	signatureGetReturnType (RMonoMethodSignaturePtr sig)

uint32_t	signatureGetCallConv (RMonoMethodSignaturePtr sig)

std::string	signatureGetDesc (RMonoMethodSignaturePtr sig, bool includeNamespace)

std::vector< RMonoTypePtr >	signatureGetParams (RMonoMethodSignaturePtr sig)

Mono API - Objects
RMonoClassPtr	objectGetClass (RMonoObjectPtr obj)

RMonoObjectPtr	objectNew (RMonoDomainPtr domain, RMonoClassPtr cls)

RMonoObjectPtr	objectNew (RMonoClassPtr cls)

void	runtimeObjectInit (const RMonoVariant &obj)

template<typename T >
T	objectUnbox (RMonoObjectPtr obj)

RMonoVariant	objectUnboxRaw (RMonoObjectPtr obj)

RMonoObjectPtr	valueBox (RMonoDomainPtr domain, RMonoClassPtr cls, const RMonoVariant &val)

RMonoObjectPtr	valueBox (RMonoClassPtr cls, const RMonoVariant &val)

RMonoStringPtr	objectToString (const RMonoVariant &obj, bool catchExceptions=true)

RMonoObjectPtr	objectClone (RMonoObjectPtr obj)

RMonoDomainPtr	objectGetDomain (RMonoObjectPtr obj)

RMonoMethodPtr	objectGetVirtualMethod (RMonoObjectPtr obj, RMonoMethodPtr method)

RMonoObjectPtr	objectIsInst (RMonoObjectPtr obj, RMonoClassPtr cls)

rmono_uint	objectGetSize (RMonoObjectPtr obj)

Mono API - Strings
RMonoStringPtr	stringNew (RMonoDomainPtr domain, const std::string_view &str)

RMonoStringPtr	stringNew (const std::string_view &str)

RMonoStringPtr	stringNewUTF16 (RMonoDomainPtr domain, const std::u16string_view &str)

RMonoStringPtr	stringNewUTF16 (const std::u16string_view &str)

RMonoStringPtr	stringNewUTF32 (RMonoDomainPtr domain, const std::u32string_view &str)

RMonoStringPtr	stringNewUTF32 (const std::u32string_view &str)

std::string	stringToUTF8 (RMonoStringPtr str)

std::u16string	stringToUTF16 (RMonoStringPtr str)

std::u32string	stringToUTF32 (RMonoStringPtr str)

std::u16string	stringChars (RMonoStringPtr str)

int32_t	stringLength (RMonoStringPtr str)

bool	stringEqual (RMonoStringPtr a, RMonoStringPtr b)

Mono API - Arrays
RMonoArrayPtr	arrayNew (RMonoDomainPtr domain, RMonoClassPtr cls, rmono_uintptr_t n)

RMonoArrayPtr	arrayNew (RMonoClassPtr cls, rmono_uintptr_t n)

RMonoArrayPtr	arrayNewFull (RMonoDomainPtr domain, RMonoClassPtr cls, const std::vector< rmono_uintptr_t > &lengths, const std::vector< rmono_intptr_t > &lowerBounds={})

RMonoArrayPtr	arrayNewFull (RMonoClassPtr cls, const std::vector< rmono_uintptr_t > &lengths, const std::vector< rmono_intptr_t > &lowerBounds={})

RMonoClassPtr	arrayClassGet (RMonoClassPtr cls, uint32_t rank)

rmono_voidp	arrayAddrWithSize (RMonoArrayPtr arr, rmono_int size, rmono_uintptr_t idx)

rmono_uintptr_t	arrayLength (RMonoArrayPtr arr)

int32_t	arrayElementSize (RMonoClassPtr cls)

int32_t	classArrayElementSize (RMonoClassPtr cls)

RMonoArrayPtr	arrayClone (RMonoArrayPtr arr)

template<typename T >
T	arrayGet (RMonoArrayPtr arr, rmono_uintptr_t idx)

void	arraySet (RMonoArrayPtr arr, rmono_uintptr_t idx, const RMonoVariant &val)

Mono API - GC Handles
rmono_gchandle	gchandleNew (RMonoObjectPtr obj, bool pinned)

rmono_gchandle	gchandleNewRaw (RMonoObjectPtrRaw obj, bool pinned)

rmono_gchandle	gchandleNewWeakref (RMonoObjectPtr obj, bool trackResurrection)

rmono_gchandle	gchandleNewWeakrefRaw (RMonoObjectPtrRaw obj, bool trackResurrection)

RMonoObjectPtrRaw	gchandleGetTarget (rmono_gchandle gchandle)

void	gchandleFree (rmono_gchandle gchandle)

Mono API - Garbage Collector (GC)
void	gcCollect (rmono_int generation)

rmono_int	gcMaxGeneration ()

rmono_int	gcGetGeneration (RMonoObjectPtr obj)

Mono API - JIT Info
RMonoJitInfoPtr	jitInfoTableFind (RMonoDomainPtr domain, rmono_voidp addr)

RMonoJitInfoPtr	jitInfoTableFind (rmono_voidp addr)

rmono_voidp	jitInfoGetCodeStart (RMonoJitInfoPtr jinfo)

int32_t	jitInfoGetCodeSize (RMonoJitInfoPtr jinfo)

RMonoMethodPtr	jitInfoGetMethod (RMonoJitInfoPtr jinfo)

Mono API - Miscellaneous
std::string	disasmCode (RMonoDisHelperPtr helper, RMonoMethodPtr method, rmono_voidp ip, rmono_voidp end)

Utilities
std::vector< RMonoClassPtr >	listClasses (RMonoImagePtr image)

std::string	objectToStringUTF8 (RMonoObjectPtr obj, bool catchExceptions=true)

template<typename T >
std::vector< T >	arrayAsVector (RMonoArrayPtr arr)

template<typename T >
RMonoArrayPtr	arrayFromVector (RMonoDomainPtr domain, RMonoClassPtr cls, const std::vector< T > &vec)

template<typename T >
RMonoArrayPtr	arrayFromVector (RMonoClassPtr cls, const std::vector< T > &vec)

rmono_gchandle	gchandlePin (rmono_gchandle gchandle)

Public Member Functions inherited from remotemono::RMonoAPIBase
HandleBackendIterator	registerMonoHandleBackend (RMonoHandleBackendBase *backend)

void	unregisterMonoHandleBackend (HandleBackendIterator backendIt)

size_t	getRegisteredHandleCount () const

RMonoAPIDispatcher *	getAPIDispatcher ()

blackbone::Process &	getProcess ()

blackbone::ThreadPtr	getWorkerThread ()

Additional Inherited Members
Public Types inherited from remotemono::RMonoAPIBase
typedef std::list< RMonoHandleBackendBase * >	HandleBackendList

typedef HandleBackendList::iterator	HandleBackendIterator

Protected Member Functions inherited from remotemono::RMonoAPIBase
	RMonoAPIBase (blackbone::Process &process)

Protected Attributes inherited from remotemono::RMonoAPIBase
RMonoAPIDispatcher *	apid

HandleBackendList	registeredHandles

blackbone::Process &	process

blackbone::ThreadPtr	worker

Detailed Description

This class provides the main public interface to the Mono API of a remote process. It is probably the class you're most interested in when using RemoteMono.

Before you can call any of the API wrapper methods provided by this class, you have to attach it to the remote process by calling attach().

Most of the methods provided by this class are simply convenience wrappers around the functions defined in RMonoAPIBackend. This class uses RMonoAPIDispatcher to choose the backend that corresponds to the ABI that has been selected for the remote process. If you want to call raw Mono API functions, or call them without the wrapping provided by this class, you can use getAPIDispatcher() to get direct access to the RMonoAPIFunction instances.

Most methods in here are not documented, because they simply call the corresponding Mono API functions in the remote process. See the original Mono Embedded API documentation for details on what these functions do.

Constructor & Destructor Documentation

◆ RMonoAPI()

remotemono::RMonoAPI::RMonoAPI ( blackbone::Process & process )

inline

Create a new RMonoAPI for the given remote process. Note that this function does not attach to the remote. You need to call attach() afterwards before using the Mono API functions.

◆ ~RMonoAPI()

remotemono::RMonoAPI::~RMonoAPI ( )

inlinevirtual

Destroy the RMonoAPI, automatically calling detach() if it was attached before.

Member Function Documentation

◆ arrayAsVector()

template<typename T >

std::vector< T > remotemono::RMonoAPI::arrayAsVector ( RMonoArrayPtr arr )

Converts the given MonoArray to a local std::vector. Can be used for both value types (e.g. arrayAsVector<int32_t>(arr)) and reference types (e.g. arrayAsVector<RMonoObjectPtr>(arr)). Note that this will always return a flat vector, even for multidimensional arrays.

◆ arrayFromVector() [1/2]

template<typename T >

RMonoArrayPtr remotemono::RMonoAPI::arrayFromVector	(	RMonoClassPtr	cls,
		const std::vector< T > &	vec
	)

Creates a new MonoArray from the values in the given std::vector. Can be used for both value types (e.g. arrayFromVector<int32_t>(getInt32Class(), {1,2,3}) and reference types (e.g. arrayFromVector<RMonoStringPtr>(getStringClass(), {mono.stringNew("A"), mono.stringNew("B")})).

◆ arrayFromVector() [2/2]

template<typename T >

RMonoArrayPtr remotemono::RMonoAPI::arrayFromVector	(	RMonoDomainPtr	domain,
		RMonoClassPtr	cls,
		const std::vector< T > &	vec
	)

Creates a new MonoArray from the values in the given std::vector. Can be used for both value types (e.g. arrayFromVector<int32_t>(getInt32Class(), {1,2,3}) and reference types (e.g. arrayFromVector<RMonoStringPtr>(getStringClass(), {mono.stringNew("A"), mono.stringNew("B")})).

◆ attach()

void remotemono::RMonoAPI::attach ( )

inline

Attach RemoteMono to the remote process. This will generate all the wrapper functions are upload their machine code to the remote, as well as create a Mono-attached worker thread (using threadAttach()) in which all the API functions will be executed.

◆ detach()

void remotemono::RMonoAPI::detach ( )

inline

Detach RemoteMono from the remote process, freeing all the memory used for the generated wrapper functions.

◆ gchandlePin()

rmono_gchandle remotemono::RMonoAPI::gchandlePin ( rmono_gchandle gchandle )

inline

Return a new GC handle for the same raw pointer as the parameter, but in its pinned version (see mono_gchandle_new()).

◆ isAPIFunctionSupported()

bool remotemono::RMonoAPI::isAPIFunctionSupported ( const std::string & name ) const

inline

Determines whether the given Mono API function is supported on the remote. Note that this uses the full, original Mono API function name, e.g. mono_runtime_invoke.

Parameters

name	The API function name to check for.

Returns: true if supported, false otherwise

◆ isAttached()

bool remotemono::RMonoAPI::isAttached ( ) const

inline

Determines whether this instance is currently attached using attach().

◆ listClasses()

std::vector< RMonoClassPtr > remotemono::RMonoAPI::listClasses ( RMonoImagePtr image )

inline

List all classes in the given image. The classes are queried from the metadata table MONO_TABLE_TYPEDEF.

Parameters

image The image for which to list classes.

Returns: All classes in the image.

◆ objectToStringUTF8()

std::string remotemono::RMonoAPI::objectToStringUTF8	(	RMonoObjectPtr	obj,
		bool	catchExceptions = `true`
	)

inline

A small convenience wrapper that combines objectToString() with stringToUTF8().

The documentation for this class was generated from the following files:

remotemono/impl/RMonoAPI_Def.h
remotemono/impl/RMonoAPI_Impl.h

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ RMonoAPI()

◆ ~RMonoAPI()

Member Function Documentation

◆ arrayAsVector()

◆ arrayFromVector() [1/2]

◆ arrayFromVector() [2/2]

◆ attach()

◆ detach()

◆ gchandlePin()

◆ isAPIFunctionSupported()

◆ isAttached()

◆ listClasses()

◆ objectToStringUTF8()