sourcehook/sourcehook.cpp
branchsourcemm-1.6.0
changeset 347 e82968c21606
child 361 f34718303c8f
     1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/sourcehook/sourcehook.cpp	Tue Sep 18 20:03:47 2007 +0000
     1.3 @@ -0,0 +1,1212 @@
     1.4 +/* ======== SourceHook ========
     1.5 +* Copyright (C) 2004-2007 Metamod:Source Development Team
     1.6 +* No warranties of any kind
     1.7 +*
     1.8 +* License: zlib/libpng
     1.9 +*
    1.10 +* Author(s): Pavol "PM OnoTo" Marko
    1.11 +* Contributors: Scott "Damaged Soul" Ehlert
    1.12 +* ============================
    1.13 +*/
    1.14 +
    1.15 +/**
    1.16 + * @file sourcehook.cpp
    1.17 + * @brief Contains the implementation of the SourceHook API
    1.18 +*/
    1.19 +
    1.20 +#if defined __GNUC__
    1.21 +#include <stdint.h>
    1.22 +#endif
    1.23 +
    1.24 +#include "sourcehook_impl.h"
    1.25 +#include "sh_memory.h"
    1.26 +
    1.27 +namespace SourceHook
    1.28 +{
    1.29 +	template<>
    1.30 +	int HashFunction<int>(const int & k)
    1.31 +	{
    1.32 +		return k;
    1.33 +	}
    1.34 +	template<>
    1.35 +	int Compare<int>(const int & k1, const int & k2)
    1.36 +	{
    1.37 +		if (k1 == k2)
    1.38 +			return 0;
    1.39 +		if (k1 > k2)
    1.40 +			return 1;
    1.41 +		if (k1 < k2)
    1.42 +			return -1;
    1.43 +		return 0;
    1.44 +	}
    1.45 +	CSourceHookImpl::CSourceHookImpl()
    1.46 +	{
    1.47 +	}
    1.48 +	CSourceHookImpl::~CSourceHookImpl()
    1.49 +	{
    1.50 +	}
    1.51 +
    1.52 +	int CSourceHookImpl::GetIfaceVersion()
    1.53 +	{
    1.54 +		return SH_IFACE_VERSION;
    1.55 +	}
    1.56 +
    1.57 +	int CSourceHookImpl::GetImplVersion()
    1.58 +	{
    1.59 +		return SH_IMPL_VERSION;
    1.60 +	}
    1.61 +
    1.62 +	bool CSourceHookImpl::IsPluginInUse(Plugin plug)
    1.63 +	{
    1.64 +		// Iterate through all hook managers which are in this plugin
    1.65 +		// Iterate through their vfnptrs, ifaces, hooks
    1.66 +		// If a hook from an other plugin is found, return true
    1.67 +		// Return false otherwise
    1.68 +#define TMP_CHECK_LIST(name) \
    1.69 +	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
    1.70 +		if (hook_iter->plug == plug) \
    1.71 +			return true;
    1.72 +
    1.73 +		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
    1.74 +			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
    1.75 +		{
    1.76 +			for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
    1.77 +				hmil_iter != hmcl_iter->end(); ++hmil_iter)
    1.78 +			{
    1.79 +				if (hmil_iter->m_Plug != plug)
    1.80 +					continue;
    1.81 +				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
    1.82 +					vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
    1.83 +				{
    1.84 +					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
    1.85 +						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
    1.86 +					{
    1.87 +						List<HookInfo>::iterator hook_iter;
    1.88 +						TMP_CHECK_LIST(m_PreHooks);
    1.89 +						TMP_CHECK_LIST(m_PostHooks);
    1.90 +					}
    1.91 +				}
    1.92 +			}
    1.93 +		}
    1.94 +		
    1.95 +#undef TMP_CHECK_LIST
    1.96 +		return false;
    1.97 +	}
    1.98 +
    1.99 +	void CSourceHookImpl::UnloadPlugin(Plugin plug)
   1.100 +	{
   1.101 +		// 1) Manually remove all hooks by this plugin
   1.102 +		// 2) Manually remove all hook mans by this plugin
   1.103 +
   1.104 +		List<RemoveHookInfo> hookstoremove;
   1.105 +		List<RemoveHookManInfo> hookmanstoremove;
   1.106 +		HookManInfoList::iterator hmil_iter;
   1.107 +
   1.108 +#define TMP_CHECK_LIST(name, ispost) \
   1.109 +	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
   1.110 +		if (hook_iter->plug == plug) \
   1.111 +			hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
   1.112 +			hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost)); \
   1.113 +
   1.114 +		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
   1.115 +			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
   1.116 +		{
   1.117 +			for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
   1.118 +				hmil_iter != hmcl_iter->end(); ++hmil_iter)
   1.119 +			{
   1.120 +				if (hmil_iter->m_Plug == plug)
   1.121 +					hookmanstoremove.push_back(RemoveHookManInfo(plug, hmil_iter->m_Func));
   1.122 +
   1.123 +				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
   1.124 +					vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
   1.125 +				{
   1.126 +					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
   1.127 +						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
   1.128 +					{
   1.129 +						List<HookInfo>::iterator hook_iter;
   1.130 +						TMP_CHECK_LIST(m_PreHooks, false);
   1.131 +						TMP_CHECK_LIST(m_PostHooks, true);
   1.132 +					}
   1.133 +				}
   1.134 +			}
   1.135 +		}
   1.136 +#undef TMP_CHECK_LIST
   1.137 +
   1.138 +		for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   1.139 +			RemoveHook(*rmiter);
   1.140 +
   1.141 +		for (List<RemoveHookManInfo>::iterator rmiter = hookmanstoremove.begin(); rmiter != hookmanstoremove.end(); ++rmiter)
   1.142 +			RemoveHookManager(*rmiter);
   1.143 +	}
   1.144 +
   1.145 +	void CSourceHookImpl::RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc)
   1.146 +	{
   1.147 +		// Moo!
   1.148 +
   1.149 +		CHookManagerInfo tmp;
   1.150 +		if (pubFunc(HA_GetInfo, &tmp) != 0)
   1.151 +			return;
   1.152 +
   1.153 +		
   1.154 +		HookManContList::iterator hmcl_iter = m_HookMans.find(
   1.155 +			CHookManagerContainer::HMCI(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx));
   1.156 +
   1.157 +		if (hmcl_iter == m_HookMans.end())
   1.158 +		{
   1.159 +			// Moo?
   1.160 +			return;
   1.161 +		}
   1.162 +
   1.163 +		CHookManagerContainer::iterator hmil_iter = hmcl_iter->find(
   1.164 +			CHookManagerInfo::Descriptor(plug, pubFunc));
   1.165 +
   1.166 +		if (hmil_iter == hmcl_iter->end())
   1.167 +		{
   1.168 +			// Moo?
   1.169 +			return;
   1.170 +		}
   1.171 +
   1.172 +		bool stillInUse = false;
   1.173 +		List<RemoveHookInfo> hookstoremove;
   1.174 +
   1.175 +		// Iterate through all of the hook manager's hooks. Remove all hooks from the hookman's plugin.
   1.176 +#define TMP_CHECK_LIST(name, ispost) \
   1.177 +	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
   1.178 +		if (hook_iter->plug == plug) \
   1.179 +			hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
   1.180 +			hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost)); \
   1.181 +		else \
   1.182 +			stillInUse = true; \
   1.183 +
   1.184 +		for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
   1.185 +			vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
   1.186 +		{
   1.187 +			for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
   1.188 +				iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
   1.189 +			{
   1.190 +				List<HookInfo>::iterator hook_iter;
   1.191 +				TMP_CHECK_LIST(m_PreHooks, false);
   1.192 +				TMP_CHECK_LIST(m_PostHooks, true);
   1.193 +			}
   1.194 +		}
   1.195 +#undef TMP_CHECK_LIST
   1.196 +
   1.197 +		for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   1.198 +			RemoveHook(*rmiter);
   1.199 +
   1.200 +		CHookManagerInfo info = *hmil_iter;
   1.201 +
   1.202 +		// Unlink the hook manager from the list
   1.203 +		hmcl_iter->erase(hmil_iter);
   1.204 +
   1.205 +		// If there were any hooks from other plugins, find a new suitable hook manager.
   1.206 +		if (stillInUse)
   1.207 +		{
   1.208 +			// Find a suitable hook manager in an other plugin
   1.209 +			hmil_iter = hmcl_iter->begin();
   1.210 +
   1.211 +			// This should _never_ happen.
   1.212 +			// If there is a hook from an other plugin, the plugin must have provided a hook manager as well.
   1.213 +			SH_ASSERT(hmil_iter != hmcl_iter->end(),
   1.214 +				("Could not find a suitable hook manager in an other plugin!"));
   1.215 +
   1.216 +			// AddHook should make sure that every plugin only has _one_ hook manager for _one_ proto/vi/vo
   1.217 +			SH_ASSERT(hmil_iter->m_Plug != plug, ("New hook manager from same plugin!"));
   1.218 +
   1.219 +			// The first hook manager should be always used - so the new hook manager has to be empty
   1.220 +			SH_ASSERT(hmil_iter->m_VfnPtrs.empty(), ("New hook manager not empty!"));
   1.221 +
   1.222 +			// Move the vfnptrs from the old hook manager to the new one
   1.223 +			hmil_iter->m_VfnPtrs = info.m_VfnPtrs;
   1.224 +
   1.225 +			// Unregister the old one, register the new one
   1.226 +			info.m_Func(HA_Unregister, NULL);
   1.227 +			hmil_iter->m_Func(HA_Register, &(*hmil_iter));
   1.228 +
   1.229 +			// Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
   1.230 +			// or whatever
   1.231 +			for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
   1.232 +				vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
   1.233 +			{
   1.234 +				// And DEREFERENCE newHookMan->m_HookfuncVfnptr!
   1.235 +				// otherwise it will be executing the vtable... had to find out the hard way
   1.236 +				*reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = *reinterpret_cast<void**>(hmil_iter->m_HookfuncVfnptr);
   1.237 +			}
   1.238 +		}
   1.239 +	}
   1.240 +
   1.241 +	void CSourceHookImpl::RemoveHookManager(RemoveHookManInfo info)
   1.242 +	{
   1.243 +		RemoveHookManager(info.plug, info.hookman);
   1.244 +	}
   1.245 +
   1.246 +	void CSourceHookImpl::CompleteShutdown()
   1.247 +	{
   1.248 +		// Remove all hooks
   1.249 +
   1.250 +		List<RemoveHookInfo> hookstoremove;
   1.251 +
   1.252 +#define TMP_CHECK_LIST(name, ispost) \
   1.253 +	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
   1.254 +		hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
   1.255 +			hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost))
   1.256 +		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
   1.257 +			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
   1.258 +		{
   1.259 +			for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
   1.260 +				hmil_iter != hmcl_iter->end(); ++hmil_iter)
   1.261 +			{
   1.262 +				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
   1.263 +					vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
   1.264 +				{
   1.265 +					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
   1.266 +						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
   1.267 +					{
   1.268 +						List<HookInfo>::iterator hook_iter;
   1.269 +						TMP_CHECK_LIST(m_PreHooks, false);
   1.270 +						TMP_CHECK_LIST(m_PostHooks, true);
   1.271 +					}
   1.272 +				}
   1.273 +			}
   1.274 +		}
   1.275 +#undef TMP_CHECK_LIST
   1.276 +
   1.277 +		for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   1.278 +			RemoveHook(*rmiter);
   1.279 +
   1.280 +		m_HookMans.clear();
   1.281 +	}
   1.282 +
   1.283 +	bool CSourceHookImpl::AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   1.284 +	{
   1.285 +		void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
   1.286 +
   1.287 +		// 1) Get info about the hook manager
   1.288 +		CHookManagerInfo tmp;
   1.289 +		if (myHookMan(HA_GetInfo, &tmp) != 0)
   1.290 +			return false;
   1.291 +
   1.292 +		tmp.m_Func = myHookMan;
   1.293 +		tmp.m_Plug = plug;
   1.294 +
   1.295 +		CHookManagerContainer::HMCI hmci(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx);
   1.296 +
   1.297 +		void **cur_vtptr = *reinterpret_cast<void***>(
   1.298 +			reinterpret_cast<char*>(adjustediface) + tmp.m_VtblOffs);
   1.299 +		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.m_VtblIdx);
   1.300 +
   1.301 +		// Add the container if not already added
   1.302 +		HookManContList::iterator hmcl_iter = m_HookMans.find(hmci);
   1.303 +		if (hmcl_iter == m_HookMans.end())
   1.304 +		{
   1.305 +			m_HookMans.push_back(CHookManagerContainer(hmci));
   1.306 +			hmcl_iter = m_HookMans.end();
   1.307 +			--hmcl_iter;
   1.308 +		}
   1.309 +
   1.310 +		hmcl_iter->AddHookManager(plug, tmp);
   1.311 +
   1.312 +		CHookManagerContainer::iterator hookman = hmcl_iter->begin();
   1.313 +		SH_ASSERT(hookman != hmcl_iter->end(), ("No hookman found - but we've just added one!"));
   1.314 +
   1.315 +		// Check whether any other container holds a hook manager which holds this vfnptr
   1.316 +		// If yes, it means that the two are incompatible, so return false.
   1.317 +		for (HookManContList::iterator hmcl_iter2 = m_HookMans.begin();
   1.318 +			hmcl_iter2 != m_HookMans.end(); ++hmcl_iter2)
   1.319 +		{
   1.320 +			if (hmcl_iter2 != hmcl_iter)
   1.321 +			{
   1.322 +				for (CHookManagerContainer::iterator hmil_iter = hmcl_iter2->begin();
   1.323 +					hmil_iter != hmcl_iter2->end(); ++hmil_iter)
   1.324 +				{
   1.325 +					if (hmil_iter->m_VfnPtrs.find(cur_vfnptr) != hmil_iter->m_VfnPtrs.end())
   1.326 +						return false;
   1.327 +				}
   1.328 +			}
   1.329 +		}
   1.330 +
   1.331 +		// Tell it to store the pointer if it's not already active
   1.332 +		if (hookman->m_VfnPtrs.empty())
   1.333 +			hookman->m_Func(HA_Register, &(*hookman));
   1.334 +
   1.335 +		CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.find(cur_vfnptr);
   1.336 +
   1.337 +		if (vfnptr_iter == hookman->m_VfnPtrs.end())
   1.338 +		{
   1.339 +			// Add a new one
   1.340 +			CVfnPtr vfp(cur_vfnptr);
   1.341 +
   1.342 +			// Alter vtable entry
   1.343 +			if (!SetMemAccess(cur_vtptr, sizeof(void*) * (tmp.m_VtblIdx + 1), SH_MEM_READ | SH_MEM_WRITE))
   1.344 +				return false;
   1.345 +
   1.346 +			*reinterpret_cast<void**>(cur_vfnptr) = *reinterpret_cast<void**>(hookman->m_HookfuncVfnptr);
   1.347 +
   1.348 +			hookman->m_VfnPtrs.push_back(vfp);
   1.349 +
   1.350 +			// Make vfnptr_iter point to the new element
   1.351 +			vfnptr_iter = hookman->m_VfnPtrs.end();
   1.352 +			--vfnptr_iter;
   1.353 +
   1.354 +			// Now that it is done, check whether we have to update any callclasses
   1.355 +			ApplyCallClassPatches(adjustediface, tmp.m_VtblOffs, tmp.m_VtblIdx, vfp.m_OrigEntry);
   1.356 +		}
   1.357 +
   1.358 +		CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.find(adjustediface);
   1.359 +		if (iface_iter == vfnptr_iter->m_Ifaces.end())
   1.360 +		{
   1.361 +			// Add a new one
   1.362 +			vfnptr_iter->m_Ifaces.push_back(CIface(adjustediface));
   1.363 +
   1.364 +			// Make iface_iter point to the new element
   1.365 +			iface_iter = vfnptr_iter->m_Ifaces.end();
   1.366 +			--iface_iter;
   1.367 +		}
   1.368 +
   1.369 +		// Add the hook
   1.370 +		HookInfo hookinfo;
   1.371 +		hookinfo.handler = handler;
   1.372 +		hookinfo.plug = plug;
   1.373 +		hookinfo.paused = false;
   1.374 +		hookinfo.thisptr_offs = thisptr_offs;
   1.375 +		if (post)
   1.376 +			iface_iter->m_PostHooks.m_List.push_back(hookinfo);
   1.377 +		else
   1.378 +			iface_iter->m_PreHooks.m_List.push_back(hookinfo);
   1.379 +
   1.380 +		return true;
   1.381 +	}
   1.382 +
   1.383 +	bool CSourceHookImpl::RemoveHook(RemoveHookInfo info)
   1.384 +	{
   1.385 +		return RemoveHook(info.plug, info.iface, info.thisptr_offs, info.hookman, info.handler, info.post);
   1.386 +	}
   1.387 +
   1.388 +	bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   1.389 +	{
   1.390 +		void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
   1.391 +		CHookManagerInfo tmp;
   1.392 +		if (myHookMan(HA_GetInfo, &tmp) != 0)
   1.393 +			return false;
   1.394 +
   1.395 +		// Find the hook manager and the hook
   1.396 +
   1.397 +		HookManContList::iterator hmcl_iter = m_HookMans.find(
   1.398 +			CHookManagerContainer::HMCI(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx));
   1.399 +		if (hmcl_iter == m_HookMans.end() || hmcl_iter->empty())
   1.400 +			return false;
   1.401 +		
   1.402 +		CHookManagerContainer::iterator hookman = hmcl_iter->begin();
   1.403 +
   1.404 +		if (!ModuleInMemory(reinterpret_cast<char*>(adjustediface) + tmp.m_VtblOffs,
   1.405 +			sizeof(void*) * (tmp.m_VtblIdx + 1)))
   1.406 +		{
   1.407 +			// The module the vtable was in is already unloaded.
   1.408 +			hookman->m_VfnPtrs.clear();
   1.409 +			hookman->m_Func(HA_Unregister, NULL);
   1.410 +			return true;
   1.411 +		}
   1.412 +
   1.413 +		void **cur_vtptr = *reinterpret_cast<void***>(
   1.414 +			reinterpret_cast<char*>(adjustediface) + tmp.m_VtblOffs);
   1.415 +		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.m_VtblIdx);
   1.416 +
   1.417 +		CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.find(cur_vfnptr);
   1.418 +
   1.419 +		if (vfnptr_iter == hookman->m_VfnPtrs.end())
   1.420 +			return false;
   1.421 +
   1.422 +		for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
   1.423 +			iface_iter != vfnptr_iter->m_Ifaces.end();)
   1.424 +		{
   1.425 +			if (iface_iter->m_Ptr != adjustediface)
   1.426 +			{
   1.427 +				iface_iter++;
   1.428 +				continue;
   1.429 +			}
   1.430 +			List<HookInfo> &hooks =
   1.431 +				post ? iface_iter->m_PostHooks.m_List : iface_iter->m_PreHooks.m_List;
   1.432 +
   1.433 +			bool erase;
   1.434 +			for (List<HookInfo>::iterator hookiter = hooks.begin();
   1.435 +				hookiter != hooks.end(); )
   1.436 +			{
   1.437 +				erase = hookiter->plug == plug && hookiter->handler->IsEqual(handler) &&
   1.438 +					hookiter->thisptr_offs == thisptr_offs;
   1.439 +				if (erase)
   1.440 +				{
   1.441 +					hookiter->handler->DeleteThis();			// Make the _plugin_ delete the handler object
   1.442 +
   1.443 +					// Move all iterators pointing at this
   1.444 +					List<HookInfo>::iterator oldhookiter = hookiter;
   1.445 +					hookiter = hooks.erase(hookiter);
   1.446 +					List<HookInfo>::iterator newhookiter = hookiter;
   1.447 +					--newhookiter; // The hook loop will ++ it then
   1.448 +					CHookList::CIter *pItIter;
   1.449 +					for (pItIter = iface_iter->m_PreHooks.m_UsedIters; pItIter; pItIter = pItIter->m_pNext)
   1.450 +						if (pItIter->m_Iter == oldhookiter)
   1.451 +							pItIter->m_Iter = newhookiter;
   1.452 +				}
   1.453 +				else
   1.454 +					++hookiter;
   1.455 +			}
   1.456 +			if (iface_iter->m_PostHooks.m_List.empty() && iface_iter->m_PreHooks.m_List.empty())
   1.457 +			{
   1.458 +				// There are no hooks on this iface anymore...
   1.459 +				for (HookLoopInfoStack::iterator hli_iter = m_HLIStack.begin();
   1.460 +					hli_iter != m_HLIStack.end(); ++hli_iter)
   1.461 +				{
   1.462 +					if (hli_iter->pCurIface == static_cast<IIface*>(&(*iface_iter)))
   1.463 +						hli_iter->shouldContinue = false;
   1.464 +				}
   1.465 +
   1.466 +				iface_iter = vfnptr_iter->m_Ifaces.erase(iface_iter);
   1.467 +				if (vfnptr_iter->m_Ifaces.empty())
   1.468 +				{
   1.469 +					// No ifaces at all -> Deactivate the hook
   1.470 +					*reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = vfnptr_iter->m_OrigEntry;
   1.471 +
   1.472 +					hookman->m_VfnPtrs.erase(vfnptr_iter);
   1.473 +
   1.474 +					// Remove callclass patch
   1.475 +					for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   1.476 +						if (cciter->m_Ptr == adjustediface)
   1.477 +							cciter->RemoveCallClassPatch(tmp.m_VtblOffs, tmp.m_VtblIdx);
   1.478 +
   1.479 +					if (hookman->m_VfnPtrs.empty())
   1.480 +					{
   1.481 +						// Unregister the hook manager
   1.482 +						hookman->m_Func(HA_Unregister, NULL);
   1.483 +					}
   1.484 +
   1.485 +					// Don't try to continue looping through ifaces
   1.486 +					// - the list is already invalid
   1.487 +					return true;
   1.488 +				}
   1.489 +			}
   1.490 +			else
   1.491 +				++iface_iter;
   1.492 +		}
   1.493 +		return true;
   1.494 +	}
   1.495 +
   1.496 +	GenericCallClass *CSourceHookImpl::GetCallClass(void *iface, size_t size)
   1.497 +	{
   1.498 +		for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   1.499 +		{
   1.500 +			if (cciter->m_Ptr == iface && cciter->m_ObjSize == size)
   1.501 +			{
   1.502 +				++cciter->m_RefCounter;
   1.503 +				return &(*cciter);
   1.504 +			}
   1.505 +		}
   1.506 +
   1.507 +		// Make a new one
   1.508 +
   1.509 +		CCallClassImpl tmp(iface, size);
   1.510 +		ApplyCallClassPatches(tmp);
   1.511 +		m_CallClasses.push_back(tmp);
   1.512 +		return &m_CallClasses.back();
   1.513 +	}
   1.514 +
   1.515 +	void CSourceHookImpl::ReleaseCallClass(GenericCallClass *ptr)
   1.516 +	{
   1.517 +		Impl_CallClassList::iterator iter = m_CallClasses.find(ptr);
   1.518 +		if (iter == m_CallClasses.end())
   1.519 +			return;
   1.520 +		--iter->m_RefCounter;
   1.521 +		if (iter->m_RefCounter < 1)
   1.522 +			m_CallClasses.erase(iter);
   1.523 +	}
   1.524 +
   1.525 +	void CSourceHookImpl::ApplyCallClassPatches(CCallClassImpl &cc)
   1.526 +	{
   1.527 +		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
   1.528 +			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
   1.529 +		{
   1.530 +			for (CHookManagerContainer::iterator hookman = hmcl_iter->begin();
   1.531 +				hookman != hmcl_iter->end(); ++hookman)
   1.532 +			{
   1.533 +				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.begin();
   1.534 +					vfnptr_iter != hookman->m_VfnPtrs.end(); ++vfnptr_iter)
   1.535 +				{
   1.536 +					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
   1.537 +						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
   1.538 +					{
   1.539 +						if (iface_iter->m_Ptr >= cc.m_Ptr &&
   1.540 +							iface_iter->m_Ptr < (reinterpret_cast<char*>(cc.m_Ptr) + cc.m_ObjSize))
   1.541 +						{
   1.542 +							cc.ApplyCallClassPatch(static_cast<int>(reinterpret_cast<char*>(iface_iter->m_Ptr) -
   1.543 +								reinterpret_cast<char*>(cc.m_Ptr)) + hookman->m_VtblOffs,
   1.544 +								hookman->m_VtblIdx, vfnptr_iter->m_OrigEntry);
   1.545 +						}
   1.546 +					}
   1.547 +				}
   1.548 +			}
   1.549 +		}
   1.550 +	}
   1.551 +
   1.552 +	void CSourceHookImpl::ApplyCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx, void *orig_entry)
   1.553 +	{
   1.554 +		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
   1.555 +			++cc_iter)
   1.556 +		{
   1.557 +			if (ifaceptr >= cc_iter->m_Ptr &&
   1.558 +				ifaceptr < (reinterpret_cast<char*>(cc_iter->m_Ptr) + cc_iter->m_ObjSize))
   1.559 +			{
   1.560 +				cc_iter->ApplyCallClassPatch(static_cast<int>(reinterpret_cast<char*>(ifaceptr) -
   1.561 +					reinterpret_cast<char*>(cc_iter->m_Ptr)) + vtbl_offs, vtbl_idx, orig_entry);
   1.562 +			}
   1.563 +		}
   1.564 +	}
   1.565 +
   1.566 +	void CSourceHookImpl::RemoveCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx)
   1.567 +	{
   1.568 +		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
   1.569 +			++cc_iter)
   1.570 +		{
   1.571 +			if (ifaceptr >= cc_iter->m_Ptr &&
   1.572 +				ifaceptr < (reinterpret_cast<char*>(cc_iter->m_Ptr) + cc_iter->m_ObjSize))
   1.573 +			{
   1.574 +				cc_iter->RemoveCallClassPatch(vtbl_offs, vtbl_idx);
   1.575 +			}
   1.576 +		}
   1.577 +	}
   1.578 +
   1.579 +	void CSourceHookImpl::SetPluginPaused(Plugin plug, bool paused)
   1.580 +	{
   1.581 +		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   1.582 +		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
   1.583 +			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
   1.584 +		{
   1.585 +			for (CHookManagerContainer::iterator hookmaniter = hmcl_iter->begin();
   1.586 +				hookmaniter != hmcl_iter->end(); ++hookmaniter)
   1.587 +			{
   1.588 +				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->m_VfnPtrs.begin();
   1.589 +					vfnptr_iter != hookmaniter->m_VfnPtrs.end(); ++vfnptr_iter)
   1.590 +				{
   1.591 +					for (CVfnPtr::IfaceListIter ifaceiter = vfnptr_iter->m_Ifaces.begin();
   1.592 +						ifaceiter != vfnptr_iter->m_Ifaces.end(); ++ifaceiter)
   1.593 +					{
   1.594 +						for (List<HookInfo>::iterator hookiter = ifaceiter->m_PreHooks.m_List.begin();
   1.595 +							hookiter != ifaceiter->m_PreHooks.m_List.end(); ++hookiter)
   1.596 +							if (plug == hookiter->plug)
   1.597 +								hookiter->paused = paused;
   1.598 +
   1.599 +						for (List<HookInfo>::iterator hookiter = ifaceiter->m_PostHooks.m_List.begin();
   1.600 +							hookiter != ifaceiter->m_PostHooks.m_List.end(); ++hookiter)
   1.601 +							if (plug == hookiter->plug)
   1.602 +								hookiter->paused = paused;
   1.603 +					}
   1.604 +				}
   1.605 +			}
   1.606 +		}
   1.607 +	}
   1.608 +	void CSourceHookImpl::PausePlugin(Plugin plug)
   1.609 +	{
   1.610 +		SetPluginPaused(plug, true);
   1.611 +	}
   1.612 +
   1.613 +	void CSourceHookImpl::UnpausePlugin(Plugin plug)
   1.614 +	{
   1.615 +		SetPluginPaused(plug, false);
   1.616 +	}
   1.617 +
   1.618 +	void CSourceHookImpl::HookLoopBegin(IIface *pIface)
   1.619 +	{
   1.620 +		HookLoopInfo hli;
   1.621 +		hli.pCurIface = pIface;
   1.622 +		hli.shouldContinue = true;
   1.623 +		hli.recall = HookLoopInfo::Recall_No;
   1.624 +
   1.625 +		static_cast<CIface*>(pIface)->m_PreHooks.RQFlagReset();
   1.626 +		static_cast<CIface*>(pIface)->m_PostHooks.RQFlagReset();
   1.627 +
   1.628 +		m_HLIStack.push(hli);
   1.629 +	}
   1.630 +
   1.631 +	void CSourceHookImpl::HookLoopEnd()
   1.632 +	{
   1.633 +		// When in a post recall... make sure status is high enough so that it returns the orig ret.
   1.634 +		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
   1.635 +			*m_HLIStack.front().pStatus = MRES_SUPERCEDE;			// THAT'LL TEACH THEM!
   1.636 +		m_HLIStack.pop();
   1.637 +	}
   1.638 +
   1.639 +	void CSourceHookImpl::SetRes(META_RES res)
   1.640 +	{
   1.641 +		*m_HLIStack.front().pCurRes = res;
   1.642 +	}
   1.643 +
   1.644 +	META_RES CSourceHookImpl::GetPrevRes()
   1.645 +	{
   1.646 +		return *m_HLIStack.front().pPrevRes;
   1.647 +	}
   1.648 +
   1.649 +	META_RES CSourceHookImpl::GetStatus()
   1.650 +	{
   1.651 +		return *m_HLIStack.front().pStatus;
   1.652 +	}
   1.653 +
   1.654 +	const void *CSourceHookImpl::GetOrigRet()
   1.655 +	{
   1.656 +		// When in a post recall... return the orig ret of the previous hookloop.
   1.657 +		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
   1.658 +			return m_HLIStack.second().pOrigRet;
   1.659 +
   1.660 +		return m_HLIStack.front().pOrigRet;
   1.661 +	}
   1.662 +
   1.663 +	const void *CSourceHookImpl::GetOverrideRet()
   1.664 +	{
   1.665 +		// pOverrideRet is always set since recalls were introduced
   1.666 +		// GetOverrideRetPtr was added; a function which always returns pOverrideRet
   1.667 +		// so that RETURN_META_VALUE_NEWPARAMS can provide an override result
   1.668 +
   1.669 +		// This means that we have to filter GetOverrideRet:
   1.670 +		//  If the status variable is < MRES_OVERRIDE, return NULL.
   1.671 +
   1.672 +		return (*m_HLIStack.front().pStatus < MRES_OVERRIDE) ?
   1.673 +			NULL : m_HLIStack.front().pOverrideRet;
   1.674 +	}
   1.675 +
   1.676 +	void *CSourceHookImpl::GetOverrideRetPtr()
   1.677 +	{
   1.678 +		// As described in the comment above: always return pOverrideRet
   1.679 +		return m_HLIStack.front().pOverrideRet;
   1.680 +	}
   1.681 +
   1.682 +	void *CSourceHookImpl::GetIfacePtr()
   1.683 +	{
   1.684 +		return *m_HLIStack.front().pIfacePtrPtr;
   1.685 +	}
   1.686 +
   1.687 +	void CSourceHookImpl::SetCurResPtr(META_RES *mres)
   1.688 +	{
   1.689 +		m_HLIStack.front().pCurRes = mres;
   1.690 +	}
   1.691 +
   1.692 +	void CSourceHookImpl::SetPrevResPtr(META_RES *mres)
   1.693 +	{
   1.694 +		m_HLIStack.front().pPrevRes = mres;
   1.695 +
   1.696 +		// If we're recalling, drag the previous mres value to the new hookfunc
   1.697 +		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
   1.698 +			*mres = *m_HLIStack.second().pPrevRes;
   1.699 +	}
   1.700 +
   1.701 +	void CSourceHookImpl::SetStatusPtr(META_RES *mres)
   1.702 +	{
   1.703 +		m_HLIStack.front().pStatus = mres;
   1.704 +
   1.705 +		// If we're recalling, drag the previous mres value to the new hookfunc
   1.706 +		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
   1.707 +			*mres = *m_HLIStack.second().pStatus;
   1.708 +	}
   1.709 +
   1.710 +	void CSourceHookImpl::SetIfacePtrPtr(void **pp)
   1.711 +	{
   1.712 +		m_HLIStack.front().pIfacePtrPtr = pp;
   1.713 +	}
   1.714 +
   1.715 +	void CSourceHookImpl::SetOrigRetPtr(const void *ptr)
   1.716 +	{
   1.717 +		m_HLIStack.front().pOrigRet = ptr;
   1.718 +	}
   1.719 +	void CSourceHookImpl::SetOverrideRetPtr(void *ptr)
   1.720 +	{
   1.721 +		m_HLIStack.front().pOverrideRet = ptr;
   1.722 +	}
   1.723 +
   1.724 +	// New function which does all of the above + more :)
   1.725 +	void *CSourceHookImpl::SetupHookLoop(META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr,
   1.726 +		void **ifacePtrPtr, const void *origRetPtr, void *overrideRetPtr)
   1.727 +	{
   1.728 +		HookLoopInfo &hli = m_HLIStack.front();
   1.729 +		hli.pStatus = statusPtr;
   1.730 +		hli.pPrevRes = prevResPtr;
   1.731 +		hli.pCurRes = curResPtr;
   1.732 +		hli.pIfacePtrPtr = ifacePtrPtr;
   1.733 +		hli.pOrigRet = origRetPtr;
   1.734 +
   1.735 +		// Handle some recall stuff
   1.736 +		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
   1.737 +		{
   1.738 +			HookLoopInfo &other = m_HLIStack.second();
   1.739 +			*statusPtr = *other.pStatus;
   1.740 +			*prevResPtr = *other.pStatus;
   1.741 +
   1.742 +			// When the status is low so there's no override return value and we're in a post recall,
   1.743 +			// give it the orig return value as override return value.
   1.744 +			if (*statusPtr < MRES_OVERRIDE && other.recall == HookLoopInfo::Recall_Post1)
   1.745 +				hli.pOverrideRet = const_cast<void*>(other.pOrigRet);
   1.746 +			else	// Otherwise, transfer override ret normally
   1.747 +				hli.pOverrideRet = other.pOverrideRet;
   1.748 +		}
   1.749 +		else
   1.750 +			hli.pOverrideRet = overrideRetPtr;
   1.751 +
   1.752 +		// Tell the hook func which override ret ptr to use
   1.753 +		return hli.pOverrideRet;
   1.754 +	}
   1.755 +
   1.756 +	bool CSourceHookImpl::ShouldContinue()
   1.757 +	{
   1.758 +		// If recall is true, we shall not continue either.
   1.759 +		// This is because, if it's true and ShouldContinue is called, it suggests that the
   1.760 +		// actual recall is done and that we are back in the original handler which shall return
   1.761 +		// immediately.
   1.762 +
   1.763 +		// Post-recalls:
   1.764 +		//  The second element on the stack has recall set to Recall_Post1.
   1.765 +		//  This means that we want to skip this part and the original function calling thing, so
   1.766 +		//  we store the status mres value, set status to MRES_SUPERCEDE, and return false.
   1.767 +		//  We also set the recall flag to Recall_Post2, so the next time the thing calls us, we
   1.768 +		//  can return true (so that the thing goes into post hooks).
   1.769 +		if (m_HLIStack.size() > 1)
   1.770 +		{
   1.771 +			if (m_HLIStack.second().recall == HookLoopInfo::Recall_Post1)
   1.772 +			{
   1.773 +				m_HLIStack.front().temporaryStatus = *m_HLIStack.front().pStatus;
   1.774 +				*m_HLIStack.front().pStatus = MRES_SUPERCEDE;
   1.775 +				m_HLIStack.second().recall = HookLoopInfo::Recall_Post2;
   1.776 +				return false;
   1.777 +			}
   1.778 +			else if (m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
   1.779 +			{
   1.780 +				*m_HLIStack.front().pStatus = m_HLIStack.front().temporaryStatus;
   1.781 +				return m_HLIStack.front().shouldContinue;
   1.782 +			}
   1.783 +		}
   1.784 +		return m_HLIStack.front().shouldContinue && !m_HLIStack.front().recall;
   1.785 +	}
   1.786 +
   1.787 +	void CSourceHookImpl::DoRecall()
   1.788 +	{
   1.789 +		if (!m_HLIStack.empty())
   1.790 +		{
   1.791 +			// Also watch out for post recalls! Described at the beginning of sourcehook_impl.h
   1.792 +			m_HLIStack.front().recall =
   1.793 +				static_cast<CIface*>(m_HLIStack.front().pCurIface)->m_PostHooks.RQFlagGet() ?
   1.794 +				HookLoopInfo::Recall_Post1 : HookLoopInfo::Recall_Pre;
   1.795 +			
   1.796 +			CHookList *mlist = static_cast<CHookList*>(m_HLIStack.front().recall == HookLoopInfo::Recall_Pre ? 
   1.797 +				m_HLIStack.front().pCurIface->GetPreHooks() : m_HLIStack.front().pCurIface->GetPostHooks());
   1.798 +			mlist->m_Recall = true;
   1.799 +
   1.800 +			// The hookfunc usually does this, but it won't have a chance to see it, 
   1.801 +			// so for recalls, we update status here if it's required
   1.802 +			if (*m_HLIStack.front().pCurRes > *m_HLIStack.front().pStatus) 
   1.803 +				*m_HLIStack.front().pStatus = *m_HLIStack.front().pCurRes;
   1.804 +
   1.805 +		}
   1.806 +	}
   1.807 +
   1.808 +	////////////////////////////
   1.809 +	// CCallClassImpl
   1.810 +	////////////////////////////
   1.811 +	CSourceHookImpl::CCallClassImpl::CCallClassImpl(void *ptr, size_t size)
   1.812 +		: m_Ptr(ptr), m_ObjSize(size), m_RefCounter(1)
   1.813 +	{
   1.814 +	}
   1.815 +	CSourceHookImpl::CCallClassImpl::~CCallClassImpl()
   1.816 +	{
   1.817 +	}
   1.818 +
   1.819 +	void *CSourceHookImpl::CCallClassImpl::GetThisPtr()
   1.820 +	{
   1.821 +		return m_Ptr;
   1.822 +	}
   1.823 +	void *CSourceHookImpl::CCallClassImpl::GetOrigFunc(int vtbloffs, int vtblidx)
   1.824 +	{
   1.825 +		OrigVTables::iterator iter = m_VT.find(vtbloffs);
   1.826 +		if (iter != m_VT.end() && iter->val.size() > (size_t)vtblidx)
   1.827 +		{
   1.828 +			return iter->val[vtblidx];
   1.829 +		}
   1.830 +		return NULL;
   1.831 +	}
   1.832 +
   1.833 +	void CSourceHookImpl::CCallClassImpl::ApplyCallClassPatch(int vtbl_offs, int vtbl_idx, void *orig_entry)
   1.834 +	{
   1.835 +		OrigFuncs &tmpvec = m_VT[vtbl_offs];
   1.836 +		if (tmpvec.size() <= (size_t)vtbl_idx)
   1.837 +			tmpvec.resize(vtbl_idx+1, NULL);
   1.838 +		tmpvec[vtbl_idx] = orig_entry;
   1.839 +	}
   1.840 +	void CSourceHookImpl::CCallClassImpl::RemoveCallClassPatch(int vtbl_offs, int vtbl_idx)
   1.841 +	{
   1.842 +		OrigVTables::iterator iter = m_VT.find(vtbl_offs);
   1.843 +		if (iter != m_VT.end())
   1.844 +		{
   1.845 +			if (iter->val.size() > (size_t)vtbl_idx)
   1.846 +			{
   1.847 +				iter->val[vtbl_idx] = 0;
   1.848 +
   1.849 +				OrigFuncs &of = iter->val;
   1.850 +				OrigFuncs::iterator lastused = of.end();
   1.851 +				for (OrigFuncs::iterator viter = of.begin(); viter != of.end(); ++viter)
   1.852 +				{
   1.853 +					if (*viter)
   1.854 +						lastused = viter;
   1.855 +				}
   1.856 +				if (lastused == of.end())
   1.857 +				{
   1.858 +					// No used element => Remove the whole vector
   1.859 +					m_VT.erase(iter);
   1.860 +					return;
   1.861 +				}
   1.862 +				of.resize(lastused - of.begin() + 1);
   1.863 +			}
   1.864 +		}
   1.865 +	}
   1.866 +
   1.867 +	////////////////////////////
   1.868 +	// CHookManagerInfo
   1.869 +	////////////////////////////
   1.870 +	CSourceHookImpl::CHookManagerInfo::CHookManagerInfo() : m_HookManVersion(0)
   1.871 +	{
   1.872 +	}
   1.873 +	CSourceHookImpl::CHookManagerInfo::~CHookManagerInfo()
   1.874 +	{
   1.875 +	}
   1.876 +
   1.877 +	IVfnPtr *CSourceHookImpl::CHookManagerInfo::FindVfnPtr(void *vfnptr)
   1.878 +	{
   1.879 +		VfnPtrListIter iter = m_VfnPtrs.find(vfnptr);
   1.880 +		return iter == m_VfnPtrs.end() ? NULL : &(*iter);
   1.881 +	}
   1.882 +	void CSourceHookImpl::CHookManagerInfo::SetInfo(int vtbl_offs, int vtbl_idx, const char *proto)
   1.883 +	{
   1.884 +		m_VtblOffs = vtbl_offs;
   1.885 +		m_VtblIdx = vtbl_idx;
   1.886 +		m_Proto = proto;
   1.887 +	}
   1.888 +	void CSourceHookImpl::CHookManagerInfo::SetHookfuncVfnptr(void *hookfunc_vfnptr)
   1.889 +	{
   1.890 +		m_HookfuncVfnptr = hookfunc_vfnptr;
   1.891 +	}
   1.892 +	void CSourceHookImpl::CHookManagerInfo::SetVersion(int version)
   1.893 +	{
   1.894 +		m_HookManVersion = version;
   1.895 +	}
   1.896 +	////////////////////////////
   1.897 +	// CVfnPtr
   1.898 +	////////////////////////////
   1.899 +
   1.900 +
   1.901 +	// If you get a crash here, the ptr passed is invalid
   1.902 +	// This usually means a SH_DECL_MANUALHOOK* with wrong thisptroffs/vtbloffs/vtblidx
   1.903 +	CSourceHookImpl::CVfnPtr::CVfnPtr(void *ptr) : m_Ptr(ptr), m_OrigEntry(*reinterpret_cast<void**>(ptr))
   1.904 +	{
   1.905 +	}
   1.906 +	CSourceHookImpl::CVfnPtr::~CVfnPtr()
   1.907 +	{
   1.908 +	}
   1.909 +
   1.910 +	void *CSourceHookImpl::CVfnPtr::GetVfnPtr()
   1.911 +	{
   1.912 +		return m_Ptr;
   1.913 +	}
   1.914 +
   1.915 +	void *CSourceHookImpl::CVfnPtr::GetOrigEntry()
   1.916 +	{
   1.917 +		return m_OrigEntry;
   1.918 +	}
   1.919 +
   1.920 +	IIface *CSourceHookImpl::CVfnPtr::FindIface(void *ptr)
   1.921 +	{
   1.922 +		IfaceListIter iter = m_Ifaces.find(ptr);
   1.923 +		return iter == m_Ifaces.end() ? NULL : &(*iter);
   1.924 +	}
   1.925 +
   1.926 +	////////////////////////////
   1.927 +	// CIface
   1.928 +	////////////////////////////
   1.929 +	CSourceHookImpl::CIface::CIface(void *ptr) : m_Ptr(ptr)
   1.930 +	{
   1.931 +	}
   1.932 +	CSourceHookImpl::CIface::~CIface()
   1.933 +	{
   1.934 +	}
   1.935 +
   1.936 +	void *CSourceHookImpl::CIface::GetPtr()
   1.937 +	{
   1.938 +		return m_Ptr;
   1.939 +	}
   1.940 +
   1.941 +	IHookList *CSourceHookImpl::CIface::GetPreHooks()
   1.942 +	{
   1.943 +		return &m_PreHooks;
   1.944 +	}
   1.945 +	IHookList *CSourceHookImpl::CIface::GetPostHooks()
   1.946 +	{
   1.947 +		return &m_PostHooks;
   1.948 +	}
   1.949 +
   1.950 +	////////////////////////////
   1.951 +	// CHookList
   1.952 +	////////////////////////////
   1.953 +
   1.954 +	CSourceHookImpl::CHookList::CHookList() : m_FreeIters(NULL), m_UsedIters(NULL),
   1.955 +		m_Recall(false)
   1.956 +	{
   1.957 +	}
   1.958 +	CSourceHookImpl::CHookList::CHookList(const CHookList &other) : m_List(other.m_List),
   1.959 +		m_FreeIters(NULL), m_UsedIters(NULL), m_Recall(false)
   1.960 +	{
   1.961 +	}
   1.962 +
   1.963 +	CSourceHookImpl::CHookList::~CHookList()
   1.964 +	{
   1.965 +		while (m_FreeIters)
   1.966 +		{
   1.967 +			CIter *iter = m_FreeIters->m_pNext;
   1.968 +			delete m_FreeIters;
   1.969 +			m_FreeIters = iter;
   1.970 +		}
   1.971 +		while (m_UsedIters)
   1.972 +		{
   1.973 +			CIter *iter = m_UsedIters->m_pNext;
   1.974 +			delete m_UsedIters;
   1.975 +			m_UsedIters = iter;
   1.976 +		}
   1.977 +	}
   1.978 +	IHookList::IIter *CSourceHookImpl::CHookList::GetIter()
   1.979 +	{
   1.980 +		m_RQFlag = true;
   1.981 +
   1.982 +		CIter *ret;
   1.983 +		if (m_FreeIters)
   1.984 +		{
   1.985 +			ret = m_FreeIters;
   1.986 +			m_FreeIters = ret->m_pNext;
   1.987 +			ret->GoToBegin();
   1.988 +		}
   1.989 +		else
   1.990 +		{
   1.991 +			ret = new CIter(this);
   1.992 +		}
   1.993 +		
   1.994 +		// Muuuh, if we're recalling, it shall be a copy of the last iterator, incremented by one
   1.995 +		if (m_Recall && m_UsedIters)
   1.996 +		{
   1.997 +			ret->Set(m_UsedIters);		// m_UsedIters is the last returned and not released iterator
   1.998 +			ret->Next();				// Use next instead of directly incrementing its m_Iter:
   1.999 +										// skips paused plugins
  1.1000 +		}
  1.1001 +
  1.1002 +		ret->m_pNext = m_UsedIters;
  1.1003 +		ret->m_pPrev = NULL;
  1.1004 +		if (m_UsedIters)
  1.1005 +			m_UsedIters->m_pPrev = ret;
  1.1006 +		m_UsedIters = ret;
  1.1007 +
  1.1008 +		m_Recall = false;
  1.1009 +
  1.1010 +		return ret;
  1.1011 +	}
  1.1012 +	void CSourceHookImpl::CHookList::ReleaseIter(IIter *pIter)
  1.1013 +	{
  1.1014 +		CIter *pIter2 = static_cast<CIter*>(pIter);
  1.1015 +
  1.1016 +		// Unlink from m_UsedIters
  1.1017 +
  1.1018 +		if (pIter2->m_pNext)
  1.1019 +			pIter2->m_pNext->m_pPrev = pIter2->m_pPrev;
  1.1020 +		if (pIter2->m_pPrev)
  1.1021 +			pIter2->m_pPrev->m_pNext = pIter2->m_pNext;
  1.1022 +		if (pIter2 == m_UsedIters)
  1.1023 +			m_UsedIters = NULL;
  1.1024 +
  1.1025 +		// Link to m_FreeIters
  1.1026 +
  1.1027 +		pIter2->m_pNext = m_FreeIters;
  1.1028 +
  1.1029 +		m_FreeIters = pIter2;
  1.1030 +
  1.1031 +		// Reset recall state.
  1.1032 +		m_Recall = false;
  1.1033 +	}
  1.1034 +
  1.1035 +	CSourceHookImpl::CHookList::CIter::CIter(CHookList *pList) : m_pList(pList), m_pNext(NULL)
  1.1036 +	{
  1.1037 +		GoToBegin();
  1.1038 +	}
  1.1039 +	CSourceHookImpl::CHookList::CIter::~CIter()
  1.1040 +	{
  1.1041 +	}
  1.1042 +
  1.1043 +	void CSourceHookImpl::CHookList::CIter::Set(CIter *pOther)
  1.1044 +	{
  1.1045 +		m_Iter = pOther->m_Iter;
  1.1046 +	}
  1.1047 +
  1.1048 +	void CSourceHookImpl::CHookList::CIter::GoToBegin()
  1.1049 +	{
  1.1050 +		m_Iter = m_pList->m_List.begin();
  1.1051 +		SkipPaused();
  1.1052 +	}
  1.1053 +
  1.1054 +	bool CSourceHookImpl::CHookList::CIter::End()
  1.1055 +	{
  1.1056 +		if (!m_pList)
  1.1057 +			return false;
  1.1058 +		return m_Iter == m_pList->m_List.end();
  1.1059 +	}
  1.1060 +	void CSourceHookImpl::CHookList::CIter::Next()
  1.1061 +	{
  1.1062 +		if (!m_pList)
  1.1063 +			return;
  1.1064 +		++m_Iter;
  1.1065 +		SkipPaused();
  1.1066 +	}
  1.1067 +	void CSourceHookImpl::CHookList::CIter::Clear()
  1.1068 +	{
  1.1069 +		m_pList = NULL;
  1.1070 +	}
  1.1071 +	void CSourceHookImpl::CHookList::CIter::SkipPaused()
  1.1072 +	{
  1.1073 +		while (m_Iter != m_pList->m_List.end() && m_Iter->paused)
  1.1074 +			++m_Iter;
  1.1075 +	}
  1.1076 +
  1.1077 +	ISHDelegate *CSourceHookImpl::CHookList::CIter::Handler()
  1.1078 +	{
  1.1079 +		return m_Iter->handler;
  1.1080 +	}
  1.1081 +	int CSourceHookImpl::CHookList::CIter::ThisPtrOffs()
  1.1082 +	{
  1.1083 +		return m_Iter->thisptr_offs;
  1.1084 +	}
  1.1085 +
  1.1086 +	//////////////////////////////////////////////////////////////////////////
  1.1087 +	// CProto
  1.1088 +	//////////////////////////////////////////////////////////////////////////
  1.1089 +	char *CSourceHookImpl::CProto::DupProto(const char *p)
  1.1090 +	{
  1.1091 +		char *newproto;
  1.1092 +		if (*p)
  1.1093 +		{
  1.1094 +			size_t len = strlen(p);
  1.1095 +			newproto = new char[len+1];
  1.1096 +			memcpy(newproto, p, len+1);
  1.1097 +		} else {
  1.1098 +			const ProtoInfo *pi1 = reinterpret_cast<const ProtoInfo *>(p);
  1.1099 +			int *ar_copy = new int[pi1->numOfParams + 1];
  1.1100 +			for (int i = 0; i <= pi1->numOfParams; i++)
  1.1101 +				ar_copy[i] = pi1->params[i];
  1.1102 +			ProtoInfo *copy = new ProtoInfo(pi1->retTypeSize, pi1->numOfParams, ar_copy);
  1.1103 +			newproto = reinterpret_cast<char *>(copy);
  1.1104 +		}
  1.1105 +
  1.1106 +		return newproto;
  1.1107 +	}
  1.1108 +
  1.1109 +	void CSourceHookImpl::CProto::FreeProto(char *prot)
  1.1110 +	{
  1.1111 +		if (*prot)
  1.1112 +		{
  1.1113 +			delete [] prot;
  1.1114 +		} else {
  1.1115 +			ProtoInfo *pi = reinterpret_cast<ProtoInfo *>(prot);
  1.1116 +			delete [] pi->params;
  1.1117 +			delete pi;
  1.1118 +		}
  1.1119 +	}
  1.1120 +
  1.1121 +	bool CSourceHookImpl::CProto::Equal(const char *p1, const char *p2)
  1.1122 +	{
  1.1123 +		if (*p1 && *p2)			// Case1: Both old
  1.1124 +		{
  1.1125 +			// As in old versions
  1.1126 +			return strcmp(p1, p2) == 0;
  1.1127 +		}
  1.1128 +		else if (!*p1 && !*p2)	// Case2: Both new
  1.1129 +		{
  1.1130 +			const ProtoInfo *pi1 = reinterpret_cast<const ProtoInfo*>(p1);
  1.1131 +			const ProtoInfo *pi2 = reinterpret_cast<const ProtoInfo*>(p2);
  1.1132 +
  1.1133 +			if (pi1->retTypeSize == pi2->retTypeSize &&
  1.1134 +				pi1->numOfParams == pi2->numOfParams)
  1.1135 +			{
  1.1136 +				// params[0] is 0 for "normal" functions and -1 for vararg functions
  1.1137 +				// params[1] is size of first parameter
  1.1138 +				// params[2] is size of second parameter ...
  1.1139 +				for (int i = 0; i <= pi1->numOfParams; ++i)
  1.1140 +				{
  1.1141 +					if (pi1->params[i] != pi2->params[i])
  1.1142 +						return false;
  1.1143 +				}
  1.1144 +				return true;
  1.1145 +			}
  1.1146 +			else
  1.1147 +			{
  1.1148 +				return false;
  1.1149 +			}
  1.1150 +		}
  1.1151 +		else					// Case3: Mixed old/new
  1.1152 +		{
  1.1153 +			// Trust the user
  1.1154 +			return true;
  1.1155 +		}
  1.1156 +	}
  1.1157 +
  1.1158 +
  1.1159 +	//////////////////////////////////////////////////////////////////////////
  1.1160 +	// CHookManagerContainer
  1.1161 +	//////////////////////////////////////////////////////////////////////////
  1.1162 +	void CSourceHookImpl::CHookManagerContainer::AddHookManager(Plugin plug, const CHookManagerInfo &hookman)
  1.1163 +	{
  1.1164 +		iterator iter;
  1.1165 +		// Check whether such a hook manager already exists; if yes, ignore.
  1.1166 +		for (iter = begin(); iter != end(); ++iter)
  1.1167 +		{
  1.1168 +			if (iter->m_Plug == plug && iter->m_Func == hookman.m_Func)
  1.1169 +				return;
  1.1170 +		}
  1.1171 +
  1.1172 +		// It doesn't -> add it. Add it to the end of its version group.
  1.1173 +		for (iter = begin(); iter != end(); ++iter)
  1.1174 +		{
  1.1175 +			if (iter->m_HookManVersion < hookman.m_HookManVersion)
  1.1176 +				break;
  1.1177 +		}
  1.1178 +
  1.1179 +		bool isBeginning = iter == begin();
  1.1180 +
  1.1181 +		insert(iter, hookman);
  1.1182 +
  1.1183 +		// If we inserted it at the beginning and if the dam breaks open many years too soon
  1.1184 +		// and if there is more than one hookman and if the second one isn't empty, transfer
  1.1185 +		// hooks from second to first
  1.1186 +
  1.1187 +		if (isBeginning && size() > 1)
  1.1188 +		{
  1.1189 +			iter = begin();
  1.1190 +			iterator second = iter;
  1.1191 +			++second;
  1.1192 +
  1.1193 +			if (!second->m_VfnPtrs.empty())
  1.1194 +			{
  1.1195 +				// Move the vfnptrs from the old hook manager to the new one
  1.1196 +				iter->m_VfnPtrs = second->m_VfnPtrs;
  1.1197 +				second->m_VfnPtrs.clear();
  1.1198 +
  1.1199 +				// Unregister the old one, register the new one
  1.1200 +				second->m_Func(HA_Unregister, NULL);
  1.1201 +				iter->m_Func(HA_Register, &(*iter));
  1.1202 +
  1.1203 +				// Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
  1.1204 +				// or whatever
  1.1205 +				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = iter->m_VfnPtrs.begin();
  1.1206 +					vfnptr_iter != iter->m_VfnPtrs.end(); ++vfnptr_iter)
  1.1207 +				{
  1.1208 +					// And DEREFERENCE newHookMan->m_HookfuncVfnptr!
  1.1209 +					// otherwise it will be executing the vtable... had to find out the hard way
  1.1210 +					*reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = *reinterpret_cast<void**>(iter->m_HookfuncVfnptr);
  1.1211 +				}
  1.1212 +			}
  1.1213 +		}
  1.1214 +	}
  1.1215 +}