core-legacy/sourcehook/sourcehook.cpp
author David Anderson <dvander@alliedmods.net>
Wed Feb 25 20:26:19 2009 -0500 (2009-02-25)
changeset 649 a0e24af92af0
parent 545 07e5df11f9fc
child 659 b35a5fdbc654
permissions -rw-r--r--
Bumped all versions.
dvander@541
     1
/* ======== SourceHook ========
dvander@541
     2
* Copyright (C) 2004-2008 Metamod:Source Development Team
dvander@541
     3
* No warranties of any kind
dvander@541
     4
*
dvander@541
     5
* License: zlib/libpng
dvander@541
     6
*
dvander@541
     7
* Author(s): Pavol "PM OnoTo" Marko
dvander@541
     8
* Contributors: Scott "Damaged Soul" Ehlert
dvander@541
     9
* ============================
dvander@541
    10
*/
dvander@541
    11
dvander@541
    12
/**
dvander@541
    13
 * @file sourcehook.cpp
dvander@541
    14
 * @brief Contains the implementation of the SourceHook API
dvander@541
    15
*/
dvander@541
    16
dvander@541
    17
#if defined __GNUC__
dvander@541
    18
#include <stdint.h>
dvander@541
    19
#endif
dvander@541
    20
dvander@541
    21
#include "sourcehook_impl.h"
dvander@541
    22
#include "sh_memory.h"
dvander@541
    23
dvander@541
    24
namespace SourceHook
dvander@541
    25
{
dvander@541
    26
	template<>
dvander@541
    27
	int HashFunction<int>(const int & k)
dvander@541
    28
	{
dvander@541
    29
		return k;
dvander@541
    30
	}
dvander@541
    31
	template<>
dvander@541
    32
	int Compare<int>(const int & k1, const int & k2)
dvander@541
    33
	{
dvander@541
    34
		if (k1 == k2)
dvander@541
    35
			return 0;
dvander@541
    36
		if (k1 > k2)
dvander@541
    37
			return 1;
dvander@541
    38
		if (k1 < k2)
dvander@541
    39
			return -1;
dvander@541
    40
		return 0;
dvander@541
    41
	}
dvander@541
    42
	CSourceHookImpl::CSourceHookImpl()
dvander@541
    43
	{
dvander@541
    44
	}
dvander@541
    45
	CSourceHookImpl::~CSourceHookImpl()
dvander@541
    46
	{
dvander@541
    47
	}
dvander@541
    48
dvander@541
    49
	int CSourceHookImpl::GetIfaceVersion()
dvander@541
    50
	{
dvander@541
    51
		return SH_IFACE_VERSION;
dvander@541
    52
	}
dvander@541
    53
dvander@541
    54
	int CSourceHookImpl::GetImplVersion()
dvander@541
    55
	{
dvander@541
    56
		return SH_IMPL_VERSION;
dvander@541
    57
	}
dvander@541
    58
dvander@541
    59
	bool CSourceHookImpl::IsPluginInUse(Plugin plug)
dvander@541
    60
	{
dvander@541
    61
		// Iterate through all hook managers which are in this plugin
dvander@541
    62
		// Iterate through their vfnptrs, ifaces, hooks
dvander@541
    63
		// If a hook from an other plugin is found, return true
dvander@541
    64
		// Return false otherwise
dvander@541
    65
#define TMP_CHECK_LIST(name) \
dvander@541
    66
	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
dvander@541
    67
		if (hook_iter->plug == plug) \
dvander@541
    68
			return true;
dvander@541
    69
dvander@541
    70
		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
dvander@541
    71
			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
dvander@541
    72
		{
dvander@541
    73
			for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
dvander@541
    74
				hmil_iter != hmcl_iter->end(); ++hmil_iter)
dvander@541
    75
			{
dvander@541
    76
				if (hmil_iter->m_Plug != plug)
dvander@541
    77
					continue;
dvander@541
    78
				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
dvander@541
    79
					vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
dvander@541
    80
				{
dvander@541
    81
					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
dvander@541
    82
						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
dvander@541
    83
					{
dvander@541
    84
						List<HookInfo>::iterator hook_iter;
dvander@541
    85
						TMP_CHECK_LIST(m_PreHooks);
dvander@541
    86
						TMP_CHECK_LIST(m_PostHooks);
dvander@541
    87
					}
dvander@541
    88
				}
dvander@541
    89
			}
dvander@541
    90
		}
dvander@541
    91
		
dvander@541
    92
#undef TMP_CHECK_LIST
dvander@541
    93
		return false;
dvander@541
    94
	}
dvander@541
    95
dvander@541
    96
	void CSourceHookImpl::UnloadPlugin(Plugin plug)
dvander@541
    97
	{
dvander@541
    98
		// 1) Manually remove all hooks by this plugin
dvander@541
    99
		// 2) Manually remove all hook mans by this plugin
dvander@541
   100
dvander@541
   101
		List<RemoveHookInfo> hookstoremove;
dvander@541
   102
		List<RemoveHookManInfo> hookmanstoremove;
dvander@541
   103
		HookManInfoList::iterator hmil_iter;
dvander@541
   104
dvander@541
   105
#define TMP_CHECK_LIST(name, ispost) \
dvander@541
   106
	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
dvander@541
   107
		if (hook_iter->plug == plug) \
dvander@541
   108
			hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
dvander@541
   109
			hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost)); \
dvander@541
   110
dvander@541
   111
		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
dvander@541
   112
			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
dvander@541
   113
		{
dvander@541
   114
			for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
dvander@541
   115
				hmil_iter != hmcl_iter->end(); ++hmil_iter)
dvander@541
   116
			{
dvander@541
   117
				if (hmil_iter->m_Plug == plug)
dvander@541
   118
					hookmanstoremove.push_back(RemoveHookManInfo(plug, hmil_iter->m_Func));
dvander@541
   119
dvander@541
   120
				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
dvander@541
   121
					vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
dvander@541
   122
				{
dvander@541
   123
					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
dvander@541
   124
						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
dvander@541
   125
					{
dvander@541
   126
						List<HookInfo>::iterator hook_iter;
dvander@541
   127
						TMP_CHECK_LIST(m_PreHooks, false);
dvander@541
   128
						TMP_CHECK_LIST(m_PostHooks, true);
dvander@541
   129
					}
dvander@541
   130
				}
dvander@541
   131
			}
dvander@541
   132
		}
dvander@541
   133
#undef TMP_CHECK_LIST
dvander@541
   134
dvander@541
   135
		for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
dvander@541
   136
			RemoveHook(*rmiter);
dvander@541
   137
dvander@541
   138
		for (List<RemoveHookManInfo>::iterator rmiter = hookmanstoremove.begin(); rmiter != hookmanstoremove.end(); ++rmiter)
dvander@541
   139
			RemoveHookManager(*rmiter);
dvander@541
   140
	}
dvander@541
   141
dvander@541
   142
	void CSourceHookImpl::RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc)
dvander@541
   143
	{
dvander@541
   144
		// Moo!
dvander@541
   145
dvander@541
   146
		CHookManagerInfo tmp;
dvander@541
   147
		if (pubFunc(HA_GetInfo, &tmp) != 0)
dvander@541
   148
			return;
dvander@541
   149
dvander@541
   150
		
dvander@541
   151
		HookManContList::iterator hmcl_iter = m_HookMans.find(
dvander@541
   152
			CHookManagerContainer::HMCI(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx));
dvander@541
   153
dvander@541
   154
		if (hmcl_iter == m_HookMans.end())
dvander@541
   155
		{
dvander@541
   156
			// Moo?
dvander@541
   157
			return;
dvander@541
   158
		}
dvander@541
   159
dvander@541
   160
		CHookManagerContainer::iterator hmil_iter = hmcl_iter->find(
dvander@541
   161
			CHookManagerInfo::Descriptor(plug, pubFunc));
dvander@541
   162
dvander@541
   163
		if (hmil_iter == hmcl_iter->end())
dvander@541
   164
		{
dvander@541
   165
			// Moo?
dvander@541
   166
			return;
dvander@541
   167
		}
dvander@541
   168
dvander@541
   169
		bool stillInUse = false;
dvander@541
   170
		List<RemoveHookInfo> hookstoremove;
dvander@541
   171
dvander@541
   172
		// Iterate through all of the hook manager's hooks. Remove all hooks from the hookman's plugin.
dvander@541
   173
#define TMP_CHECK_LIST(name, ispost) \
dvander@541
   174
	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
dvander@541
   175
		if (hook_iter->plug == plug) \
dvander@541
   176
			hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
dvander@541
   177
			hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost)); \
