Fixed some memory leaks.

addons/source-python/packages/source-python/entities/_base.py

@@ -339,8 +339,11 @@ def server_classes(self):
     @cached_property
     def properties(self):
         """Iterate over all descriptors available for the entity."""
+        properties = {}
         for server_class in self.server_classes:
-            yield from server_class.properties
+            for prop, data in server_class.properties.items():
+                properties[prop] = data
+        return properties
 
     @cached_property
     def inputs(self):
@@ -374,8 +377,11 @@ def keyvalues(self):
             An entity might also have hardcoded keyvalues that can't be listed
             with this property.
         """
+        keyvalues = {}
         for server_class in self.server_classes:
-            yield from server_class.keyvalues
+            for keyvalue, data in server_class.keyvalues.items():
+                keyvalues[keyvalue] = data
+        return keyvalues
 
     def get_model(self):
         """Return the entity's model.

addons/source-python/packages/source-python/entities/datamaps.py

@@ -127,7 +127,11 @@ class InputFunction(Function):
 
     def __init__(self, name, argument_type, function, this):
         """Instantiate the function instance and store the base attributes."""
-        super().__init__(function)
+        self._function = function
+        super().__init__(
+            function.address, function.convention, function.arguments,
+            function.return_type
+        )
 
         self._name = name
         self._argument_type = argument_type

addons/source-python/packages/source-python/memory/helpers.py

@@ -315,7 +315,10 @@ class MemberFunction(Function):
 
     def __init__(self, manager, return_type, func, this):
         """Initialize the instance."""
-        super().__init__(func)
+        self._function = func
+        super().__init__(
+            func.address, func.convention, func.arguments, func.return_type
+        )
 
         # This should always hold a TypeManager instance
         self._manager = manager

src/core/modules/memory/memory_function.cpp

