remotemono
RMonoAPI_Def.h
1 /*
2  Copyright 2020 David "Alemarius Nexus" Lerch
3 
4  This file is part of RemoteMono.
5 
6  RemoteMono is free software: you can redistribute it and/or modify
7  it under the terms of the GNU Lesser General Public License as published
8  by the Free Software Foundation, either version 3 of the License, or
9  (at your option) any later version.
10 
11  RemoteMono is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU Lesser General Public License for more details.
15 
16  You should have received a copy of the GNU Lesser General Public License
17  along with RemoteMono. If not, see <https://www.gnu.org/licenses/>.
18  */
19 
20 #pragma once
21 
22 #include "../config.h"
23 
24 #include <string>
25 #include <string_view>
26 #include <BlackBone/Process/Process.h>
27 #include "RMonoAPIBase_Def.h"
28 #include "RMonoTypes.h"
29 #include "RMonoHandle_Def.h"
30 #include "RMonoVariant_Def.h"
31 #include "RMonoVariantArray_Def.h"
32 #include "exception/RMonoException_Def.h"
33 #include "exception/RMonoUnsupportedAPIException_Def.h"
34 
35 
36 
37 namespace remotemono
38 {
39 
40 
41 
57 class RMonoAPI : public RMonoAPIBase
58 {
59 public:
62 
67  inline RMonoAPI(blackbone::Process& process);
68 
72  inline virtual ~RMonoAPI();
73 
74 
80  inline void attach();
81 
85  inline void detach();
86 
90  inline bool isAttached() const;
91 
99  inline bool isAPIFunctionSupported(const std::string& name) const;
100 
102 
103 
104 
105  // ********** MONO API WRAPPERS **********
106 
107  inline void free(rmono_voidp p);
108 
111  inline RMonoDomainPtr jitInit(const std::string_view& filename);
112  inline void jitCleanup(RMonoDomainPtr domain);
114 
117  inline RMonoDomainPtr getRootDomain();
118  inline bool domainSet(RMonoDomainPtr domain, bool force);
119  inline RMonoDomainPtr domainGet();
120  inline std::vector<RMonoDomainPtr> domainList();
121  inline RMonoDomainPtr domainCreateAppdomain ( const std::string_view& friendlyName,
122  const std::string_view& configFile = std::string_view());
123  inline RMonoAssemblyPtr domainAssemblyOpen(RMonoDomainPtr domain, const std::string_view& name);
124  inline void domainUnload(RMonoDomainPtr domain);
125  inline std::string domainGetFriendlyName(RMonoDomainPtr domain);
127 
130  inline RMonoThreadPtr threadAttach(RMonoDomainPtr domain);
131  inline void threadDetach(RMonoThreadPtr thread);
133 
136  inline void assemblyClose(RMonoAssemblyPtr assembly);
137  inline std::vector<RMonoAssemblyPtr> assemblyList();
138  inline RMonoImagePtr assemblyGetImage(RMonoAssemblyPtr assembly);
139  inline RMonoAssemblyNamePtr assemblyGetName(RMonoAssemblyPtr assembly);
140  inline RMonoAssemblyNamePtr assemblyNameNew(const std::string_view& name);
141  inline bool assemblyNameParse(const std::string_view& name, RMonoAssemblyNamePtr aname); // NOTE: Deprecated
142  inline void assemblyNameFree(RMonoAssemblyNamePtrRaw name);
143  inline std::string assemblyNameGetName(RMonoAssemblyNamePtr assembly);
144  inline std::string assemblyNameGetCulture(RMonoAssemblyNamePtr assembly);
145  inline uint16_t assemblyNameGetVersion ( RMonoAssemblyNamePtr assembly, uint16_t* minor,
146  uint16_t* build, uint16_t* revision);
147  inline std::string stringifyAssemblyName(RMonoAssemblyNamePtr assembly);
148  inline std::string assemblyNameStringify(RMonoAssemblyNamePtr assembly);
149  inline RMonoAssemblyPtr assemblyLoaded(RMonoAssemblyNamePtr name);
150  inline RMonoAssemblyPtr assemblyLoaded(const std::string_view& name);
152 
155  inline std::string imageGetName(RMonoImagePtr image);
156  inline std::string imageGetFilename(RMonoImagePtr image);
157  inline RMonoTableInfoPtr imageGetTableInfo(RMonoImagePtr image, rmono_int tableID);
158  inline rmono_int tableInfoGetRows(RMonoTableInfoPtr table);
159  inline rmono_voidp imageRVAMap(RMonoImagePtr image, uint32_t addr);
161 
164  inline uint32_t metadataDecodeRowCol(RMonoTableInfoPtr table, rmono_int idx, rmono_uint col);
165  inline rmono_voidp metadataGuidHeap(RMonoImagePtr image, uint32_t idx, uint8_t* outGuid = nullptr);
166  inline std::string metadataStringHeap(RMonoImagePtr image, uint32_t idx);
167  inline rmono_voidp metadataStringHeapRaw(RMonoImagePtr image, uint32_t idx);
168  inline rmono_voidp metadataBlobHeap(RMonoImagePtr image, uint32_t idx);
169  inline std::string metadataUserString(RMonoImagePtr image, uint32_t idx);
170  inline rmono_voidp metadataUserStringRaw(RMonoImagePtr image, uint32_t idx);
171  inline uint32_t metadataDecodeBlobSize(rmono_voidp blobPtr, rmono_voidp* outBlobPtr);
173 
176  inline RMonoClassPtr getObjectClass();
177  inline RMonoClassPtr getInt16Class();
178  inline RMonoClassPtr getInt32Class();
179  inline RMonoClassPtr getInt64Class();
180  inline RMonoClassPtr getDoubleClass();
181  inline RMonoClassPtr getSingleClass();
182  inline RMonoClassPtr getStringClass();
183  inline RMonoClassPtr getThreadClass();
184  inline RMonoClassPtr getUInt16Class();
185  inline RMonoClassPtr getUInt32Class();
186  inline RMonoClassPtr getUInt64Class();
187  inline RMonoClassPtr getVoidClass();
188  inline RMonoClassPtr getArrayClass();
189  inline RMonoClassPtr getBooleanClass();
190  inline RMonoClassPtr getByteClass();
191  inline RMonoClassPtr getSByteClass();
192  inline RMonoClassPtr getCharClass();
193  inline RMonoClassPtr getExceptionClass();
195 
198  inline RMonoVTablePtr classVTable(RMonoDomainPtr domain, RMonoClassPtr cls);
199  inline RMonoVTablePtr classVTable(RMonoClassPtr cls);
200  inline void runtimeClassInit(RMonoVTablePtr vtable);
201  inline RMonoClassPtr classGetParent(RMonoClassPtr cls);
202  inline RMonoTypePtr classGetType(RMonoClassPtr cls);
203  inline RMonoClassPtr classFromName(RMonoImagePtr image, const std::string_view& nameSpace, const std::string_view& name);
204  inline RMonoClassPtr classFromMonoType(RMonoTypePtr type);
205  inline std::string classGetName(RMonoClassPtr cls);
206  inline std::string classGetNamespace(RMonoClassPtr cls);
207  inline std::vector<RMonoClassFieldPtr> classGetFields(RMonoClassPtr cls);
208  inline std::vector<RMonoMethodPtr> classGetMethods(RMonoClassPtr cls);
209  inline std::vector<RMonoPropertyPtr> classGetProperties(RMonoClassPtr cls);
210  inline RMonoClassFieldPtr classGetFieldFromName(RMonoClassPtr cls, const std::string_view& name);
211  inline RMonoMethodPtr classGetMethodFromName(RMonoClassPtr cls, const std::string_view& name, int32_t paramCount = -1);
212  inline RMonoPropertyPtr classGetPropertyFromName(RMonoClassPtr cls, const std::string_view& name);
213  inline RMonoClassPtr classGetElementClass(RMonoClassPtr cls);
214  inline uint32_t classGetFlags(RMonoClassPtr cls);
215  inline rmono_int classGetRank(RMonoClassPtr cls);
216  inline bool classIsValueType(RMonoClassPtr cls);
217  inline uint32_t classDataSize(RMonoClassPtr cls);
218  inline uint32_t classInstanceSize(RMonoClassPtr cls);
219  inline int32_t classValueSize(RMonoClassPtr cls, uint32_t* align = nullptr);
221 
224  inline RMonoReflectionTypePtr typeGetObject(RMonoDomainPtr domain, RMonoTypePtr type);
225  inline RMonoReflectionTypePtr typeGetObject(RMonoTypePtr type);
226  inline std::string typeGetName(RMonoTypePtr type);
227  inline RMonoClassPtr typeGetClass(RMonoTypePtr type);
228  inline rmono_int typeGetType(RMonoTypePtr type);
229  inline bool typeIsByRef(RMonoTypePtr type);
230  inline bool typeIsPointer(RMonoTypePtr type);
231  inline bool typeIsReference(RMonoTypePtr type);
232  inline bool typeIsStruct(RMonoTypePtr type);
233  inline bool typeIsVoid(RMonoTypePtr type);
234  inline rmono_int typeSize(RMonoTypePtr type, rmono_int* align = nullptr);
235  inline rmono_int typeStackSize(RMonoTypePtr type, rmono_int* align = nullptr);
237 
240  inline RMonoClassPtr fieldGetParent(RMonoClassFieldPtr field);
241  inline RMonoTypePtr fieldGetType(RMonoClassFieldPtr field);
242  inline std::string fieldGetName(RMonoClassFieldPtr field);
243  inline uint32_t fieldGetFlags(RMonoClassFieldPtr field);
244  inline void fieldSetValue(RMonoObjectPtr obj, RMonoClassFieldPtr field, const RMonoVariant& val);
245  inline void fieldGetValue(RMonoObjectPtr obj, RMonoClassFieldPtr field, RMonoVariant& val);
246  inline void fieldGetValue(RMonoObjectPtr obj, RMonoClassFieldPtr field, RMonoVariant&& val);
247  template <typename T> T fieldGetValue(RMonoObjectPtr obj, RMonoClassFieldPtr field);
248  inline RMonoObjectPtr fieldGetValueObject(RMonoDomainPtr domain, RMonoClassFieldPtr field, RMonoObjectPtr obj = nullptr);
249  inline RMonoObjectPtr fieldGetValueObject(RMonoClassFieldPtr field, RMonoObjectPtr obj = nullptr);
250  inline void fieldStaticSetValue(RMonoVTablePtr vtable, RMonoClassFieldPtr field, const RMonoVariant& val);
251  inline void fieldStaticGetValue(RMonoVTablePtr vtable, RMonoClassFieldPtr field, RMonoVariant& val);
252  inline void fieldStaticGetValue(RMonoVTablePtr vtable, RMonoClassFieldPtr field, RMonoVariant&& val);
253  template <typename T> T fieldStaticGetValue(RMonoVTablePtr vtable, RMonoClassFieldPtr field);
254  inline uint32_t fieldGetOffset(RMonoClassFieldPtr field);
256 
259  inline RMonoClassPtr methodGetClass(RMonoMethodPtr method);
260  inline std::string methodGetName(RMonoMethodPtr method);
261  inline std::string methodFullName(RMonoMethodPtr method, bool signature);
262  inline uint32_t methodGetFlags(RMonoMethodPtr method, uint32_t* iflags = nullptr);
263  inline RMonoMethodSignaturePtr methodSignature(RMonoMethodPtr method);
264  inline RMonoMethodHeaderPtr methodGetHeader(RMonoMethodPtr method);
265  inline rmono_voidp methodHeaderGetCode(RMonoMethodHeaderPtr header, uint32_t* codeSize, uint32_t* maxStack);
266  inline RMonoMethodDescPtr methodDescNew(const std::string_view& name, bool includeNamespace);
267  inline void methodDescFree(RMonoMethodDescPtrRaw desc);
268  inline bool methodDescMatch(RMonoMethodDescPtr desc, RMonoMethodPtr method);
269  inline RMonoMethodPtr methodDescSearchInClass(RMonoMethodDescPtr desc, RMonoClassPtr cls);
270  inline RMonoMethodPtr methodDescSearchInClass(const std::string_view& desc, bool includeNamespace, RMonoClassPtr cls);
271  inline RMonoMethodPtr methodDescSearchInImage(RMonoMethodDescPtr desc, RMonoImagePtr image);
272  inline RMonoMethodPtr methodDescSearchInImage(const std::string_view& desc, bool includeNamespace, RMonoImagePtr image);
273  inline RMonoObjectPtr runtimeInvoke ( RMonoMethodPtr method, const RMonoVariant& obj,
274  RMonoVariantArray& params, bool catchExceptions = true);
275  inline RMonoObjectPtr runtimeInvoke ( RMonoMethodPtr method, const RMonoVariant& obj = nullptr,
276  RMonoVariantArray&& params = RMonoVariantArray(), bool catchExceptions = true);
277  inline rmono_voidp compileMethod(RMonoMethodPtr method);
279 
282  inline std::string propertyGetName(RMonoPropertyPtr prop);
283  inline uint32_t propertyGetFlags(RMonoPropertyPtr prop);
284  inline RMonoClassPtr propertyGetParent(RMonoPropertyPtr prop);
285  inline RMonoMethodPtr propertyGetSetMethod(RMonoPropertyPtr prop);
286  inline RMonoMethodPtr propertyGetGetMethod(RMonoPropertyPtr prop);
287  inline RMonoObjectPtr propertyGetValue ( RMonoPropertyPtr prop, const RMonoVariant& obj,
288  RMonoVariantArray& params, bool catchExceptions = true);
289  inline RMonoObjectPtr propertyGetValue ( RMonoPropertyPtr prop, const RMonoVariant& obj = nullptr,
290  RMonoVariantArray&& params = RMonoVariantArray(), bool catchExceptions = true);
291  inline void propertySetValue ( RMonoPropertyPtr prop, const RMonoVariant& obj,
292  RMonoVariantArray& params, bool catchExceptions = true);
293  inline void propertySetValue ( RMonoPropertyPtr prop, const RMonoVariant& obj = nullptr,
294  RMonoVariantArray&& params = RMonoVariantArray(), bool catchExceptions = true);
296 
299  inline RMonoTypePtr signatureGetReturnType(RMonoMethodSignaturePtr sig);
300  inline uint32_t signatureGetCallConv(RMonoMethodSignaturePtr sig);
301  inline std::string signatureGetDesc(RMonoMethodSignaturePtr sig, bool includeNamespace);
302  inline std::vector<RMonoTypePtr> signatureGetParams(RMonoMethodSignaturePtr sig);
304 
307  inline RMonoClassPtr objectGetClass(RMonoObjectPtr obj);
308  inline RMonoObjectPtr objectNew(RMonoDomainPtr domain, RMonoClassPtr cls);
309  inline RMonoObjectPtr objectNew(RMonoClassPtr cls);
310  inline void runtimeObjectInit(const RMonoVariant& obj);
311  template <typename T> T objectUnbox(RMonoObjectPtr obj);
312  inline RMonoVariant objectUnboxRaw(RMonoObjectPtr obj);
313  inline RMonoObjectPtr valueBox(RMonoDomainPtr domain, RMonoClassPtr cls, const RMonoVariant& val);
314  inline RMonoObjectPtr valueBox(RMonoClassPtr cls, const RMonoVariant& val);
315  inline RMonoStringPtr objectToString(const RMonoVariant& obj, bool catchExceptions = true);
316  inline RMonoObjectPtr objectClone(RMonoObjectPtr obj);
317  inline RMonoDomainPtr objectGetDomain(RMonoObjectPtr obj);
318  inline RMonoMethodPtr objectGetVirtualMethod(RMonoObjectPtr obj, RMonoMethodPtr method);
319  inline RMonoObjectPtr objectIsInst(RMonoObjectPtr obj, RMonoClassPtr cls);
320  inline rmono_uint objectGetSize(RMonoObjectPtr obj);
322 
325  inline RMonoStringPtr stringNew(RMonoDomainPtr domain, const std::string_view& str);
326  inline RMonoStringPtr stringNew(const std::string_view& str);
327  inline RMonoStringPtr stringNewUTF16(RMonoDomainPtr domain, const std::u16string_view& str);
328  inline RMonoStringPtr stringNewUTF16(const std::u16string_view& str);
329  inline RMonoStringPtr stringNewUTF32(RMonoDomainPtr domain, const std::u32string_view& str);
330  inline RMonoStringPtr stringNewUTF32(const std::u32string_view& str);
331  inline std::string stringToUTF8(RMonoStringPtr str);
332  inline std::u16string stringToUTF16(RMonoStringPtr str);
333  inline std::u32string stringToUTF32(RMonoStringPtr str);
334  inline std::u16string stringChars(RMonoStringPtr str);
335  inline int32_t stringLength(RMonoStringPtr str);
336  inline bool stringEqual(RMonoStringPtr a, RMonoStringPtr b);
338 
341  inline RMonoArrayPtr arrayNew(RMonoDomainPtr domain, RMonoClassPtr cls, rmono_uintptr_t n);
342  inline RMonoArrayPtr arrayNew(RMonoClassPtr cls, rmono_uintptr_t n);
343  inline RMonoArrayPtr arrayNewFull ( RMonoDomainPtr domain, RMonoClassPtr cls, const std::vector<rmono_uintptr_t>& lengths,
344  const std::vector<rmono_intptr_t>& lowerBounds = {});
345  inline RMonoArrayPtr arrayNewFull ( RMonoClassPtr cls, const std::vector<rmono_uintptr_t>& lengths,
346  const std::vector<rmono_intptr_t>& lowerBounds = {});
347  inline RMonoClassPtr arrayClassGet(RMonoClassPtr cls, uint32_t rank);
348  inline rmono_voidp arrayAddrWithSize(RMonoArrayPtr arr, rmono_int size, rmono_uintptr_t idx);
349  inline rmono_uintptr_t arrayLength(RMonoArrayPtr arr);
350  inline int32_t arrayElementSize(RMonoClassPtr cls);
351  inline int32_t classArrayElementSize(RMonoClassPtr cls);
352  inline RMonoArrayPtr arrayClone(RMonoArrayPtr arr);
353  template <typename T> T arrayGet(RMonoArrayPtr arr, rmono_uintptr_t idx);
354  inline void arraySet(RMonoArrayPtr arr, rmono_uintptr_t idx, const RMonoVariant& val);
356 
359  inline rmono_gchandle gchandleNew(RMonoObjectPtr obj, bool pinned);
360  inline rmono_gchandle gchandleNewRaw(RMonoObjectPtrRaw obj, bool pinned);
361  inline rmono_gchandle gchandleNewWeakref(RMonoObjectPtr obj, bool trackResurrection);
362  inline rmono_gchandle gchandleNewWeakrefRaw(RMonoObjectPtrRaw obj, bool trackResurrection);
363  inline RMonoObjectPtrRaw gchandleGetTarget(rmono_gchandle gchandle);
364  inline void gchandleFree(rmono_gchandle gchandle);
366 
369  inline void gcCollect(rmono_int generation);
370  inline rmono_int gcMaxGeneration();
371  inline rmono_int gcGetGeneration(RMonoObjectPtr obj);
373 
376  inline RMonoJitInfoPtr jitInfoTableFind(RMonoDomainPtr domain, rmono_voidp addr);
377  inline RMonoJitInfoPtr jitInfoTableFind(rmono_voidp addr);
378  inline rmono_voidp jitInfoGetCodeStart(RMonoJitInfoPtr jinfo);
379  inline int32_t jitInfoGetCodeSize(RMonoJitInfoPtr jinfo);
380  inline RMonoMethodPtr jitInfoGetMethod(RMonoJitInfoPtr jinfo);
382 
385  inline std::string disasmCode(RMonoDisHelperPtr helper, RMonoMethodPtr method, rmono_voidp ip, rmono_voidp end);
387 
388 
389 
390 
391  // ********** UTILITY METHODS **********
392 
395 
402  inline std::vector<RMonoClassPtr> listClasses(RMonoImagePtr image);
403 
407  inline std::string objectToStringUTF8(RMonoObjectPtr obj, bool catchExceptions = true);
408 
414  template <typename T>
415  std::vector<T> arrayAsVector(RMonoArrayPtr arr);
416 
422  template <typename T>
423  RMonoArrayPtr arrayFromVector(RMonoDomainPtr domain, RMonoClassPtr cls, const std::vector<T>& vec);
424 
430  template <typename T>
431  RMonoArrayPtr arrayFromVector(RMonoClassPtr cls, const std::vector<T>& vec);
432 
436  inline rmono_gchandle gchandlePin(rmono_gchandle gchandle);
437 
439 
440 
441 
442 private:
443  inline void selectABI();
444 
445  template <typename ABI>
446  blackbone::MemBlock prepareIterator();
447 
448  inline void checkAttached();
449 
450  template <typename FuncT>
451  void checkAPIFunctionSupported(const FuncT& f);
452 
453 
454 private:
455  bool attached;
456  RMonoDomainPtr rootDomain;
457  RMonoThreadPtr monoThread;
458 };
459 
460 
461 
462 }
remotemono::RMonoAPI::arrayAsVector
std::vector< T > arrayAsVector(RMonoArrayPtr arr)
Definition: RMonoAPI_Impl.h:2585
remotemono::RMonoAPIBase
Definition: RMonoAPIBase_Def.h:43
remotemono::RMonoAPI
Definition: RMonoAPI_Def.h:58
remotemono::RMonoObjectHandle< RMonoThreadPtrRaw >
remotemono::RMonoAPI::isAttached
bool isAttached() const
Definition: RMonoAPI_Impl.h:131
remotemono::RMonoAPI::RMonoAPI
RMonoAPI(blackbone::Process &process)
Definition: RMonoAPI_Impl.h:48
remotemono::RMonoAPI::detach
void detach()
Definition: RMonoAPI_Impl.h:93
remotemono::RMonoVariantArray
Definition: RMonoVariantArray_Def.h:47
remotemono::RMonoAPI::isAPIFunctionSupported
bool isAPIFunctionSupported(const std::string &name) const
Definition: RMonoAPI_Impl.h:137
remotemono::RMonoAPI::gchandlePin
rmono_gchandle gchandlePin(rmono_gchandle gchandle)
Definition: RMonoAPI_Impl.h:2619
remotemono::RMonoAPI::~RMonoAPI
virtual ~RMonoAPI()
Definition: RMonoAPI_Impl.h:54
remotemono::RMonoAPI::arrayFromVector
RMonoArrayPtr arrayFromVector(RMonoDomainPtr domain, RMonoClassPtr cls, const std::vector< T > &vec)
Definition: RMonoAPI_Impl.h:2599
remotemono::RMonoAPI::attach
void attach()
Definition: RMonoAPI_Impl.h:60
remotemono::RMonoVariant
Definition: RMonoVariant_Def.h:71
remotemono::RMonoAPI::listClasses
std::vector< RMonoClassPtr > listClasses(RMonoImagePtr image)
Definition: RMonoAPI_Impl.h:2553
remotemono::RMonoAPI::objectToStringUTF8
std::string objectToStringUTF8(RMonoObjectPtr obj, bool catchExceptions=true)
Definition: RMonoAPI_Impl.h:2578
remotemono::RMonoHandle< RMonoDomainPtrRaw >
Generated by doxygen 1.8.20