dvander@541
   178
		else \
dvander@541
   179
			stillInUse = true; \
dvander@541
   180
dvander@541
   181
		for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
dvander@541
   182
			vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
dvander@541
   183
		{
dvander@541
   184
			for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
dvander@541
   185
				iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
dvander@541
   186
			{
dvander@541
   187
				List<HookInfo>::iterator hook_iter;
dvander@541
   188
				TMP_CHECK_LIST(m_PreHooks, false);
dvander@541
   189
				TMP_CHECK_LIST(m_PostHooks, true);
dvander@541
   190
			}
dvander@541
   191
		}
dvander@541
   192
#undef TMP_CHECK_LIST
dvander@541
   193
dvander@541
   194
		for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
dvander@541
   195
			RemoveHook(*rmiter);
dvander@541
   196
dvander@541
   197
		CHookManagerInfo info = *hmil_iter;
dvander@541
   198
dvander@541
   199
		// Unlink the hook manager from the list
dvander@541
   200
		hmcl_iter->erase(hmil_iter);
dvander@541
   201
dvander@541
   202
		// If there were any hooks from other plugins, find a new suitable hook manager.
dvander@541
   203
		if (stillInUse)
dvander@541
   204
		{
dvander@541
   205
			// Find a suitable hook manager in an other plugin
dvander@541
   206
			hmil_iter = hmcl_iter->begin();
dvander@541
   207
dvander@541
   208
			// This should _never_ happen.
dvander@541
   209
			// If there is a hook from an other plugin, the plugin must have provided a hook manager as well.
dvander@541
   210
			SH_ASSERT(hmil_iter != hmcl_iter->end(),
dvander@541
   211
				("Could not find a suitable hook manager in an other plugin!"));
dvander@541
   212
dvander@541
   213
			// AddHook should make sure that every plugin only has _one_ hook manager for _one_ proto/vi/vo
dvander@541
   214
			SH_ASSERT(hmil_iter->m_Plug != plug, ("New hook manager from same plugin!"));
dvander@541
   215
dvander@541
   216
			// The first hook manager should be always used - so the new hook manager has to be empty
dvander@541
   217
			SH_ASSERT(hmil_iter->m_VfnPtrs.empty(), ("New hook manager not empty!"));
dvander@541
   218
dvander@541
   219
			// Move the vfnptrs from the old hook manager to the new one
dvander@541
   220
			hmil_iter->m_VfnPtrs = info.m_VfnPtrs;
dvander@541
   221
dvander@541
   222
			// Unregister the old one, register the new one
dvander@541
   223
			info.m_Func(HA_Unregister, NULL);
dvander@541
   224
			hmil_iter->m_Func(HA_Register, &(*hmil_iter));
dvander@541
   225
dvander@541
   226
			// Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
dvander@541
   227
			// or whatever
dvander@541
   228
			for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
dvander@541
   229
				vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
dvander@541
   230
			{
dvander@541
   231
				// And DEREFERENCE newHookMan->m_HookfuncVfnptr!
dvander@541
   232
				// otherwise it will be executing the vtable... had to find out the hard way
dvander@541
   233
				*reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = *reinterpret_cast<void**>(hmil_iter->m_HookfuncVfnptr);
dvander@541
   234
			}
dvander@541
   235
		}
dvander@541
   236
	}
dvander@541
   237
dvander@541
   238
	void CSourceHookImpl::RemoveHookManager(RemoveHookManInfo info)
dvander@541
   239
	{
dvander@541
   240
		RemoveHookManager(info.plug, info.hookman);
dvander@541
   241
	}
dvander@541
   242
dvander@541
   243
	void CSourceHookImpl::CompleteShutdown()
dvander@541
   244
	{
dvander@541
   245
		// Remove all hooks
dvander@541
   246
dvander@541
   247
		List<RemoveHookInfo> hookstoremove;
dvander@541
   248
dvander@541
   249
#define TMP_CHECK_LIST(name, ispost) \
dvander@541
   250
	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
dvander@541
   251
		hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
dvander@541
   252
			hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost))
dvander@541
   253
		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
dvander@541
   254
			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
dvander@541
   255
		{
dvander@541
   256
			for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
dvander@541
   257
				hmil_iter != hmcl_iter->end(); ++hmil_iter)
dvander@541
   258
			{
dvander@541
   259
				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
dvander@541
   260
					vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
dvander@541
   261
				{
dvander@541
   262
					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
dvander@541
   263
						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
dvander@541
   264
					{
dvander@541
   265
						List<HookInfo>::iterator hook_iter;
dvander@541
   266
						TMP_CHECK_LIST(m_PreHooks, false);
dvander@541
   267
						TMP_CHECK_LIST(m_PostHooks, true);
dvander@541
   268
					}
dvander@541
   269
				}
dvander@541
   270
			}
dvander@541
   271
		}
dvander@541
   272
#undef TMP_CHECK_LIST
dvander@541
   273
dvander@541
   274
		for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
dvander@541
   275
			RemoveHook(*rmiter);
dvander@541
   276
dvander@541
   277
		m_HookMans.clear();
dvander@541
   278
	}
dvander@541
   279
dvander@541
   280
	bool CSourceHookImpl::AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
dvander@541
   281
	{
dvander@541
   282
		void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
dvander@541
   283
dvander@541
   284
		// 1) Get info about the hook manager
dvander@541
   285
		CHookManagerInfo tmp;
dvander@541
   286
		if (myHookMan(HA_GetInfo, &tmp) != 0)
dvander@541
   287
			return false;
dvander@541
   288
dvander@541
   289
		tmp.m_Func = myHookMan;
dvander@541
   290
		tmp.m_Plug = plug;
dvander@541
   291
dvander@541
   292
		CHookManagerContainer::HMCI hmci(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx);
dvander@541
   293
dvander@541
   294
		void **cur_vtptr = *reinterpret_cast<void***>(
dvander@541
   295
			reinterpret_cast<char*>(adjustediface) + tmp.m_VtblOffs);
dvander@541
   296
		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.m_VtblIdx);
dvander@541
   297
dvander@541
   298
		// Add the container if not already added
dvander@541
   299
		HookManContList::iterator hmcl_iter = m_HookMans.find(hmci);
dvander@541
   300
		if (hmcl_iter == m_HookMans.end())
dvander@541
   301
		{
dvander@541
   302
			m_HookMans.push_back(CHookManagerContainer(hmci));
dvander@541
   303
			hmcl_iter = m_HookMans.end();
dvander@541
   304
			--hmcl_iter;
dvander@541
   305
		}
dvander@541
   306
dvander@541
   307
		hmcl_iter->AddHookManager(plug, tmp);
dvander@541
   308
dvander@541
   309
		CHookManagerContainer::iterator hookman = hmcl_iter->begin();
dvander@541
   310
		SH_ASSERT(hookman != hmcl_iter->end(), ("No hookman found - but we've just added one!"));
dvander@541
   311
dvander@541
   312
		// Check whether any other container holds a hook manager which holds this vfnptr
dvander@541
   313
		// If yes, it means that the two are incompatible, so return false.
dvander@541
   314
		for (HookManContList::iterator hmcl_iter2 = m_HookMans.begin();
dvander@541
   315
			hmcl_iter2 != m_HookMans.end(); ++hmcl_iter2)
dvander@541
   316
		{
dvander@541
   317
			if (hmcl_iter2 != hmcl_iter)
dvander@541
   318
			{
dvander@541
   319
				for (CHookManagerContainer::iterator hmil_iter = hmcl_iter2->begin();
dvander@541
   320
					hmil_iter != hmcl_iter2->end(); ++hmil_iter)
dvander@541
   321
				{
dvander@541
   322
					if (hmil_iter->m_VfnPtrs.find(cur_vfnptr) != hmil_iter->m_VfnPtrs.end())
dvander@541
   323
						return false;
dvander@541
   324
				}
dvander@541
   325
			}
dvander@541
   326
		}
dvander@541
   327
dvander@541
   328
		// Tell it to store the pointer if it's not already active
dvander@541
   329
		if (hookman->m_VfnPtrs.empty())
dvander@541
   330
			hookman->m_Func(HA_Register, &(*hookman));
dvander@541
   331
dvander@541
   332
		CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.find(cur_vfnptr);
dvander@541
   333
dvander@541
   334
		if (vfnptr_iter == hookman->m_VfnPtrs.end())