@@ -142,6 +142,9 @@ CFunction::CFunction(unsigned long ulAddr, object oCallingConvention, object oAr
 		// If this line succeeds the user wants to create a function with the built-in calling conventions
 		m_eCallingConvention = extract<Convention_t>(oCallingConvention);
 		m_pCallingConvention = MakeDynamicHooksConvention(m_eCallingConvention, ObjectToDataTypeVector(m_tArgs), m_eReturnType);
+
+		// We allocated the calling convention, we are responsible to cleanup.
+		m_bAllocatedCallingConvention = true;
 	}
 	catch( ... )
 	{
@@ -154,8 +157,12 @@ CFunction::CFunction(unsigned long ulAddr, object oCallingConvention, object oAr
 		// FIXME:
 		// This is required to fix a crash, but it will also cause a memory leak,
 		// because no calling convention object that is created via this method will ever be deleted.
+		// TODO: Pretty sure this was required due to the missing held type definition. It was added, but wasn't tested yet.
 		Py_INCREF(_oCallingConvention.ptr());
 		m_pCallingConvention = extract<ICallingConvention*>(_oCallingConvention);
+
+		// We didn't allocate the calling convention, someone else is responsible for it.
+		m_bAllocatedCallingConvention = false;
 	}
 
 	// Step 4: Get the DynCall calling convention
@@ -170,11 +177,32 @@ CFunction::CFunction(unsigned long ulAddr, Convention_t eCallingConvention,
 	m_eCallingConvention = eCallingConvention;
 	m_iCallingConvention = iCallingConvention;
 	m_pCallingConvention = pCallingConvention;
+
+	// We didn't allocate the calling convention, someone else is responsible for it.
+	m_bAllocatedCallingConvention = false;
+
 	m_tArgs = tArgs;
 	m_eReturnType = eReturnType;
 	m_oConverter = oConverter;
 }
 
+CFunction::~CFunction()
+{
+	// If we didn't allocate the calling convention, then it is not our responsibility.
+	if (!m_bAllocatedCallingConvention)
+		return;
+
+	CHook* pHook = GetHookManager()->FindHook((void *) m_ulAddr);
+
+	// DynamicHooks will take care of it for us from there.
+	if (pHook && pHook->m_pCallingConvention == m_pCallingConvention)
+		return;
+
+	// Cleanup.
+	delete m_pCallingConvention;
+	m_pCallingConvention = NULL;
+}
+
 bool CFunction::IsCallable()
 {
 	return (m_eCallingConvention != CONV_CUSTOM) && (m_iCallingConvention != -1);

src/core/modules/memory/memory_function.h

@@ -52,14 +52,16 @@ enum Convention_t
 // ============================================================================
 // >> CFunction
 // ============================================================================
-class CFunction: public CPointer
+class CFunction: public CPointer, private boost::noncopyable
 {
 public:
 	CFunction(unsigned long ulAddr, object oCallingConvention, object oArgs, object oReturnType);
 	CFunction(unsigned long ulAddr, Convention_t eCallingConvention, int iCallingConvention,
 		ICallingConvention* pCallingConvention, boost::python::tuple tArgs,
 		DataType_t eReturnType, object oConverter);
 
+	~CFunction();
+
 	bool IsCallable();
 	bool IsHookable();
 
@@ -99,6 +101,7 @@ class CFunction: public CPointer
 
 	// DynamicHooks calling convention (built-in and custom)
 	ICallingConvention*		m_pCallingConvention;
+	bool					m_bAllocatedCallingConvention;
 };
 
 

src/core/modules/memory/memory_pointer.cpp

@@ -109,14 +109,6 @@ void CPointer::SetStringArray(char* szText, int iOffset /* = 0 */)
 	EXCEPT_SEGV()
 }
 
-unsigned long GetPtrHelper(unsigned long addr)
-{
-	TRY_SEGV()
-		return *(unsigned long *) addr;
-	EXCEPT_SEGV()
-	return 0;
-}
-
 CPointer* CPointer::GetPtr(int iOffset /* = 0 */)
 {
 	Validate();
@@ -286,7 +278,10 @@ CFunction* CPointer::MakeFunction(object oCallingConvention, object oArgs, objec
 
 CFunction* CPointer::MakeVirtualFunction(int iIndex, object oCallingConvention, object args, object return_type)
 {
-	return GetVirtualFunc(iIndex)->MakeFunction(oCallingConvention, args, return_type);
+	CPointer *pPtr = GetVirtualFunc(iIndex);
+	CFunction *pFunc = pPtr->MakeFunction(oCallingConvention, args, return_type);
+	delete pPtr;
+	return pFunc;
 }
 
 CFunction* CPointer::MakeVirtualFunction(CFunctionInfo& info)

src/core/modules/memory/memory_pointer.h

@@ -190,4 +190,16 @@ inline CPointer* Alloc(int iSize, bool bAutoDealloc = true)
 	return new CPointer((unsigned long) UTIL_Alloc(iSize), bAutoDealloc);
 }
 
+
+// ============================================================================
+// >> GetPtrHelper
+// ============================================================================
+inline unsigned long GetPtrHelper(unsigned long addr)
+{
+	TRY_SEGV()
+		return *(unsigned long *) addr;
+	EXCEPT_SEGV()
+	return 0;
+}
+
 #endif // _MEMORY_POINTER_H

src/core/modules/memory/memory_scanner.cpp

@@ -328,7 +328,7 @@ CPointer* CBinaryFile::FindPointer(object oIdentifier, int iOffset, unsigned int
 		ptr->m_ulAddr += iOffset;
 		while (iLevel > 0)
 		{
-			ptr = ptr->GetPtr();
+			ptr->m_ulAddr = GetPtrHelper(ptr->m_ulAddr);
 			iLevel = iLevel - 1;
 		}
 	}

src/core/modules/memory/memory_wrap.cpp

@@ -452,7 +452,8 @@ void export_type_info_iter(scope _memory)
 void export_function(scope _memory)
 {
 	class_<CFunction, bases<CPointer>, boost::noncopyable >("Function", init<unsigned long, object, object, object>())
-		.def(init<CFunction&>())
+		// Don't allow copies, because they will hold references to our calling convention.
+		// .def(init<CFunction&>())
 		.def("__call__",
 			raw_method(&CFunction::Call),
 			"Calls the function dynamically."
@@ -817,7 +818,7 @@ void export_registers(scope _memory)
 // ============================================================================
 void export_calling_convention(scope _memory)
 {
-	class_<ICallingConventionWrapper, boost::noncopyable>(
+	class_<ICallingConventionWrapper, ICallingConventionWrapper *, boost::noncopyable>(
 		"CallingConvention",
 		"An an abstract class that is used to create custom calling "
 		"conventions (only available for hooking function and not for"