From fa26f4e462b1d7a92eb05d637dd1eb033e64a70c Mon Sep 17 00:00:00 2001 From: Wend4r <47463683+Wend4r@users.noreply.github.com> Date: Thu, 13 Oct 2022 14:00:20 +0300 Subject: [PATCH 1/9] Push `Address` methodmap with read methods --- core/logic/PseudoAddrManager.cpp | 7 +++- core/logic/PseudoAddrManager.h | 1 + core/logic/smn_core.cpp | 62 ++++++++++++++++++++++++++++++++ plugins/include/sourcemod.inc | 7 ++++ 4 files changed, 76 insertions(+), 1 deletion(-) diff --git a/core/logic/PseudoAddrManager.cpp b/core/logic/PseudoAddrManager.cpp index 2979b1ab09..6c0d40fa58 100644 --- a/core/logic/PseudoAddrManager.cpp +++ b/core/logic/PseudoAddrManager.cpp @@ -43,10 +43,15 @@ PseudoAddressManager::PseudoAddressManager() : m_NumEntries(0) // A pseudo address consists of a table index in the upper 6 bits and an offset in the // lower 26 bits. The table consists of memory allocation base addresses. void *PseudoAddressManager::FromPseudoAddress(uint32_t paddr) +{ + return FromPseudoAddress(paddr, 0); +} + +void *PseudoAddressManager::FromPseudoAddress(uint32_t paddr, uint32_t offset) { #ifdef PLATFORM_X64 uint8_t index = paddr >> PSEUDO_OFFSET_BITS; - uint32_t offset = paddr & ((1 << PSEUDO_OFFSET_BITS) - 1); + offset += paddr & ((1 << PSEUDO_OFFSET_BITS) - 1); if (index >= m_NumEntries) return nullptr; diff --git a/core/logic/PseudoAddrManager.h b/core/logic/PseudoAddrManager.h index 5de802aa26..175fc8e8c0 100644 --- a/core/logic/PseudoAddrManager.h +++ b/core/logic/PseudoAddrManager.h @@ -38,6 +38,7 @@ class PseudoAddressManager PseudoAddressManager(); public: void *FromPseudoAddress(uint32_t paddr); + void *FromPseudoAddress(uint32_t paddr, uint32_t offset); uint32_t ToPseudoAddress(void *addr); private: void *GetAllocationBase(void *ptr); diff --git a/core/logic/smn_core.cpp b/core/logic/smn_core.cpp index 490a6a00da..c2441d8329 100644 --- a/core/logic/smn_core.cpp +++ b/core/logic/smn_core.cpp @@ -816,6 +816,64 @@ enum NumberType //memory addresses below 0x10000 are automatically considered invalid for dereferencing #define VALID_MINIMUM_MEMORY_ADDRESS 0x10000 +inline static bool IsAddressValidRange(void *addr) +{ + return addr != NULL && reinterpret_cast(addr) >= VALID_MINIMUM_MEMORY_ADDRESS; +} + +// Very slowly if iterate by each address cell. +template +inline static bool HasAddressAccess(void *addr) +{ + int bits; + + return SourceHook::GetPageBits(addr, &bits) && bits & A; +} + +template +inline static cell_t ReadSecureAddressCell(IPluginContext *pContext, cell_t caddr, cell_t coffset) +{ +#ifdef PLATFORM_X86 + void *addr = reinterpret_cast(caddr + coffset); +#else + void *addr = pseudoAddr.FromPseudoAddress((uint32_t)caddr, (uint32_t)coffset); +#endif + + if (!IsAddressValidRange(addr)) + { + #ifdef _DEBUG + return pContext->ThrowNativeError("Invalid address 0x%x is pointing to reserved memory (base is 0x%x, offset is 0x%x, read block size is %d)", addr, caddr, coffset, sizeof(T)); + #else + return pContext->ThrowNativeError("Invalid address 0x%x is pointing to reserved memory", addr); + #endif + } + +#ifdef _DEBUG + if (!HasAddressAccess(addr)) + { + return pContext->ThrowNativeError("Invalid address access by 0x%x to read memory (base is 0x%x, offset is 0x%x, read block size is %d)", addr, caddr, coffset, sizeof(T)); + } +#endif + + // If you have crash, enable _DEBUG for profiling which plugin the address is not valid. + return (cell_t)*reinterpret_cast(addr); +} + +static cell_t Address_ReadInt8(IPluginContext *pContext, const cell_t *params) +{ + return ReadSecureAddressCell(pContext, params[1], params[2]); +} + +static cell_t Address_ReadInt16(IPluginContext *pContext, const cell_t *params) +{ + return ReadSecureAddressCell(pContext, params[1], params[2]); +} + +static cell_t Address_ReadInt32(IPluginContext *pContext, const cell_t *params) +{ + return ReadSecureAddressCell(pContext, params[1], params[2]); +} + static cell_t LoadFromAddress(IPluginContext *pContext, const cell_t *params) { #ifdef PLATFORM_X86 @@ -1114,6 +1172,10 @@ REGISTER_NATIVES(coreNatives) {"IsNullVector", IsNullVector}, {"IsNullString", IsNullString}, {"LogStackTrace", LogStackTrace}, + + {"Address.ReadInt8", Address_ReadInt8}, + {"Address.ReadInt16", Address_ReadInt16}, + {"Address.ReadInt32", Address_ReadInt32}, {"FrameIterator.FrameIterator", FrameIterator_Create}, {"FrameIterator.Next", FrameIterator_Next}, diff --git a/plugins/include/sourcemod.inc b/plugins/include/sourcemod.inc index 876a6d6834..d0969b2330 100644 --- a/plugins/include/sourcemod.inc +++ b/plugins/include/sourcemod.inc @@ -712,6 +712,13 @@ enum Address Address_Null = 0 // a typical invalid result when an address lookup fails }; +methodmap Address +{ + public native any ReadInt8(int offset = 0); + public native any ReadInt16(int offset = 0); + public native any ReadInt32(int offset = 0); +}; + /** * Load up to 4 bytes from a memory address. * From 3849b017389c8de06c43303f5bbe317796bdd72e Mon Sep 17 00:00:00 2001 From: Wend4r <47463683+Wend4r@users.noreply.github.com> Date: Thu, 13 Oct 2022 14:11:10 +0300 Subject: [PATCH 2/9] Push `Address.Write*()` methods --- core/logic/smn_core.cpp | 51 +++++++++++++++++++++++++++++++++++ plugins/include/sourcemod.inc | 4 +++ 2 files changed, 55 insertions(+) diff --git a/core/logic/smn_core.cpp b/core/logic/smn_core.cpp index c2441d8329..cf0e47bbb5 100644 --- a/core/logic/smn_core.cpp +++ b/core/logic/smn_core.cpp @@ -859,6 +859,39 @@ inline static cell_t ReadSecureAddressCell(IPluginContext *pContext, cell_t cadd return (cell_t)*reinterpret_cast(addr); } +template +inline static cell_t WriteSecureAddressCell(IPluginContext *pContext, cell_t caddr, cell_t coffset, cell_t cvalue) +{ +#ifdef PLATFORM_X86 + void *addr = reinterpret_cast(caddr + coffset); +#else + void *addr = pseudoAddr.FromPseudoAddress((uint32_t)caddr, (uint32_t)coffset); +#endif + + if (!IsAddressValidRange(addr)) + { + #ifdef _DEBUG + return pContext->ThrowNativeError("Invalid address 0x%x is pointing to reserved memory (base is 0x%x, offset is 0x%x, read block size is %d)", addr, caddr, coffset, sizeof(T)); + #else + return pContext->ThrowNativeError("Invalid address 0x%x is pointing to reserved memory", addr); + #endif + } + +#ifdef _DEBUG + if (!HasAddressAccess(addr)) + { + return pContext->ThrowNativeError("Invalid address access by 0x%x to write memory (base is 0x%x, offset is 0x%x, read block size is %d)", addr, caddr, coffset, sizeof(T)); + } +#endif + + // If you have crash, enable _DEBUG for profiling which plugin the address is not valid. + cell_t old_cvalue = (cell_t)*reinterpret_cast(addr); + + *reinterpret_cast(addr) = (T)cvalue; + + return old_cvalue; +} + static cell_t Address_ReadInt8(IPluginContext *pContext, const cell_t *params) { return ReadSecureAddressCell(pContext, params[1], params[2]); @@ -874,6 +907,21 @@ static cell_t Address_ReadInt32(IPluginContext *pContext, const cell_t *params) return ReadSecureAddressCell(pContext, params[1], params[2]); } +static cell_t Address_WriteInt8(IPluginContext *pContext, const cell_t *params) +{ + return WriteSecureAddressCell(pContext, params[1], params[3], params[2]); +} + +static cell_t Address_WriteInt16(IPluginContext *pContext, const cell_t *params) +{ + return WriteSecureAddressCell(pContext, params[1], params[3], params[2]); +} + +static cell_t Address_WriteInt32(IPluginContext *pContext, const cell_t *params) +{ + return WriteSecureAddressCell(pContext, params[1], params[3], params[2]); +} + static cell_t LoadFromAddress(IPluginContext *pContext, const cell_t *params) { #ifdef PLATFORM_X86 @@ -1176,6 +1224,9 @@ REGISTER_NATIVES(coreNatives) {"Address.ReadInt8", Address_ReadInt8}, {"Address.ReadInt16", Address_ReadInt16}, {"Address.ReadInt32", Address_ReadInt32}, + {"Address.WriteInt8", Address_WriteInt8}, + {"Address.WriteInt16", Address_WriteInt16}, + {"Address.WriteInt32", Address_WriteInt32}, {"FrameIterator.FrameIterator", FrameIterator_Create}, {"FrameIterator.Next", FrameIterator_Next}, diff --git a/plugins/include/sourcemod.inc b/plugins/include/sourcemod.inc index d0969b2330..073866d621 100644 --- a/plugins/include/sourcemod.inc +++ b/plugins/include/sourcemod.inc @@ -717,6 +717,10 @@ methodmap Address public native any ReadInt8(int offset = 0); public native any ReadInt16(int offset = 0); public native any ReadInt32(int offset = 0); + + public native any WriteInt8(any data, int offset = 0); + public native any WriteInt16(any data, int offset = 0); + public native any WriteInt32(any data, int offset = 0); }; /** From 0e278809365c22c2c8b689d175582a14e651f270 Mon Sep 17 00:00:00 2001 From: Wend4r <47463683+Wend4r@users.noreply.github.com> Date: Thu, 13 Oct 2022 14:54:34 +0300 Subject: [PATCH 3/9] Push `Address.GetAccess()` method --- core/logic/smn_core.cpp | 43 ++++++++++++++++++++++++----------- plugins/include/sourcemod.inc | 6 +++++ 2 files changed, 36 insertions(+), 13 deletions(-) diff --git a/core/logic/smn_core.cpp b/core/logic/smn_core.cpp index cf0e47bbb5..a23bb54a88 100644 --- a/core/logic/smn_core.cpp +++ b/core/logic/smn_core.cpp @@ -816,28 +816,38 @@ enum NumberType //memory addresses below 0x10000 are automatically considered invalid for dereferencing #define VALID_MINIMUM_MEMORY_ADDRESS 0x10000 +inline static void *GetAddress(cell_t caddr, cell_t coffset) +{ +#ifdef PLATFORM_X86 + return reinterpret_cast(caddr + coffset); +#else + return pseudoAddr.FromPseudoAddress((uint32_t)caddr, (uint32_t)coffset); +#endif +} + inline static bool IsAddressValidRange(void *addr) { return addr != NULL && reinterpret_cast(addr) >= VALID_MINIMUM_MEMORY_ADDRESS; } +inline static int GetAddressAccess(void *addr) +{ + int bits; + + return SourceHook::GetPageBits(addr, &bits) ? bits : 0; +} + // Very slowly if iterate by each address cell. template inline static bool HasAddressAccess(void *addr) { - int bits; - - return SourceHook::GetPageBits(addr, &bits) && bits & A; + return (GetAddressAccess(addr) & A) != 0; } template inline static cell_t ReadSecureAddressCell(IPluginContext *pContext, cell_t caddr, cell_t coffset) { -#ifdef PLATFORM_X86 - void *addr = reinterpret_cast(caddr + coffset); -#else - void *addr = pseudoAddr.FromPseudoAddress((uint32_t)caddr, (uint32_t)coffset); -#endif + void *addr = GetAddress(caddr, coffset); if (!IsAddressValidRange(addr)) { @@ -862,11 +872,7 @@ inline static cell_t ReadSecureAddressCell(IPluginContext *pContext, cell_t cadd template inline static cell_t WriteSecureAddressCell(IPluginContext *pContext, cell_t caddr, cell_t coffset, cell_t cvalue) { -#ifdef PLATFORM_X86 - void *addr = reinterpret_cast(caddr + coffset); -#else - void *addr = pseudoAddr.FromPseudoAddress((uint32_t)caddr, (uint32_t)coffset); -#endif + void *addr = GetAddress(caddr, coffset); if (!IsAddressValidRange(addr)) { @@ -892,6 +898,11 @@ inline static cell_t WriteSecureAddressCell(IPluginContext *pContext, cell_t cad return old_cvalue; } +inline static int GetSecureAddressAccessCell(IPluginContext *pContext, cell_t caddr, cell_t coffset) +{ + return GetAddressAccess(GetAddress(caddr, coffset)); +} + static cell_t Address_ReadInt8(IPluginContext *pContext, const cell_t *params) { return ReadSecureAddressCell(pContext, params[1], params[2]); @@ -922,6 +933,11 @@ static cell_t Address_WriteInt32(IPluginContext *pContext, const cell_t *params) return WriteSecureAddressCell(pContext, params[1], params[3], params[2]); } +static cell_t Address_GetAccess(IPluginContext *pContext, const cell_t *params) +{ + return (cell_t)GetSecureAddressAccessCell(pContext, params[1], params[2]); +} + static cell_t LoadFromAddress(IPluginContext *pContext, const cell_t *params) { #ifdef PLATFORM_X86 @@ -1227,6 +1243,7 @@ REGISTER_NATIVES(coreNatives) {"Address.WriteInt8", Address_WriteInt8}, {"Address.WriteInt16", Address_WriteInt16}, {"Address.WriteInt32", Address_WriteInt32}, + {"Address.GetAccess", Address_GetAccess}, {"FrameIterator.FrameIterator", FrameIterator_Create}, {"FrameIterator.Next", FrameIterator_Next}, diff --git a/plugins/include/sourcemod.inc b/plugins/include/sourcemod.inc index 073866d621..a651c6750f 100644 --- a/plugins/include/sourcemod.inc +++ b/plugins/include/sourcemod.inc @@ -697,6 +697,10 @@ native FeatureStatus GetFeatureStatus(FeatureType type, const char[] name); native void RequireFeature(FeatureType type, const char[] name, const char[] fmt="", any ...); +#define SH_MEM_READ (1 << 0) +#define SH_MEM_WRITE (1 << 1) +#define SH_MEM_EXEC (1 << 2) + /** * Represents how many bytes we can read from an address with one load */ @@ -721,6 +725,8 @@ methodmap Address public native any WriteInt8(any data, int offset = 0); public native any WriteInt16(any data, int offset = 0); public native any WriteInt32(any data, int offset = 0); + + public native int GetAccess(int offset = 0); }; /** From 5bbc5a890d21da554317df3140edac90df37a24a Mon Sep 17 00:00:00 2001 From: Wend4r <47463683+Wend4r@users.noreply.github.com> Date: Thu, 13 Oct 2022 14:56:19 +0300 Subject: [PATCH 4/9] Push `Address.SetAccess()` method --- core/logic/smn_core.cpp | 15 +++++++++++++++ plugins/include/sourcemod.inc | 1 + 2 files changed, 16 insertions(+) diff --git a/core/logic/smn_core.cpp b/core/logic/smn_core.cpp index a23bb54a88..0566f52817 100644 --- a/core/logic/smn_core.cpp +++ b/core/logic/smn_core.cpp @@ -837,6 +837,11 @@ inline static int GetAddressAccess(void *addr) return SourceHook::GetPageBits(addr, &bits) ? bits : 0; } +inline static bool SetAddressAccess(void *addr, size_t len, int access) +{ + return SourceHook::SetMemAccess(addr, len, access); +} + // Very slowly if iterate by each address cell. template inline static bool HasAddressAccess(void *addr) @@ -903,6 +908,11 @@ inline static int GetSecureAddressAccessCell(IPluginContext *pContext, cell_t ca return GetAddressAccess(GetAddress(caddr, coffset)); } +inline static cell_t SetSecureAddressAccessCell(IPluginContext *pContext, cell_t caddr, cell_t coffset, cell_t size, cell_t access) +{ + return (cell_t)SetAddressAccess(GetAddress(caddr, coffset), (size_t)size, (int)access); +} + static cell_t Address_ReadInt8(IPluginContext *pContext, const cell_t *params) { return ReadSecureAddressCell(pContext, params[1], params[2]); @@ -938,6 +948,11 @@ static cell_t Address_GetAccess(IPluginContext *pContext, const cell_t *params) return (cell_t)GetSecureAddressAccessCell(pContext, params[1], params[2]); } +static cell_t Address_SetAccess(IPluginContext *pContext, const cell_t *params) +{ + return SetSecureAddressAccessCell(pContext, params[1], params[4], params[3], params[2]); +} + static cell_t LoadFromAddress(IPluginContext *pContext, const cell_t *params) { #ifdef PLATFORM_X86 diff --git a/plugins/include/sourcemod.inc b/plugins/include/sourcemod.inc index a651c6750f..2e3d272b8c 100644 --- a/plugins/include/sourcemod.inc +++ b/plugins/include/sourcemod.inc @@ -727,6 +727,7 @@ methodmap Address public native any WriteInt32(any data, int offset = 0); public native int GetAccess(int offset = 0); + public native bool SetAccess(int access, int size = 4, int offset = 0); }; /** From 8991e25c074cfefefed32abf7c640fdd315f6cbb Mon Sep 17 00:00:00 2001 From: Wend4r <47463683+Wend4r@users.noreply.github.com> Date: Thu, 13 Oct 2022 15:08:12 +0300 Subject: [PATCH 5/9] Swap `inline static` to correctly `static inline` --- core/logic/smn_core.cpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/core/logic/smn_core.cpp b/core/logic/smn_core.cpp index 0566f52817..c1260bfcde 100644 --- a/core/logic/smn_core.cpp +++ b/core/logic/smn_core.cpp @@ -816,7 +816,7 @@ enum NumberType //memory addresses below 0x10000 are automatically considered invalid for dereferencing #define VALID_MINIMUM_MEMORY_ADDRESS 0x10000 -inline static void *GetAddress(cell_t caddr, cell_t coffset) +static inline void *GetAddress(cell_t caddr, cell_t coffset) { #ifdef PLATFORM_X86 return reinterpret_cast(caddr + coffset); @@ -825,32 +825,32 @@ inline static void *GetAddress(cell_t caddr, cell_t coffset) #endif } -inline static bool IsAddressValidRange(void *addr) +static inline bool IsAddressValidRange(void *addr) { return addr != NULL && reinterpret_cast(addr) >= VALID_MINIMUM_MEMORY_ADDRESS; } -inline static int GetAddressAccess(void *addr) +static inline int GetAddressAccess(void *addr) { int bits; return SourceHook::GetPageBits(addr, &bits) ? bits : 0; } -inline static bool SetAddressAccess(void *addr, size_t len, int access) +static inline bool SetAddressAccess(void *addr, size_t len, int access) { return SourceHook::SetMemAccess(addr, len, access); } // Very slowly if iterate by each address cell. template -inline static bool HasAddressAccess(void *addr) +static inline bool HasAddressAccess(void *addr) { return (GetAddressAccess(addr) & A) != 0; } template -inline static cell_t ReadSecureAddressCell(IPluginContext *pContext, cell_t caddr, cell_t coffset) +static inline cell_t ReadSecureAddressCell(IPluginContext *pContext, cell_t caddr, cell_t coffset) { void *addr = GetAddress(caddr, coffset); @@ -875,7 +875,7 @@ inline static cell_t ReadSecureAddressCell(IPluginContext *pContext, cell_t cadd } template -inline static cell_t WriteSecureAddressCell(IPluginContext *pContext, cell_t caddr, cell_t coffset, cell_t cvalue) +static inline cell_t WriteSecureAddressCell(IPluginContext *pContext, cell_t caddr, cell_t coffset, cell_t cvalue) { void *addr = GetAddress(caddr, coffset); @@ -903,12 +903,12 @@ inline static cell_t WriteSecureAddressCell(IPluginContext *pContext, cell_t cad return old_cvalue; } -inline static int GetSecureAddressAccessCell(IPluginContext *pContext, cell_t caddr, cell_t coffset) +static inline int GetSecureAddressAccessCell(IPluginContext *pContext, cell_t caddr, cell_t coffset) { return GetAddressAccess(GetAddress(caddr, coffset)); } -inline static cell_t SetSecureAddressAccessCell(IPluginContext *pContext, cell_t caddr, cell_t coffset, cell_t size, cell_t access) +static inline cell_t SetSecureAddressAccessCell(IPluginContext *pContext, cell_t caddr, cell_t coffset, cell_t size, cell_t access) { return (cell_t)SetAddressAccess(GetAddress(caddr, coffset), (size_t)size, (int)access); } From 1931e3284bf24273c5c3bf78ade5f57ddb067673 Mon Sep 17 00:00:00 2001 From: Wend4r <47463683+Wend4r@users.noreply.github.com> Date: Thu, 13 Oct 2022 15:54:09 +0300 Subject: [PATCH 6/9] Add description to `Address` methods --- plugins/include/sourcemod.inc | 55 +++++++++++++++++++++++++++++++++-- 1 file changed, 52 insertions(+), 3 deletions(-) diff --git a/plugins/include/sourcemod.inc b/plugins/include/sourcemod.inc index 2e3d272b8c..3fe2fd96b4 100644 --- a/plugins/include/sourcemod.inc +++ b/plugins/include/sourcemod.inc @@ -697,9 +697,9 @@ native FeatureStatus GetFeatureStatus(FeatureType type, const char[] name); native void RequireFeature(FeatureType type, const char[] name, const char[] fmt="", any ...); -#define SH_MEM_READ (1 << 0) -#define SH_MEM_WRITE (1 << 1) -#define SH_MEM_EXEC (1 << 2) +#define SH_MEM_READ (1 << 0) // Memory block can be read. +#define SH_MEM_WRITE (1 << 1) // Memory block can be write. +#define SH_MEM_EXEC (1 << 2) // Memory block can be execute. Usually the bytecode to be executed by CPU. /** * Represents how many bytes we can read from an address with one load @@ -718,15 +718,64 @@ enum Address methodmap Address { + // Reads 1 byte from a memory address. + // + // @param offset Offset from the base address (in bytes). + // @return The value that is stored. + // @error Address is null or pointing to reserved memory. public native any ReadInt8(int offset = 0); + + // Reads 2 bytes from a memory address. + // + // @param offset Offset from the base address (in bytes). + // @return The value that is stored. + // @error Address is null or pointing to reserved memory. public native any ReadInt16(int offset = 0); + + // Reads 4 bytes from a memory address. + // + // @param offset Offset from the base address (in bytes). + // @return The value that is stored. + // @error Address is null or pointing to reserved memory. public native any ReadInt32(int offset = 0); + // Writes 1 byte to a memory address. + // + // @param data Value to store at the address. + // @param offset Offset from the base address (in bytes). + // @return The value that is stored. + // @error Address is null or pointing to reserved memory. public native any WriteInt8(any data, int offset = 0); + + // Writes 2 bytes to a memory address. + // + // @param data Value to store at the address. + // @param offset Offset from the base address (in bytes). + // @return The value that is stored. + // @error Address is null or pointing to reserved memory. public native any WriteInt16(any data, int offset = 0); + + // Writes 4 bytes to a memory address. + // + // @param data Value to store at the address. + // @param offset Offset from the base address (in bytes). + // @return The value that is stored. + // @error Address is null or pointing to reserved memory. public native any WriteInt32(any data, int offset = 0); + // Gets accesses from a memory address block. + // + // @param offset Offset from the base address (in bytes). + // @return Access flags. See SH_MEM_* for details. public native int GetAccess(int offset = 0); + + // Sets access flags to a memory address. + // Very effectively with setting accesses for large memory block. + // + // @param access Access flags. See SH_MEM_* for details. + // @param size Memory block size to set accesses. + // @param offset Offset from the base address (in bytes). + // @return If true, accesses have been protected, otherwise failure. public native bool SetAccess(int access, int size = 4, int offset = 0); }; From 3630f5f372c450b5ca65a167d928a0eba3e29394 Mon Sep 17 00:00:00 2001 From: Wend4r <47463683+Wend4r@users.noreply.github.com> Date: Thu, 13 Oct 2022 16:01:57 +0300 Subject: [PATCH 7/9] Update `Address.Write*()` return desc. --- plugins/include/sourcemod.inc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/plugins/include/sourcemod.inc b/plugins/include/sourcemod.inc index 3fe2fd96b4..2016a95af0 100644 --- a/plugins/include/sourcemod.inc +++ b/plugins/include/sourcemod.inc @@ -743,7 +743,7 @@ methodmap Address // // @param data Value to store at the address. // @param offset Offset from the base address (in bytes). - // @return The value that is stored. + // @return The old value that was stored. // @error Address is null or pointing to reserved memory. public native any WriteInt8(any data, int offset = 0); @@ -751,7 +751,7 @@ methodmap Address // // @param data Value to store at the address. // @param offset Offset from the base address (in bytes). - // @return The value that is stored. + // @return The old value that was stored. // @error Address is null or pointing to reserved memory. public native any WriteInt16(any data, int offset = 0); @@ -759,7 +759,7 @@ methodmap Address // // @param data Value to store at the address. // @param offset Offset from the base address (in bytes). - // @return The value that is stored. + // @return The old value that was stored. // @error Address is null or pointing to reserved memory. public native any WriteInt32(any data, int offset = 0); From 077d7aebaf0c8ebf0bf9449ba29490631cd76915 Mon Sep 17 00:00:00 2001 From: Wend4r <47463683+Wend4r@users.noreply.github.com> Date: Thu, 13 Oct 2022 16:04:16 +0300 Subject: [PATCH 8/9] Add missing `Address.SetAccess` native reg. --- core/logic/smn_core.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/core/logic/smn_core.cpp b/core/logic/smn_core.cpp index c1260bfcde..b8a605ca5a 100644 --- a/core/logic/smn_core.cpp +++ b/core/logic/smn_core.cpp @@ -1259,6 +1259,7 @@ REGISTER_NATIVES(coreNatives) {"Address.WriteInt16", Address_WriteInt16}, {"Address.WriteInt32", Address_WriteInt32}, {"Address.GetAccess", Address_GetAccess}, + {"Address.SetAccess", Address_SetAccess}, {"FrameIterator.FrameIterator", FrameIterator_Create}, {"FrameIterator.Next", FrameIterator_Next}, From d2631247ae9ace11f718c17e25399d75799d4b8a Mon Sep 17 00:00:00 2001 From: Wend4r <47463683+Wend4r@users.noreply.github.com> Date: Sat, 15 Oct 2022 13:01:36 +0300 Subject: [PATCH 9/9] DEBUG: add memory readability check to `Address.Wtire*()` methods --- core/logic/smn_core.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/logic/smn_core.cpp b/core/logic/smn_core.cpp index b8a605ca5a..4b90cc5462 100644 --- a/core/logic/smn_core.cpp +++ b/core/logic/smn_core.cpp @@ -846,7 +846,7 @@ static inline bool SetAddressAccess(void *addr, size_t len, int access) template static inline bool HasAddressAccess(void *addr) { - return (GetAddressAccess(addr) & A) != 0; + return (GetAddressAccess(addr) & A) == A; } template @@ -889,7 +889,7 @@ static inline cell_t WriteSecureAddressCell(IPluginContext *pContext, cell_t cad } #ifdef _DEBUG - if (!HasAddressAccess(addr)) + if (!HasAddressAccess(addr)) { return pContext->ThrowNativeError("Invalid address access by 0x%x to write memory (base is 0x%x, offset is 0x%x, read block size is %d)", addr, caddr, coffset, sizeof(T)); }