dvander@541
   335
		{
dvander@541
   336
			// Add a new one
dvander@541
   337
			CVfnPtr vfp(cur_vfnptr);
dvander@541
   338
dvander@541
   339
			// Alter vtable entry
dvander@541
   340
			if (!SetMemAccess(cur_vtptr, sizeof(void*) * (tmp.m_VtblIdx + 1), SH_MEM_READ | SH_MEM_WRITE))
dvander@541
   341
				return false;
dvander@541
   342
dvander@541
   343
			*reinterpret_cast<void**>(cur_vfnptr) = *reinterpret_cast<void**>(hookman->m_HookfuncVfnptr);
dvander@541
   344
dvander@541
   345
			hookman->m_VfnPtrs.push_back(vfp);
dvander@541
   346
dvander@541
   347
			// Make vfnptr_iter point to the new element
dvander@541
   348
			vfnptr_iter = hookman->m_VfnPtrs.end();
dvander@541
   349
			--vfnptr_iter;
dvander@541
   350
dvander@541
   351
			// Now that it is done, check whether we have to update any callclasses
dvander@541
   352
			ApplyCallClassPatches(adjustediface, tmp.m_VtblOffs, tmp.m_VtblIdx, vfp.m_OrigEntry);
dvander@541
   353
		}
dvander@541
   354
dvander@541
   355
		CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.find(adjustediface);
dvander@541
   356
		if (iface_iter == vfnptr_iter->m_Ifaces.end())
dvander@541
   357
		{
dvander@541
   358
			// Add a new one
dvander@541
   359
			vfnptr_iter->m_Ifaces.push_back(CIface(adjustediface));
dvander@541
   360
dvander@541
   361
			// Make iface_iter point to the new element
dvander@541
   362
			iface_iter = vfnptr_iter->m_Ifaces.end();
dvander@541
   363
			--iface_iter;
dvander@541
   364
		}
dvander@541
   365
dvander@541
   366
		// Add the hook
dvander@541
   367
		HookInfo hookinfo;
dvander@541
   368
		hookinfo.handler = handler;
dvander@541
   369
		hookinfo.plug = plug;
dvander@541
   370
		hookinfo.paused = false;
dvander@541
   371
		hookinfo.thisptr_offs = thisptr_offs;
dvander@541
   372
		if (post)
dvander@541
   373
			iface_iter->m_PostHooks.m_List.push_back(hookinfo);
dvander@541
   374
		else
dvander@541
   375
			iface_iter->m_PreHooks.m_List.push_back(hookinfo);
dvander@541
   376
dvander@541
   377
		return true;
dvander@541
   378
	}
dvander@541
   379
dvander@541
   380
	bool CSourceHookImpl::RemoveHook(RemoveHookInfo info)
dvander@541
   381
	{
dvander@541
   382
		return RemoveHook(info.plug, info.iface, info.thisptr_offs, info.hookman, info.handler, info.post);
dvander@541
   383
	}
dvander@541
   384
dvander@541
   385
	bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
dvander@541
   386
	{
dvander@541
   387
		void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
dvander@541
   388
		CHookManagerInfo tmp;
dvander@541
   389
		if (myHookMan(HA_GetInfo, &tmp) != 0)
dvander@541
   390
			return false;
dvander@541
   391
dvander@541
   392
		// Find the hook manager and the hook
dvander@541
   393
dvander@541
   394
		HookManContList::iterator hmcl_iter = m_HookMans.find(
dvander@541
   395
			CHookManagerContainer::HMCI(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx));
dvander@541
   396
		if (hmcl_iter == m_HookMans.end() || hmcl_iter->empty())
dvander@541
   397
			return false;
dvander@541
   398
		
dvander@541
   399
		CHookManagerContainer::iterator hookman = hmcl_iter->begin();
dvander@541
   400
dvander@541
   401
		if (!ModuleInMemory(reinterpret_cast<char*>(adjustediface) + tmp.m_VtblOffs,
dvander@541
   402
			sizeof(void*) * (tmp.m_VtblIdx + 1)))
dvander@541
   403
		{
dvander@541
   404
			// The module the vtable was in is already unloaded.
dvander@541
   405
			hookman->m_VfnPtrs.clear();
dvander@541
   406
			hookman->m_Func(HA_Unregister, NULL);
dvander@541
   407
			return true;
dvander@541
   408
		}
dvander@541
   409
dvander@541
   410
		void **cur_vtptr = *reinterpret_cast<void***>(
dvander@541
   411
			reinterpret_cast<char*>(adjustediface) + tmp.m_VtblOffs);
dvander@541
   412
		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.m_VtblIdx);
dvander@541
   413
dvander@541
   414
		CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.find(cur_vfnptr);
dvander@541
   415
dvander@541
   416
		if (vfnptr_iter == hookman->m_VfnPtrs.end())
dvander@541
   417
			return false;
dvander@541
   418
dvander@541
   419
		for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
dvander@541
   420
			iface_iter != vfnptr_iter->m_Ifaces.end();)
dvander@541
   421
		{
dvander@541
   422
			if (iface_iter->m_Ptr != adjustediface)
dvander@541
   423
			{
dvander@541
   424
				iface_iter++;
dvander@541
   425
				continue;
dvander@541
   426
			}
dvander@541
   427
			List<HookInfo> &hooks =
dvander@541
   428
				post ? iface_iter->m_PostHooks.m_List : iface_iter->m_PreHooks.m_List;
dvander@541
   429
dvander@541
   430
			bool erase;
dvander@541
   431
			for (List<HookInfo>::iterator hookiter = hooks.begin();
dvander@541
   432
				hookiter != hooks.end(); )
dvander@541
   433
			{
dvander@541
   434
				erase = hookiter->plug == plug && hookiter->handler->IsEqual(handler) &&
dvander@541
   435
					hookiter->thisptr_offs == thisptr_offs;
dvander@541
   436
				if (erase)
dvander@541
   437
				{
dvander@541
   438
					hookiter->handler->DeleteThis();			// Make the _plugin_ delete the handler object
dvander@541
   439
dvander@541
   440
					// Move all iterators pointing at this
dvander@541
   441
					List<HookInfo>::iterator oldhookiter = hookiter;
dvander@541
   442
					hookiter = hooks.erase(hookiter);
dvander@541
   443
					List<HookInfo>::iterator newhookiter = hookiter;
dvander@541
   444
					--newhookiter; // The hook loop will ++ it then
dvander@541
   445
					CHookList::CIter *pItIter;
dvander@541
   446
					for (pItIter = iface_iter->m_PreHooks.m_UsedIters; pItIter; pItIter = pItIter->m_pNext)
dvander@541
   447
						if (pItIter->m_Iter == oldhookiter)
dvander@541
   448
							pItIter->m_Iter = newhookiter;
dvander@541
   449
				}
dvander@541
   450
				else
dvander@541
   451
					++hookiter;
dvander@541
   452
			}
dvander@541
   453
			if (iface_iter->m_PostHooks.m_List.empty() && iface_iter->m_PreHooks.m_List.empty())
dvander@541
   454
			{
dvander@541
   455
				// There are no hooks on this iface anymore...
dvander@541
   456
				for (HookLoopInfoStack::iterator hli_iter = m_HLIStack.begin();
dvander@541
   457
					hli_iter != m_HLIStack.end(); ++hli_iter)
dvander@541
   458
				{
dvander@541
   459
					if (hli_iter->pCurIface == static_cast<IIface*>(&(*iface_iter)))
dvander@541
   460
						hli_iter->shouldContinue = false;
dvander@541
   461
				}
dvander@541
   462
dvander@541
   463
				iface_iter = vfnptr_iter->m_Ifaces.erase(iface_iter);
dvander@541
   464
				if (vfnptr_iter->m_Ifaces.empty())
dvander@541
   465
				{
dvander@541
   466
					// No ifaces at all -> Deactivate the hook
dvander@541
   467
					*reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = vfnptr_iter->m_OrigEntry;
dvander@541
   468
dvander@541
   469
					hookman->m_VfnPtrs.erase(vfnptr_iter);
dvander@541
   470
dvander@541
   471
					// Remove callclass patch
dvander@541
   472
					for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
dvander@541
   473
						if (cciter->m_Ptr == adjustediface)
dvander@541
   474
							cciter->RemoveCallClassPatch(tmp.m_VtblOffs, tmp.m_VtblIdx);
dvander@541
   475
dvander@541
   476
					if (hookman->m_VfnPtrs.empty())
dvander@541
   477
					{
dvander@541
   478
						// Unregister the hook manager
dvander@541
   479
						hookman->m_Func(HA_Unregister, NULL);
dvander@541
   480
					}
dvander@541
   481
dvander@541
   482
					// Don't try to continue looping through ifaces
dvander@541
   483
					// - the list is already invalid
dvander@541
   484
					return true;
dvander@541
   485
				}
dvander@541
   486
			}
dvander@541
   487
			else
dvander@541
   488
				++iface_iter;
dvander@541
   489
		}
dvander@541
   490
		return true;
dvander@541
   491
	}
dvander@541
   492
dvander@541
   493
	GenericCallClass *CSourceHookImpl::GetCallClass(void *iface, size_t size)
dvander@541
   494
	{
dvander@541
   495
		for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
dvander@541
   496
		{
dvander@541
   497
			if (cciter->m_Ptr == iface && cciter->m_ObjSize == size)
dvander@541
   498
			{
dvander@541
   499
				++cciter->m_RefCounter;
dvander@541
   500
				return &(*cciter);
dvander@541
   501
			}
dvander@541
   502
		}
dvander@541
   503
dvander@541
   504
		// Make a new one
dvander@541
   505
dvander@541
   506
		CCallClassImpl tmp(iface, size);
dvander@541
   507
		ApplyCallClassPatches(tmp);
dvander@541
   508
		m_CallClasses.push_back(tmp);
dvander@541
   509
		return &m_CallClasses.back();
dvander@541
   510
	}
dvander@541
   511
dvander@541
   512
	void CSourceHookImpl::ReleaseCallClass(GenericCallClass *ptr)
dvander@541
   513
	{
dvander@541
   514
		Impl_CallClassList::iterator iter = m_CallClasses.find(ptr);
dvander@541
   515
		if (iter == m_CallClasses.end())
dvander@541
   516
			return;
dvander@541
   517
		--iter->m_RefCounter;
dvander@541
   518
		if (iter->m_RefCounter < 1)
dvander@541
   519
			m_CallClasses.erase(iter);
dvander@541
   520
	}
dvander@541
   521
dvander@541
   522
	void CSourceHookImpl::ApplyCallClassPatches(CCallClassImpl &cc)
dvander@541
   523
	{
dvander@541
   524
		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
dvander@541
   525
			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
dvander@541
   526
		{
dvander@541
   527
			for (CHookManagerContainer::iterator hookman = hmcl_iter->begin();
dvander@541
   528
				hookman != hmcl_iter->end(); ++hookman)
dvander@541
   529
			{
dvander@541
   530
				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.begin();
dvander@541
   531
					vfnptr_iter != hookman->m_VfnPtrs.end(); ++vfnptr_iter)
dvander@541
   532
				{
dvander@541
   533
					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
dvander@541
   534
						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
dvander@541
   535
					{
dvander@541
   536
						if (iface_iter->m_Ptr >= cc.m_Ptr &&
dvander@541
   537
							iface_iter->m_Ptr < (reinterpret_cast<char*>(cc.m_Ptr) + cc.m_ObjSize))
dvander@541
   538
						{
dvander@541
   539
							cc.ApplyCallClassPatch(static_cast<int>(reinterpret_cast<char*>(iface_iter->m_Ptr) -
dvander@541
   540
								reinterpret_cast<char*>(cc.m_Ptr)) + hookman->m_VtblOffs,
dvander@541
   541
								hookman->m_VtblIdx, vfnptr_iter->m_OrigEntry);
dvander@541
   542
						}
dvander@541
   543
					}
dvander@541
   544
				}
dvander@541
   545
			}
dvander@541
   546
		}
dvander@541
   547
	}
dvander@541
   548
dvander@541
   549
	void CSourceHookImpl::ApplyCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx, void *orig_entry)
dvander@541
   550
	{
dvander@541
   551
		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
dvander@541
   552
			++cc_iter)
dvander@541
   553
		{
dvander@541
   554
			if (ifaceptr >= cc_iter->m_Ptr &&
dvander@541
   555
				ifaceptr < (reinterpret_cast<char*>(cc_iter->m_Ptr) + cc_iter->m_ObjSize))
dvander@541
   556
			{
dvander@541
   557
				cc_iter->ApplyCallClassPatch(static_cast<int>(reinterpret_cast<char*>(ifaceptr) -
dvander@541
   558
					reinterpret_cast<char*>(cc_iter->m_Ptr)) + vtbl_offs, vtbl_idx, orig_entry);
dvander@541
   559
			}
dvander@541
   560
		}
dvander@541
   561
	}
dvander@541
   562
dvander@541
   563
	void CSourceHookImpl::RemoveCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx)
dvander@541
   564
	{
dvander@541
   565
		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
dvander@541
   566
			++cc_iter)
dvander@541
   567
		{
dvander@541
   568
			if (ifaceptr >= cc_iter->m_Ptr &&
dvander@541
   569
				ifaceptr < (reinterpret_cast<char*>(cc_iter->m_Ptr) + cc_iter->m_ObjSize))
dvander@541
   570
			{
dvander@541
   571
				cc_iter->RemoveCallClassPatch(vtbl_offs, vtbl_idx);
dvander@541
   572
			}
dvander@541
   573
		}
dvander@541
   574
	}
dvander@541
   575
dvander@541
   576
	void CSourceHookImpl::SetPluginPaused(Plugin plug, bool paused)
dvander@541
   577
	{
dvander@541
   578
		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
dvander@541
   579
		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
dvander@541
   580
			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
dvander@541
   581
		{
dvander@541
   582
			for (CHookManagerContainer::iterator hookmaniter = hmcl_iter->begin();
dvander@541
   583
				hookmaniter != hmcl_iter->end(); ++hookmaniter)
dvander@541
   584
			{
dvander@541
   585
				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->m_VfnPtrs.begin();
dvander@541
   586
					vfnptr_iter != hookmaniter->m_VfnPtrs.end(); ++vfnptr_iter)
dvander@541
   587
				{
dvander@541
   588
					for (CVfnPtr::IfaceListIter ifaceiter = vfnptr_iter->m_Ifaces.begin();
dvander@541
   589
						ifaceiter != vfnptr_iter->m_Ifaces.end(); ++ifaceiter)
dvander@541
   590
					{
dvander@541
   591
						for (List<HookInfo>::iterator hookiter = ifaceiter->m_PreHooks.m_List.begin();
dvander@541
   592
							hookiter != ifaceiter->m_PreHooks.m_List.end(); ++hookiter)
dvander@541
   593
							if (plug == hookiter->plug)
dvander@541
   594
								hookiter->paused = paused;
dvander@541
   595
dvander@541
   596
						for (List<HookInfo>::iterator hookiter = ifaceiter->m_PostHooks.m_List.begin();
dvander@541
   597
							hookiter != ifaceiter->m_PostHooks.m_List.end(); ++hookiter)
dvander@541
   598
							if (plug == hookiter->plug)
dvander@541
   599
								hookiter->paused = paused;
dvander@541
   600
					}
dvander@541
   601
				}
dvander@541
   602
			}
dvander@541
   603
		}
dvander@541
   604
	}
dvander@541
   605
	void CSourceHookImpl::PausePlugin(Plugin plug)
dvander@541
   606
	{
dvander@541
   607
		SetPluginPaused(plug, true);
dvander@541
   608
	}
dvander@541
   609
dvander@541
   610
	void CSourceHookImpl::UnpausePlugin(Plugin plug)
dvander@541
   611
	{
dvander@541
   612
		SetPluginPaused(plug, false);
dvander@541
   613
	}
dvander@541
   614
dvander@541
   615
	void CSourceHookImpl::HookLoopBegin(IIface *pIface)
dvander@541
   616
	{
dvander@541
   617
		HookLoopInfo hli;
dvander@541
   618
		hli.pCurIface = pIface;
dvander@541
   619
		hli.shouldContinue = true;
dvander@541
   620
		hli.recall = HookLoopInfo::Recall_No;
dvander@541
   621
dvander@541
   622
		static_cast<CIface*>(pIface)->m_PreHooks.RQFlagReset();
dvander@541
   623
		static_cast<CIface*>(pIface)->m_PostHooks.RQFlagReset();
dvander@541
   624
dvander@541
   625
		m_HLIStack.push(hli);
dvander@541
   626
	}
dvander@541
   627
dvander@541
   628
	void CSourceHookImpl::HookLoopEnd()
dvander@541
   629
	{
dvander@541
   630
		// When in a post recall... make sure status is high enough so that it returns the orig ret.
dvander@541
   631
		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
dvander@541
   632
			*m_HLIStack.front().pStatus = MRES_SUPERCEDE;			// THAT'LL TEACH THEM!
dvander@541
   633
		m_HLIStack.pop();
dvander@541
   634
	}
dvander@541
   635
dvander@541
   636
	void CSourceHookImpl::SetRes(META_RES res)
dvander@541
   637
	{
dvander@541
   638
		*m_HLIStack.front().pCurRes = res;
dvander@541
   639
	}
dvander@541
   640
dvander@541
   641
	META_RES CSourceHookImpl::GetPrevRes()
dvander@541
   642
	{
dvander@541
   643
		return *m_HLIStack.front().pPrevRes;
dvander@541
   644
	}
dvander@541
   645
dvander@541
   646
	META_RES CSourceHookImpl::GetStatus()
dvander@541
   647
	{
dvander@541
   648
		return *m_HLIStack.front().pStatus;
dvander@541
   649
	}
dvander@541
   650
dvander@541
   651
	const void *CSourceHookImpl::GetOrigRet()
dvander@541
   652
	{
dvander@541
   653
		// When in a post recall... return the orig ret of the previous hookloop.
dvander@541
   654
		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
dvander@541
   655
			return m_HLIStack.second().pOrigRet;
dvander@541
   656
dvander@541
   657
		return m_HLIStack.front().pOrigRet;
dvander@541
   658
	}
dvander@541
   659
dvander@541
   660
	const void *CSourceHookImpl::GetOverrideRet()
dvander@541
   661
	{
dvander@541
   662
		// pOverrideRet is always set since recalls were introduced
dvander@541
   663
		// GetOverrideRetPtr was added; a function which always returns pOverrideRet
dvander@541
   664
		// so that RETURN_META_VALUE_NEWPARAMS can provide an override result
dvander@541
   665
dvander@541
   666
		// This means that we have to filter GetOverrideRet:
dvander@541
   667
		//  If the status variable is < MRES_OVERRIDE, return NULL.
dvander@541
   668
dvander@541
   669
		return (*m_HLIStack.front().pStatus < MRES_OVERRIDE) ?
dvander@541
   670
			NULL : m_HLIStack.front().pOverrideRet;
dvander@541
   671
	}
dvander@541
   672
dvander@541
   673
	void *CSourceHookImpl::GetOverrideRetPtr()
dvander@541
   674
	{
dvander@541
   675
		// As described in the comment above: always return pOverrideRet
dvander@541
   676
		return m_HLIStack.front().pOverrideRet;
dvander@541
   677
	}
dvander@541
   678
dvander@541
   679
	void *CSourceHookImpl::GetIfacePtr()
dvander@541
   680
	{
dvander@541
   681
		return *m_HLIStack.front().pIfacePtrPtr;
dvander@541
   682
	}
dvander@541
   683
dvander@541
   684
	void CSourceHookImpl::SetCurResPtr(META_RES *mres)
dvander@541
   685
	{
dvander@541
   686
		m_HLIStack.front().pCurRes = mres;
dvander@541
   687
	}
dvander@541
   688
dvander@541
   689
	void CSourceHookImpl::SetPrevResPtr(META_RES *mres)
dvander@541
   690
	{
dvander@541
   691
		m_HLIStack.front().pPrevRes = mres;
dvander@541
   692
dvander@541
   693
		// If we're recalling, drag the previous mres value to the new hookfunc
dvander@541
   694
		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
dvander@541
   695
			*mres = *m_HLIStack.second().pPrevRes;
dvander@541
   696
	}
dvander@541
   697
dvander@541
   698
	void CSourceHookImpl::SetStatusPtr(META_RES *mres)
dvander@541
   699
	{
dvander@541
   700
		m_HLIStack.front().pStatus = mres;
dvander@541
   701
dvander@541
   702
		// If we're recalling, drag the previous mres value to the new hookfunc
dvander@541
   703
		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
dvander@541
   704
			*mres = *m_HLIStack.second().pStatus;
dvander@541
   705
	}
dvander@541
   706
dvander@541
   707
	void CSourceHookImpl::SetIfacePtrPtr(void **pp)
dvander@541
   708
	{
dvander@541
   709
		m_HLIStack.front().pIfacePtrPtr = pp;
dvander@541
   710
	}
dvander@541
   711
dvander@541
   712
	void CSourceHookImpl::SetOrigRetPtr(const void *ptr)
dvander@541
   713
	{
dvander@541
   714
		m_HLIStack.front().pOrigRet = ptr;
dvander@541
   715
	}
dvander@541
   716
	void CSourceHookImpl::SetOverrideRetPtr(void *ptr)
dvander@541
   717
	{
dvander@541
   718
		m_HLIStack.front().pOverrideRet = ptr;
dvander@541
   719
	}
dvander@541
   720
dvander@541
   721
	// New function which does all of the above + more :)
dvander@541
   722
	void *CSourceHookImpl::SetupHookLoop(META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr,
dvander@541
   723
		void **ifacePtrPtr, const void *origRetPtr, void *overrideRetPtr)
dvander@541
   724
	{
dvander@541
   725
		HookLoopInfo &hli = m_HLIStack.front();
dvander@541
   726
		hli.pStatus = statusPtr;
dvander@541
   727
		hli.pPrevRes = prevResPtr;
dvander@541
   728
		hli.pCurRes = curResPtr;
dvander@541
   729
		hli.pIfacePtrPtr = ifacePtrPtr;
dvander@541
   730
		hli.pOrigRet = origRetPtr;
dvander@541
   731
dvander@541
   732
		// Handle some recall stuff
dvander@541
   733
		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
dvander@541
   734
		{
dvander@541
   735
			HookLoopInfo &other = m_HLIStack.second();
dvander@541
   736
			*statusPtr = *other.pStatus;
dvander@541
   737
			*prevResPtr = *other.pStatus;
dvander@541
   738
dvander@541
   739
			// When the status is low so there's no override return value and we're in a post recall,
dvander@541
   740
			// give it the orig return value as override return value.
dvander@541
   741
			if (*statusPtr < MRES_OVERRIDE && other.recall == HookLoopInfo::Recall_Post1)
dvander@541
   742
				hli.pOverrideRet = const_cast<void*>(other.pOrigRet);
dvander@541
   743
			else	// Otherwise, transfer override ret normally
dvander@541
   744
				hli.pOverrideRet = other.pOverrideRet;
dvander@541
   745
		}
dvander@541
   746
		else
dvander@541
   747
			hli.pOverrideRet = overrideRetPtr;
dvander@541
   748
dvander@541
   749
		// Tell the hook func which override ret ptr to use
dvander@541
   750
		return hli.pOverrideRet;
dvander@541
   751
	}
dvander@541
   752
dvander@541
   753
	bool CSourceHookImpl::ShouldContinue()
dvander@541
   754
	{
dvander@541
   755
		// Post-recalls:
dvander@541
   756
		//  The second element on the stack has recall set to Recall_Post1.
dvander@541
   757
		//  This means that we want to skip this part and the original function calling thing, so
dvander@541
   758
		//  we store the status mres value, set status to MRES_SUPERCEDE, and return false.
dvander@541
   759
		//  We also set the recall flag to Recall_Post2, so the next time the thing calls us, we
dvander@541
   760
		//  can return true (so that the thing goes into post hooks).
dvander@541
   761
		if (m_HLIStack.size() > 1)
dvander@541
   762
		{
dvander@541
   763
			if (m_HLIStack.second().recall == HookLoopInfo::Recall_Post1)
dvander@541
   764
			{
dvander@541
   765
				m_HLIStack.front().temporaryStatus = *m_HLIStack.front().pStatus;
dvander@541
   766
				*m_HLIStack.front().pStatus = MRES_SUPERCEDE;
dvander@541
   767
				m_HLIStack.second().recall = HookLoopInfo::Recall_Post2;
dvander@541
   768
				return false;
dvander@541
   769
			}
dvander@541
   770
			else if (m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
dvander@541
   771
			{
dvander@541
   772
				*m_HLIStack.front().pStatus = m_HLIStack.front().temporaryStatus;
dvander@541
   773
				return m_HLIStack.front().shouldContinue;
dvander@541
   774
			}
dvander@541
   775
		}
dvander@541
   776
dvander@541
   777
		// 16.01.2008: We used to return false for recalls here.
dvander@541
   778
		// This caused the hook funcs to think that the whole iface has been destroyed
dvander@541
   779
		// (the original purpose of shouldcontinue was to notify the hookfuncs that everything has been
dvander@541
   780
		// invalidated by RemoveHook) so they did not release their iterator. -> Leaks
dvander@541
   781
		// Now, GetIter sets the iterator to END so it still gets released but the hooks don't continue.
dvander@541
   782
		
dvander@541
   783
		// But: we have to return false in the post phase of pre recalls (ie. a pre hook made a recall).
dvander@541
   784
		if (m_HLIStack.front().recall == HookLoopInfo::Recall_Pre &&
dvander@541
   785
			static_cast<CIface*>(m_HLIStack.front().pCurIface)->m_PreHooks.RelFlagGet())
dvander@541
   786
		{
dvander@541
   787
			return false;
dvander@541
   788
		}
dvander@541
   789
dvander@541
   790
		return m_HLIStack.front().shouldContinue;
dvander@541
   791
	}
dvander@541
   792
dvander@541
   793
	void CSourceHookImpl::DoRecall()
dvander@541
   794
	{
dvander@541
   795
		if (!m_HLIStack.empty())
dvander@541
   796
		{
dvander@541
   797
			// Also watch out for post recalls! Described at the beginning of sourcehook_impl.h
dvander@541
   798
			m_HLIStack.front().recall =
dvander@541
   799
				static_cast<CIface*>(m_HLIStack.front().pCurIface)->m_PostHooks.RQFlagGet() ?
dvander@541
   800
				HookLoopInfo::Recall_Post1 : HookLoopInfo::Recall_Pre;
dvander@541
   801
			
dvander@541
   802
			CHookList *mlist = static_cast<CHookList*>(m_HLIStack.front().recall == HookLoopInfo::Recall_Pre ? 
dvander@541
   803
				m_HLIStack.front().pCurIface->GetPreHooks() : m_HLIStack.front().pCurIface->GetPostHooks());
dvander@541
   804
			mlist->m_Recall = true;
dvander@541
   805
dvander@541
   806
			// The hookfunc usually does this, but it won't have a chance to see it, 
dvander@541
   807
			// so for recalls, we update status here if it's required
dvander@541
   808
			if (*m_HLIStack.front().pCurRes > *m_HLIStack.front().pStatus) 
dvander@541
   809
				*m_HLIStack.front().pStatus = *m_HLIStack.front().pCurRes;
dvander@541
   810
dvander@541
   811
		}
dvander@541
   812
	}
dvander@541
   813
dvander@541
   814
	////////////////////////////
dvander@541
   815
	// CCallClassImpl
dvander@541
   816
	////////////////////////////
dvander@541
   817
	CSourceHookImpl::CCallClassImpl::CCallClassImpl(void *ptr, size_t size)
dvander@541
   818
		: m_Ptr(ptr), m_ObjSize(size), m_RefCounter(1)
dvander@541
   819
	{
dvander@541
   820
	}
dvander@541
   821
	CSourceHookImpl::CCallClassImpl::~CCallClassImpl()
dvander@541
   822
	{
dvander@541
   823
	}
dvander@541
   824
dvander@541
   825
	void *CSourceHookImpl::CCallClassImpl::GetThisPtr()
dvander@541
   826
	{
dvander@541
   827
		return m_Ptr;
dvander@541
   828
	}
dvander@541
   829
	void *CSourceHookImpl::CCallClassImpl::GetOrigFunc(int vtbloffs, int vtblidx)
dvander@541
   830
	{
dvander@541
   831
		OrigVTables::iterator iter = m_VT.find(vtbloffs);
dvander@541
   832
		if (iter != m_VT.end() && iter->val.size() > (size_t)vtblidx)
dvander@541
   833
		{
dvander@541
   834
			return iter->val[vtblidx];
dvander@541
   835
		}
dvander@541
   836
		return NULL;
dvander@541
   837
	}
dvander@541
   838
dvander@541
   839
	void CSourceHookImpl::CCallClassImpl::ApplyCallClassPatch(int vtbl_offs, int vtbl_idx, void *orig_entry)
dvander@541
   840
	{
dvander@541
   841
		OrigFuncs &tmpvec = m_VT[vtbl_offs];
dvander@541
   842
		if (tmpvec.size() <= (size_t)vtbl_idx)
dvander@541
   843
			tmpvec.resize(vtbl_idx+1, NULL);
dvander@541
   844
		tmpvec[vtbl_idx] = orig_entry;
dvander@541
   845
	}
dvander@541
   846
	void CSourceHookImpl::CCallClassImpl::RemoveCallClassPatch(int vtbl_offs, int vtbl_idx)
dvander@541
   847
	{
dvander@541
   848
		OrigVTables::iterator iter = m_VT.find(vtbl_offs);
dvander@541
   849
		if (iter != m_VT.end())
dvander@541
   850
		{
dvander@541
   851
			if (iter->val.size() > (size_t)vtbl_idx)
dvander@541
   852
			{
dvander@541
   853
				iter->val[vtbl_idx] = 0;
dvander@541
   854
dvander@541
   855
				OrigFuncs &of = iter->val;
dvander@541
   856
				OrigFuncs::iterator lastused = of.end();
dvander@541
   857
				for (OrigFuncs::iterator viter = of.begin(); viter != of.end(); ++viter)
dvander@541
   858
				{
dvander@541
   859
					if (*viter)
dvander@541
   860
						lastused = viter;
dvander@541
   861
				}
dvander@541
   862
				if (lastused == of.end())
dvander@541
   863
				{
dvander@541
   864
					// No used element => Remove the whole vector
dvander@541
   865
					m_VT.erase(iter);
dvander@541
   866
					return;
dvander@541
   867
				}
dvander@541
   868
				of.resize(lastused - of.begin() + 1);
dvander@541
   869
			}
dvander@541
   870
		}
dvander@541
   871
	}
dvander@541
   872
dvander@541
   873
	////////////////////////////
dvander@541
   874
	// CHookManagerInfo
dvander@541
   875
	////////////////////////////
dvander@541
   876
	CSourceHookImpl::CHookManagerInfo::CHookManagerInfo() : m_HookManVersion(0)
dvander@541
   877
	{
dvander@541
   878
	}
dvander@541
   879
	CSourceHookImpl::CHookManagerInfo::~CHookManagerInfo()
dvander@541
   880
	{
dvander@541
   881
	}
dvander@541
   882
dvander@541
   883
	IVfnPtr *CSourceHookImpl::CHookManagerInfo::FindVfnPtr(void *vfnptr)
dvander@541
   884
	{
dvander@541
   885
		VfnPtrListIter iter = m_VfnPtrs.find(vfnptr);
dvander@541
   886
		return iter == m_VfnPtrs.end() ? NULL : &(*iter);
dvander@541
   887
	}
dvander@541
   888
	void CSourceHookImpl::CHookManagerInfo::SetInfo(int vtbl_offs, int vtbl_idx, const char *proto)
dvander@541
   889
	{
dvander@541
   890
		m_VtblOffs = vtbl_offs;
dvander@541
   891
		m_VtblIdx = vtbl_idx;
dvander@541
   892
		m_Proto = proto;
dvander@541
   893
	}
dvander@541
   894
	void CSourceHookImpl::CHookManagerInfo::SetHookfuncVfnptr(void *hookfunc_vfnptr)
dvander@541
   895
	{
dvander@541
   896
		m_HookfuncVfnptr = hookfunc_vfnptr;
dvander@541
   897
	}
dvander@541
   898
	void CSourceHookImpl::CHookManagerInfo::SetVersion(int version)
dvander@541
   899
	{
dvander@541
   900
		m_HookManVersion = version;
dvander@541
   901
	}
dvander@541
   902
	////////////////////////////
dvander@541
   903
	// CVfnPtr
dvander@541
   904
	////////////////////////////
dvander@541
   905
dvander@541
   906
dvander@541
   907
	// If you get a crash here, the ptr passed is invalid
dvander@541
   908
	// This usually means a SH_DECL_MANUALHOOK* with wrong thisptroffs/vtbloffs/vtblidx
dvander@541
   909
	CSourceHookImpl::CVfnPtr::CVfnPtr(void *ptr) : m_Ptr(ptr), m_OrigEntry(*reinterpret_cast<void**>(ptr))
dvander@541
   910
	{
dvander@541
   911
	}
dvander@541
   912
	CSourceHookImpl::CVfnPtr::~CVfnPtr()
dvander@541
   913
	{
dvander@541
   914
	}
dvander@541
   915
dvander@541
   916
	void *CSourceHookImpl::CVfnPtr::GetVfnPtr()
dvander@541
   917
	{
dvander@541
   918
		return m_Ptr;
dvander@541
   919
	}
dvander@541
   920
dvander@541
   921
	void *CSourceHookImpl::CVfnPtr::GetOrigEntry()
dvander@541
   922
	{
dvander@541
   923
		return m_OrigEntry;
dvander@541
   924
	}
dvander@541
   925
dvander@541
   926
	IIface *CSourceHookImpl::CVfnPtr::FindIface(void *ptr)
dvander@541
   927
	{
dvander@541
   928
		IfaceListIter iter = m_Ifaces.find(ptr);
dvander@541
   929
		return iter == m_Ifaces.end() ? NULL : &(*iter);
dvander@541
   930
	}
dvander@541
   931
dvander@541
   932
	////////////////////////////
dvander@541
   933
	// CIface
dvander@541
   934
	////////////////////////////
dvander@541
   935
	CSourceHookImpl::CIface::CIface(void *ptr) : m_Ptr(ptr)
dvander@541
   936
	{
dvander@541
   937
	}
dvander@541
   938
	CSourceHookImpl::CIface::~CIface()
dvander@541
   939
	{
dvander@541
   940
	}
dvander@541
   941
dvander@541
   942
	void *CSourceHookImpl::CIface::GetPtr()
dvander@541
   943
	{
dvander@541
   944
		return m_Ptr;
dvander@541
   945
	}
dvander@541
   946
dvander@541
   947
	IHookList *CSourceHookImpl::CIface::GetPreHooks()
dvander@541
   948
	{
dvander@541
   949
		return &m_PreHooks;
dvander@541
   950
	}
dvander@541
   951
	IHookList *CSourceHookImpl::CIface::GetPostHooks()
dvander@541
   952
	{
dvander@541
   953
		return &m_PostHooks;
dvander@541
   954
	}
dvander@541
   955
dvander@541
   956
	////////////////////////////
dvander@541
   957
	// CHookList
dvander@541
   958
	////////////////////////////
dvander@541
   959
dvander@541
   960
	CSourceHookImpl::CHookList::CHookList() : m_FreeIters(NULL), m_UsedIters(NULL),
dvander@541
   961
		m_Recall(false)
dvander@541
   962
	{
dvander@541
   963
	}
dvander@541
   964
	CSourceHookImpl::CHookList::CHookList(const CHookList &other) : m_List(other.m_List),
dvander@541
   965
		m_FreeIters(NULL), m_UsedIters(NULL), m_Recall(false)
dvander@541
   966
	{
dvander@541
   967
	}
dvander@541
   968
dvander@541
   969
	CSourceHookImpl::CHookList::~CHookList()
dvander@541
   970
	{
dvander@541
   971
		while (m_FreeIters)
dvander@541
   972
		{
dvander@541
   973
			CIter *iter = m_FreeIters->m_pNext;
dvander@541
   974
			delete m_FreeIters;
dvander@541
   975
			m_FreeIters = iter;
dvander@541
   976
		}
dvander@541
   977
		while (m_UsedIters)
dvander@541
   978
		{
dvander@541
   979
			CIter *iter = m_UsedIters->m_pNext;
dvander@541
   980
			delete m_UsedIters;
dvander@541
   981
			m_UsedIters = iter;
dvander@541
   982
		}
dvander@541
   983
	}
dvander@541
   984
	IHookList::IIter *CSourceHookImpl::CHookList::GetIter()
dvander@541
   985
	{
dvander@541
   986
		m_RQFlag = true;
dvander@541
   987
dvander@541
   988
		CIter *ret;
dvander@541
   989
		if (m_FreeIters)
dvander@541
   990
		{
dvander@541
   991
			ret = m_FreeIters;
dvander@541
   992
			m_FreeIters = ret->m_pNext;
dvander@541
   993
			ret->GoToBegin();
dvander@541
   994
		}
dvander@541
   995
		else
dvander@541
   996
		{
dvander@541
   997
			ret = new CIter(this);
dvander@541
   998
		}
dvander@541
   999
		
dvander@541
  1000
		// Muuuh, if we're recalling, it shall be a copy of the last iterator, incremented by one
dvander@541
  1001
		if (m_Recall && m_UsedIters)
dvander@541
  1002
		{
dvander@541
  1003
			ret->Set(m_UsedIters);		// m_UsedIters is the last returned and not released iterator
dvander@541
  1004
			ret->Next();				// Use next instead of directly incrementing its m_Iter:
dvander@541
  1005
										// skips paused plugins
dvander@541
  1006
dvander@541
  1007
			// Set the last iterator to END!
dvander@541
  1008
			m_UsedIters->GoToEnd();
dvander@541
  1009
		}
dvander@541
  1010
dvander@541
  1011
		ret->m_pNext = m_UsedIters;
dvander@541
  1012
		ret->m_pPrev = NULL;
dvander@541
  1013
		if (m_UsedIters)
dvander@541
  1014
			m_UsedIters->m_pPrev = ret;
dvander@541
  1015
		m_UsedIters = ret;
dvander@541
  1016
dvander@541
  1017
		m_Recall = false;
dvander@541
  1018
dvander@541
  1019
		return ret;
dvander@541
  1020
	}
dvander@541
  1021
	void CSourceHookImpl::CHookList::ReleaseIter(IIter *pIter)
dvander@541
  1022
	{
dvander@541
  1023
		m_RelFlag = true;
dvander@541
  1024
dvander@541
  1025
		CIter *pIter2 = static_cast<CIter*>(pIter);
dvander@541
  1026
dvander@541
  1027
		// Unlink from m_UsedIters
dvander@541
  1028
dvander@541
  1029
		if (pIter2->m_pNext)
dvander@541
  1030
			pIter2->m_pNext->m_pPrev = pIter2->m_pPrev;
dvander@541
  1031
		if (pIter2->m_pPrev)
dvander@541
  1032
			pIter2->m_pPrev->m_pNext = pIter2->m_pNext;
dvander@541
  1033
		if (pIter2 == m_UsedIters)
dvander@541
  1034
			m_UsedIters = m_UsedIters->m_pNext;
dvander@541
  1035
dvander@541
  1036
		// Link to m_FreeIters
dvander@541
  1037
dvander@541
  1038
		pIter2->m_pNext = m_FreeIters;
dvander@541
  1039
dvander@541
  1040
		m_FreeIters = pIter2;
dvander@541
  1041
dvander@541
  1042
		// Reset recall state.
dvander@541
  1043
		m_Recall = false;
dvander@541
  1044
	}
dvander@541
  1045
dvander@541
  1046
	CSourceHookImpl::CHookList::CIter::CIter(CHookList *pList) : m_pList(pList), m_pNext(NULL)
dvander@541
  1047
	{
dvander@541
  1048
		GoToBegin();
dvander@541
  1049
	}
dvander@541
  1050
	CSourceHookImpl::CHookList::CIter::~CIter()
dvander@541
  1051
	{
dvander@541
  1052
	}
dvander@541
  1053
dvander@541
  1054
	void CSourceHookImpl::CHookList::CIter::Set(CIter *pOther)
dvander@541
  1055
	{
dvander@541
  1056
		m_Iter = pOther->m_Iter;
dvander@541
  1057
	}
dvander@541
  1058
dvander@541
  1059
	void CSourceHookImpl::CHookList::CIter::GoToBegin()
dvander@541
  1060
	{
dvander@541
  1061
		m_Iter = m_pList->m_List.begin();
dvander@541
  1062
		SkipPaused();
dvander@541
  1063
	}
dvander@541
  1064
dvander@541
  1065
	void CSourceHookImpl::CHookList::CIter::GoToEnd()
dvander@541
  1066
	{
dvander@541
  1067
		m_Iter = m_pList->m_List.end();
dvander@541
  1068
	}
dvander@541
  1069
dvander@541
  1070
	bool CSourceHookImpl::CHookList::CIter::End()
dvander@541
  1071
	{
dvander@541
  1072
		if (!m_pList)
dvander@541
  1073
			return false;
dvander@541
  1074
		return m_Iter == m_pList->m_List.end();
dvander@541
  1075
	}
dvander@541
  1076
	void CSourceHookImpl::CHookList::CIter::Next()
dvander@541
  1077
	{
dvander@541
  1078
		if (!m_pList || m_Iter == m_pList->m_List.end())
dvander@541
  1079
			return;
dvander@541
  1080
		++m_Iter;
dvander@541
  1081
		SkipPaused();
dvander@541
  1082
	}
dvander@541
  1083
	void CSourceHookImpl::CHookList::CIter::Clear()
dvander@541
  1084
	{
dvander@541
  1085
		m_pList = NULL;
dvander@541
  1086
	}
dvander@541
  1087
	void CSourceHookImpl::CHookList::CIter::SkipPaused()
dvander@541
  1088
	{
dvander@541
  1089
		while (m_Iter != m_pList->m_List.end() && m_Iter->paused)
dvander@541
  1090
			++m_Iter;
dvander@541
  1091
	}
dvander@541
  1092
dvander@541
  1093
	ISHDelegate *CSourceHookImpl::CHookList::CIter::Handler()
dvander@541
  1094
	{
dvander@541
  1095
		return m_Iter->handler;
dvander@541
  1096
	}
dvander@541
  1097
	int CSourceHookImpl::CHookList::CIter::ThisPtrOffs()
dvander@541
  1098
	{
dvander@541
  1099
		return m_Iter->thisptr_offs;
dvander@541
  1100
	}
dvander@541
  1101
dvander@541
  1102
	//////////////////////////////////////////////////////////////////////////
dvander@541
  1103
	// CProto
dvander@541
  1104
	//////////////////////////////////////////////////////////////////////////
dvander@541
  1105
	char *CSourceHookImpl::CProto::DupProto(const char *p)
dvander@541
  1106
	{
dvander@541
  1107
		char *newproto;
dvander@541
  1108
		if (*p)
dvander@541
  1109
		{
dvander@541
  1110
			size_t len = strlen(p);
dvander@541
  1111
			newproto = new char[len+1];
dvander@541
  1112
			memcpy(newproto, p, len+1);
dvander@541
  1113
		} else {
dvander@541
  1114
			const ProtoInfo *pi1 = reinterpret_cast<const ProtoInfo *>(p);
dvander@541
  1115
			int *ar_copy = new int[pi1->numOfParams + 1];
dvander@541
  1116
			for (int i = 0; i <= pi1->numOfParams; i++)
dvander@541
  1117
				ar_copy[i] = pi1->params[i];
dvander@541
  1118
			ProtoInfo *copy = new ProtoInfo(pi1->retTypeSize, pi1->numOfParams, ar_copy);
dvander@541
  1119
			newproto = reinterpret_cast<char *>(copy);
dvander@541
  1120
		}
dvander@541
  1121
dvander@541
  1122
		return newproto;
dvander@541
  1123
	}
dvander@541
  1124
dvander@541
  1125
	void CSourceHookImpl::CProto::FreeProto(char *prot)
dvander@541
  1126
	{
dvander@541
  1127
		if (*prot)
dvander@541
  1128
		{
dvander@541
  1129
			delete [] prot;
dvander@541
  1130
		} else {
dvander@541
  1131
			ProtoInfo *pi = reinterpret_cast<ProtoInfo *>(prot);
dvander@541
  1132
			delete [] pi->params;
dvander@541
  1133
			delete pi;
dvander@541
  1134
		}
dvander@541
  1135
	}
dvander@541
  1136
dvander@541
  1137
	bool CSourceHookImpl::CProto::Equal(const char *p1, const char *p2)
dvander@541
  1138
	{
dvander@541
  1139
		if (*p1 && *p2)			// Case1: Both old
dvander@541
  1140
		{
dvander@541
  1141
			// As in old versions
dvander@541
  1142
			return strcmp(p1, p2) == 0;
dvander@541
  1143
		}
dvander@541
  1144
		else if (!*p1 && !*p2)	// Case2: Both new
dvander@541
  1145
		{
dvander@541
  1146
			const ProtoInfo *pi1 = reinterpret_cast<const ProtoInfo*>(p1);
dvander@541
  1147
			const ProtoInfo *pi2 = reinterpret_cast<const ProtoInfo*>(p2);
dvander@541
  1148
dvander@541
  1149
			if (pi1->retTypeSize == pi2->retTypeSize &&
dvander@541
  1150
				pi1->numOfParams == pi2->numOfParams)
dvander@541
  1151
			{
dvander@541
  1152
				// params[0] is 0 for "normal" functions and -1 for vararg functions
dvander@541
  1153
				// params[1] is size of first parameter
dvander@541
  1154
				// params[2] is size of second parameter ...
dvander@541
  1155
				for (int i = 0; i <= pi1->numOfParams; ++i)
dvander@541
  1156
				{
dvander@541
  1157
					if (pi1->params[i] != pi2->params[i])
dvander@541
  1158
						return false;
dvander@541
  1159
				}
dvander@541
  1160
				return true;
dvander@541
  1161
			}
dvander@541
  1162
			else
dvander@541
  1163
			{
dvander@541
  1164
				return false;
dvander@541
  1165
			}
dvander@541
  1166
		}
dvander@541
  1167
		else					// Case3: Mixed old/new
dvander@541
  1168
		{
dvander@541
  1169
			// Trust the user
dvander@541
  1170
			return true;
dvander@541
  1171
		}
dvander@541
  1172
	}
dvander@541
  1173
dvander@541
  1174
dvander@541
  1175
	//////////////////////////////////////////////////////////////////////////
dvander@541
  1176
	// CHookManagerContainer
dvander@541
  1177
	//////////////////////////////////////////////////////////////////////////
dvander@541
  1178
	void CSourceHookImpl::CHookManagerContainer::AddHookManager(Plugin plug, const CHookManagerInfo &hookman)
dvander@541
  1179
	{
dvander@541
  1180
		iterator iter;
dvander@541
  1181
		// Check whether such a hook manager already exists; if yes, ignore.
dvander@541
  1182
		for (iter = begin(); iter != end(); ++iter)
dvander@541
  1183
		{
dvander@541
  1184
			if (iter->m_Plug == plug && iter->m_Func == hookman.m_Func)
dvander@541
  1185
				return;
dvander@541
  1186
		}
dvander@541
  1187
dvander@541
  1188
		// It doesn't -> add it. Add it to the end of its version group.
dvander@541
  1189
		for (iter = begin(); iter != end(); ++iter)
dvander@541
  1190
		{
dvander@541
  1191
			if (iter->m_HookManVersion < hookman.m_HookManVersion)
dvander@541
  1192
				break;
dvander@541
  1193
		}
dvander@541
  1194
dvander@541
  1195
		bool isBeginning = iter == begin();
dvander@541
  1196
dvander@541
  1197
		insert(iter, hookman);
dvander@541
  1198
dvander@541
  1199
		// If we inserted it at the beginning and if the dam breaks open many years too soon
dvander@541
  1200
		// and if there is more than one hookman and if the second one isn't empty, transfer
dvander@541
  1201
		// hooks from second to first
dvander@541
  1202
dvander@541
  1203
		if (isBeginning && size() > 1)
dvander@541
  1204
		{
dvander@541
  1205
			iter = begin();
dvander@541
  1206
			iterator second = iter;
dvander@541
  1207
			++second;
dvander@541
  1208
dvander@541
  1209
			if (!second->m_VfnPtrs.empty())
dvander@541
  1210
			{
dvander@541
  1211
				// Move the vfnptrs from the old hook manager to the new one
dvander@541
  1212
				iter->m_VfnPtrs = second->m_VfnPtrs;
dvander@541
  1213
				second->m_VfnPtrs.clear();
dvander@541
  1214
dvander@541
  1215
				// Unregister the old one, register the new one
dvander@541
  1216
				second->m_Func(HA_Unregister, NULL);
dvander@541
  1217
				iter->m_Func(HA_Register, &(*iter));
dvander@541
  1218
dvander@541
  1219
				// Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
dvander@541
  1220
				// or whatever
dvander@541
  1221
				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = iter->m_VfnPtrs.begin();
dvander@541
  1222
					vfnptr_iter != iter->m_VfnPtrs.end(); ++vfnptr_iter)
dvander@541
  1223
				{
dvander@541
  1224
					// And DEREFERENCE newHookMan->m_HookfuncVfnptr!
dvander@541
  1225
					// otherwise it will be executing the vtable... had to find out the hard way
dvander@541
  1226
					*reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = *reinterpret_cast<void**>(iter->m_HookfuncVfnptr);
dvander@541
  1227
				}
dvander@541
  1228
			}
dvander@541
  1229
		}
dvander@541
  1230
	}
dvander@541
  1231
}