sourcehook/sourcehook.cpp
changeset 380 f9e21a2ac558
parent 333 3813f1ac0cfe
child 386 08583103ba6f
     1.1 --- a/sourcehook/sourcehook.cpp	Sun Oct 07 03:12:19 2007 +0000
     1.2 +++ b/sourcehook/sourcehook.cpp	Sun Oct 07 22:10:07 2007 +0000
     1.3 @@ -39,1425 +39,1062 @@
     1.4  			return -1;
     1.5  		return 0;
     1.6  	}
     1.7 -	CSourceHookImpl::CSourceHookImpl() : m_OneIgnore(NULL), m_IgnoreActive(false)
     1.8 -	{
     1.9 -	}
    1.10 -	CSourceHookImpl::~CSourceHookImpl()
    1.11 -	{
    1.12 -	}
    1.13  
    1.14 -	int CSourceHookImpl::GetIfaceVersion()
    1.15 -	{
    1.16 -		return SH_IFACE_VERSION;
    1.17 -	}
    1.18 -
    1.19 -	int CSourceHookImpl::GetImplVersion()
    1.20 -	{
    1.21 -		return SH_IMPL_VERSION;
    1.22 -	}
    1.23 -
    1.24 -	bool CSourceHookImpl::IsPluginInUse(Plugin plug)
    1.25 +	namespace Impl
    1.26  	{
    1.27 -		// Iterate through all hook managers which are in this plugin
    1.28 -		// Iterate through their vfnptrs, ifaces, hooks
    1.29 -		// If a hook from an other plugin is found, return true
    1.30 -		// Return false otherwise
    1.31 -#define TMP_CHECK_LIST(name) \
    1.32 -	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
    1.33 -		if (hook_iter->plug == plug) \
    1.34 +		//////////////////////////////////////////////////////////////////////////
    1.35 +		// CProto
    1.36 +		//////////////////////////////////////////////////////////////////////////
    1.37 +		ProtoInfo *CProto::DupProto(const ProtoInfo *src)
    1.38 +		{
    1.39 +			if (src == NULL)
    1.40 +				return NULL;
    1.41 +
    1.42 +			PassInfo *newParamsPassInfo = new PassInfo[src->numOfParams + 1];
    1.43 +			for (int i = 0; i <= src->numOfParams; ++i)
    1.44 +				newParamsPassInfo[i] = src->paramsPassInfo[i];
    1.45 +
    1.46 +			ProtoInfo *newProto = new ProtoInfo;
    1.47 +			newProto->retPassInfo = src->retPassInfo;
    1.48 +			newProto->paramsPassInfo = newParamsPassInfo;
    1.49 +			newProto->numOfParams = src->numOfParams;
    1.50 +			newProto->convention = src->convention;
    1.51 +
    1.52 +			return newProto;
    1.53 +		}
    1.54 +
    1.55 +		void CProto::FreeProto(ProtoInfo *prot)
    1.56 +		{
    1.57 +			if (!prot)
    1.58 +				return;
    1.59 +
    1.60 +			delete [] prot->paramsPassInfo;
    1.61 +			delete prot;
    1.62 +		}
    1.63 +
    1.64 +		bool CProto::Equal(const ProtoInfo *p1, const ProtoInfo *p2)
    1.65 +		{
    1.66 +			if (!p1 || !p2)
    1.67 +				return false;
    1.68 +
    1.69 +			if (p1->numOfParams != p2->numOfParams)
    1.70 +				return false;
    1.71 +
    1.72 +			if (p1->convention != ProtoInfo::CallConv_Unknown && p2->convention != ProtoInfo::CallConv_Unknown &&
    1.73 +				p1->convention != p2->convention)
    1.74 +				return false;
    1.75 +
    1.76 +			if (p1->retPassInfo.size != p2->retPassInfo.size)
    1.77 +				return false;
    1.78 +
    1.79 +			// Skip params[0] : dummy
    1.80 +			for (int i = 1; i <= p1->numOfParams; ++i)
    1.81 +			{
    1.82 +				if (p1->paramsPassInfo[i].size != p2->paramsPassInfo[i].size)
    1.83 +					return false;
    1.84 +				if (p1->paramsPassInfo[i].type != PassInfo::PassType_Unknown && p2->paramsPassInfo[i].type != PassInfo::PassType_Unknown)
    1.85 +				{
    1.86 +					if (p1->paramsPassInfo[i].type != p2->paramsPassInfo[i].type)
    1.87 +						return false;
    1.88 +					if (p1->paramsPassInfo[i].flags != p2->paramsPassInfo[i].flags)
    1.89 +						return false;
    1.90 +				}
    1.91 +			}
    1.92 +
    1.93  			return true;
    1.94 +		}
    1.95  
    1.96 -		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
    1.97 -			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
    1.98 +
    1.99 +		//////////////////////////////////////////////////////////////////////////
   1.100 +		// CHookManContainerList
   1.101 +		//////////////////////////////////////////////////////////////////////////
   1.102 +		CHookManagerContainer &CHookManContainerList::GetContainer(int vtbloffs, int vtblidx, const CProto &proto)
   1.103 +		{
   1.104 +			iterator iter = find(CHookManagerContainer::Descriptor(vtbloffs, vtblidx, proto));
   1.105 +			if (iter == end())
   1.106 +			{
   1.107 +				CHookManagerContainer newCont(vtbloffs, vtblidx, proto);
   1.108 +				push_back(newCont);
   1.109 +				return back();
   1.110 +			}
   1.111 +			else
   1.112 +			{
   1.113 +				return *iter;
   1.114 +			}
   1.115 +		}
   1.116 +
   1.117 +		void CHookManContainerList::RemoveHookMans(Plugin plug)
   1.118 +		{
   1.119 +			for (iterator iter = begin(); iter != end(); ++iter)
   1.120 +				iter->RemoveHookMans(plug);
   1.121 +		}
   1.122 +
   1.123 +		void CHookManContainerList::RemoveHookMans(Plugin plug, HookManagerPubFunc pubFunc)
   1.124 +		{
   1.125 +			for (iterator iter = begin(); iter != end(); ++iter)
   1.126 +				iter->RemoveHookMans(plug, pubFunc);
   1.127 +		}
   1.128 +
   1.129 +		//////////////////////////////////////////////////////////////////////////
   1.130 +		// CHookManagerContainer
   1.131 +		//////////////////////////////////////////////////////////////////////////
   1.132 +		
   1.133 +		bool CHookManagerContainer::AddHookManager(const CHookManager &hookMan)
   1.134  		{
   1.135 -			for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
   1.136 -				hmil_iter != hmcl_iter->end(); ++hmil_iter)
   1.137 +			iterator iter;
   1.138 +
   1.139 +			// Don't accept invalid hook managers
   1.140 +			if (!hookMan)
   1.141 +				return false;
   1.142 +
   1.143 +			// Check whether such a hook manager already exists; if yes, ignore.
   1.144 +			iter = find(hookMan);
   1.145 +			if (iter != end())
   1.146  			{
   1.147 -				if (hmil_iter->m_Plug != plug)
   1.148 -					continue;
   1.149 -				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
   1.150 -					vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
   1.151 +				// but make sure that it's activated (ms_HI stored)
   1.152 +				iter->Register();
   1.153 +				return true;
   1.154 +			}
   1.155 +
   1.156 +			// It doesn't -> add it. Add it to the end of its version group.
   1.157 +			for (iter = begin(); iter != end(); ++iter)
   1.158 +			{
   1.159 +				if (iter->GetVersion() < hookMan.GetVersion())
   1.160 +					break;
   1.161 +			}
   1.162 +
   1.163 +			bool isBeginning = iter == begin();
   1.164 +
   1.165 +			insert(iter, hookMan);
   1.166 +
   1.167 +			if (isBeginning)
   1.168 +			{
   1.169 +				iter = begin();
   1.170 +
   1.171 +				if (size() > 1)
   1.172  				{
   1.173 -					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
   1.174 -						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
   1.175 +					// If the next hookman isn't empty (there were hooks before, but this hookman is better)
   1.176 +					// transfer its vfnptrs and deactivate it
   1.177 +
   1.178 +					iterator second = iter;
   1.179 +					++second;
   1.180 +
   1.181 +					if (!second->GetVfnPtrList().empty())
   1.182  					{
   1.183 -						List<HookInfo>::iterator hook_iter;
   1.184 -						TMP_CHECK_LIST(m_PreHooks);
   1.185 -						TMP_CHECK_LIST(m_PostHooks);
   1.186 +						// Move the vfnptrs from the old hook manager to the new one
   1.187 +						iter->GetVfnPtrList() = second->GetVfnPtrList();
   1.188 +						second->GetVfnPtrList().clear();
   1.189 +
   1.190 +						// Unregister the old one, register the new one
   1.191 +						second->Unregister();
   1.192 +
   1.193 +						// Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
   1.194 +						// :TODO: change this to something like for_all :X
   1.195 +						for (List<CVfnPtr>::iterator vfnptr_iter = iter->GetVfnPtrList().begin();
   1.196 +							vfnptr_iter != iter->GetVfnPtrList().end(); ++vfnptr_iter)
   1.197 +						{
   1.198 +							vfnptr_iter->Patch(iter->GetHookFunc());
   1.199 +						}
   1.200  					}
   1.201  				}
   1.202 +
   1.203 +				// activate the new active hookman
   1.204 +				iter->Register();
   1.205 +			}
   1.206 +			
   1.207 +			return true;
   1.208 +		}
   1.209 +
   1.210 +		void CHookManagerContainer::RemoveHookMans(Plugin plug, HookManagerPubFunc pubFunc)
   1.211 +		{
   1.212 +			bool erasethis = false;
   1.213 +
   1.214 +			for (iterator iter = begin(); iter != end(); erasethis ? (iter = erase(iter)) : ++iter)
   1.215 +			{
   1.216 +				erasethis = false;
   1.217 +				if (iter->GetOwnerPlugin() == plug
   1.218 +					&& (pubFunc == NULL ? true : (iter->GetPubFunc() == pubFunc)))
   1.219 +				{
   1.220 +					if (iter == begin() && !iter->GetVfnPtrList().empty())
   1.221 +					{
   1.222 +						// The hook manager is active
   1.223 +						// -> Transfer its hooks to the next hook manager (which _has_ to exist)
   1.224 +						SH_ASSERT(size() > 1, ("No more hook managers!?"));
   1.225 +
   1.226 +						iterator second = iter;
   1.227 +						++second;
   1.228 +
   1.229 +						SH_ASSERT(second->GetOwnerPlugin() != plug, ("New hook manager from same plugin!"));
   1.230 +
   1.231 +						second->GetVfnPtrList() = iter->GetVfnPtrList();
   1.232 +						iter->GetVfnPtrList().clear();
   1.233 +
   1.234 +						second->Register();
   1.235 +						iter->Unregister();
   1.236 +
   1.237 +						// Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
   1.238 +						// :TODO: change this to something like for_all :X
   1.239 +						for (List<CVfnPtr>::iterator vfnptr_iter = second->GetVfnPtrList().begin();
   1.240 +							vfnptr_iter != second->GetVfnPtrList().end(); ++vfnptr_iter)
   1.241 +						{
   1.242 +							vfnptr_iter->Patch(second->GetHookFunc());
   1.243 +						}
   1.244 +					}
   1.245 +					erasethis = true;
   1.246 +				}
   1.247  			}
   1.248  		}
   1.249  		
   1.250 -#undef TMP_CHECK_LIST
   1.251 -		return false;
   1.252 -	}
   1.253 -
   1.254 -	void CSourceHookImpl::UnloadPlugin(Plugin plug)
   1.255 -	{
   1.256 -		// 1) Manually remove all hooks by this plugin
   1.257 -		// 2) Manually remove all hook mans by this plugin
   1.258 -
   1.259 -		List<RemoveHookInfo> hookstoremove;
   1.260 -		List<RemoveHookManInfo> hookmanstoremove;
   1.261 -		HookManInfoList::iterator hmil_iter;
   1.262 -
   1.263 -#define TMP_CHECK_LIST(name, ispost) \
   1.264 -	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
   1.265 -		if (hook_iter->plug == plug) \
   1.266 -			hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
   1.267 -			hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost)); \
   1.268 -
   1.269 -		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
   1.270 -			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
   1.271 +		//////////////////////////////////////////////////////////////////////////
   1.272 +		// CHookManager
   1.273 +		//////////////////////////////////////////////////////////////////////////
   1.274 +		void CHookManager::SetInfo(int hookman_version, int vtbloffs, int vtblidx,
   1.275 +			ProtoInfo *proto, void *hookfunc_vfnptr)
   1.276  		{
   1.277 -			for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
   1.278 -				hmil_iter != hmcl_iter->end(); ++hmil_iter)
   1.279 -			{
   1.280 -				if (hmil_iter->m_Plug == plug)
   1.281 -					hookmanstoremove.push_back(RemoveHookManInfo(plug, hmil_iter->m_Func));
   1.282 -
   1.283 -				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
   1.284 -					vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
   1.285 -				{
   1.286 -					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
   1.287 -						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
   1.288 -					{
   1.289 -						List<HookInfo>::iterator hook_iter;
   1.290 -						TMP_CHECK_LIST(m_PreHooks, false);
   1.291 -						TMP_CHECK_LIST(m_PostHooks, true);
   1.292 -					}
   1.293 -				}
   1.294 -			}
   1.295 -		}
   1.296 -#undef TMP_CHECK_LIST
   1.297 -
   1.298 -		for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   1.299 -			RemoveHook(*rmiter);
   1.300 -
   1.301 -		for (List<RemoveHookManInfo>::iterator rmiter = hookmanstoremove.begin(); rmiter != hookmanstoremove.end(); ++rmiter)
   1.302 -			RemoveHookManager(*rmiter);
   1.303 -	}
   1.304 -
   1.305 -	void CSourceHookImpl::RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc)
   1.306 -	{
   1.307 -		// Moo!
   1.308 -
   1.309 -		CHookManagerInfo tmp;
   1.310 -		if (pubFunc(HA_GetInfo, &tmp) != 0)
   1.311 -			return;
   1.312 -
   1.313 -		
   1.314 -		HookManContList::iterator hmcl_iter = m_HookMans.find(
   1.315 -			CHookManagerContainer::HMCI(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx));
   1.316 -
   1.317 -		if (hmcl_iter == m_HookMans.end())
   1.318 -		{
   1.319 -			// Moo?
   1.320 -			return;
   1.321 -		}
   1.322 -
   1.323 -		CHookManagerContainer::iterator hmil_iter = hmcl_iter->find(
   1.324 -			CHookManagerInfo::Descriptor(plug, pubFunc));
   1.325 -
   1.326 -		if (hmil_iter == hmcl_iter->end())
   1.327 -		{
   1.328 -			// Moo?
   1.329 -			return;
   1.330 +			m_Version = hookman_version;
   1.331 +			m_VtblOffs = vtbloffs;
   1.332 +			m_VtblIdx = vtblidx;
   1.333 +			m_Proto = proto;
   1.334 +			m_HookfuncVfnptr = hookfunc_vfnptr;
   1.335  		}
   1.336  
   1.337 -		bool stillInUse = false;
   1.338 -		List<RemoveHookInfo> hookstoremove;
   1.339 -
   1.340 -		// Iterate through all of the hook manager's hooks. Remove all hooks from the hookman's plugin.
   1.341 -#define TMP_CHECK_LIST(name, ispost) \
   1.342 -	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
   1.343 -		if (hook_iter->plug == plug) \
   1.344 -			hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
   1.345 -			hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost)); \
   1.346 -		else \
   1.347 -			stillInUse = true; \
   1.348 -
   1.349 -		for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
   1.350 -			vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
   1.351 -		{
   1.352 -			for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
   1.353 -				iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
   1.354 -			{
   1.355 -				List<HookInfo>::iterator hook_iter;
   1.356 -				TMP_CHECK_LIST(m_PreHooks, false);
   1.357 -				TMP_CHECK_LIST(m_PostHooks, true);
   1.358 -			}
   1.359 -		}
   1.360 -#undef TMP_CHECK_LIST
   1.361 -
   1.362 -		for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   1.363 -			RemoveHook(*rmiter);
   1.364 -
   1.365 -		CHookManagerInfo info = *hmil_iter;
   1.366 -
   1.367 -		// Unlink the hook manager from the list
   1.368 -		hmcl_iter->erase(hmil_iter);
   1.369 -
   1.370 -		// If there were any hooks from other plugins, find a new suitable hook manager.
   1.371 -		if (stillInUse)
   1.372 +		CVfnPtr &CHookManager::GetVfnPtr(void *vfnptr)
   1.373  		{
   1.374 -			// Find a suitable hook manager in an other plugin
   1.375 -			hmil_iter = hmcl_iter->begin();
   1.376 -
   1.377 -			// This should _never_ happen.
   1.378 -			// If there is a hook from an other plugin, the plugin must have provided a hook manager as well.
   1.379 -			SH_ASSERT(hmil_iter != hmcl_iter->end(),
   1.380 -				("Could not find a suitable hook manager in an other plugin!"));
   1.381 -
   1.382 -			// AddHook should make sure that every plugin only has _one_ hook manager for _one_ proto/vi/vo
   1.383 -			SH_ASSERT(hmil_iter->m_Plug != plug, ("New hook manager from same plugin!"));
   1.384 -
   1.385 -			// The first hook manager should be always used - so the new hook manager has to be empty
   1.386 -			SH_ASSERT(hmil_iter->m_VfnPtrs.empty(), ("New hook manager not empty!"));
   1.387 -
   1.388 -			// Move the vfnptrs from the old hook manager to the new one
   1.389 -			hmil_iter->m_VfnPtrs = info.m_VfnPtrs;
   1.390 -
   1.391 -			// Unregister the old one, register the new one
   1.392 -			info.m_Func(HA_Unregister, NULL);
   1.393 -			hmil_iter->m_Func(HA_Register, &(*hmil_iter));
   1.394 -
   1.395 -			// Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
   1.396 -			// or whatever
   1.397 -			for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
   1.398 -				vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
   1.399 +			List<CVfnPtr>::iterator iter = m_VfnPtrList.find(vfnptr);
   1.400 +			if (iter == m_VfnPtrList.end())
   1.401  			{
   1.402 -				// And DEREFERENCE newHookMan->m_HookfuncVfnptr!
   1.403 -				// otherwise it will be executing the vtable... had to find out the hard way
   1.404 -				*reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = *reinterpret_cast<void**>(hmil_iter->m_HookfuncVfnptr);
   1.405 -			}
   1.406 -		}
   1.407 -	}
   1.408 -
   1.409 -	void CSourceHookImpl::RemoveHookManager(RemoveHookManInfo info)
   1.410 -	{
   1.411 -		RemoveHookManager(info.plug, info.hookman);
   1.412 -	}
   1.413 -
   1.414 -	void CSourceHookImpl::CompleteShutdown()
   1.415 -	{
   1.416 -		// Remove all hooks
   1.417 -
   1.418 -		List<RemoveHookInfo> hookstoremove;
   1.419 +				CVfnPtr newVfnPtr(vfnptr);
   1.420 +				m_VfnPtrList.push_back(newVfnPtr);
   1.421  
   1.422 -#define TMP_CHECK_LIST(name, ispost) \
   1.423 -	for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
   1.424 -		hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
   1.425 -			hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost))
   1.426 -		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
   1.427 -			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
   1.428 -		{
   1.429 -			for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
   1.430 -				hmil_iter != hmcl_iter->end(); ++hmil_iter)
   1.431 -			{
   1.432 -				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
   1.433 -					vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
   1.434 -				{
   1.435 -					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
   1.436 -						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
   1.437 -					{
   1.438 -						List<HookInfo>::iterator hook_iter;
   1.439 -						TMP_CHECK_LIST(m_PreHooks, false);
   1.440 -						TMP_CHECK_LIST(m_PostHooks, true);
   1.441 -					}
   1.442 -				}
   1.443 -			}
   1.444 -		}
   1.445 -#undef TMP_CHECK_LIST
   1.446 -
   1.447 -		for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   1.448 -			RemoveHook(*rmiter);
   1.449 -
   1.450 -		m_HookMans.clear();
   1.451 -	}
   1.452 -
   1.453 -
   1.454 -	bool CSourceHookImpl::AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   1.455 -	{
   1.456 -		return AddHookNew(plug, Hook_Normal, iface, thisptr_offs, myHookMan, handler, post) != 0 ? true : false;
   1.457 -	}
   1.458 +				newVfnPtr.Patch(GetHookFunc());
   1.459  
   1.460 -	int CSourceHookImpl::AddHookNew(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
   1.461 -		ISHDelegate *handler, bool post)
   1.462 -	{
   1.463 -		void *adjustediface = NULL;
   1.464 -		void **cur_vtptr = NULL;
   1.465 -		void *cur_vfnptr = NULL;
   1.466 -
   1.467 -		if (mode != Hook_Normal && mode != Hook_VP && mode != Hook_DVP)
   1.468 -			return 0;
   1.469 -
   1.470 -		// 1) Get info about the hook manager
   1.471 -		CHookManagerInfo tmp;
   1.472 -		if (myHookMan(HA_GetInfo, &tmp) != 0)
   1.473 -			return 0;
   1.474 -
   1.475 -		tmp.m_Func = myHookMan;
   1.476 -		tmp.m_Plug = plug;
   1.477 -
   1.478 -		CHookManagerContainer::HMCI hmci(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx);
   1.479 -
   1.480 -		// Add the container if not already added
   1.481 -		HookManContList::iterator hmcl_iter = m_HookMans.find(hmci);
   1.482 -		if (hmcl_iter == m_HookMans.end())
   1.483 -		{
   1.484 -			m_HookMans.push_back(CHookManagerContainer(hmci));
   1.485 -			hmcl_iter = m_HookMans.end();
   1.486 -			--hmcl_iter;
   1.487 -		}
   1.488 -
   1.489 -		hmcl_iter->AddHookManager(plug, tmp);
   1.490 -
   1.491 -		CHookManagerContainer::iterator hookman = hmcl_iter->begin();
   1.492 -		SH_ASSERT(hookman != hmcl_iter->end(), ("No hookman found - but we've just added one!"));
   1.493 -
   1.494 -		// Check whether any other container holds a hook manager which holds this vfnptr
   1.495 -		// If yes, it means that the two are incompatible, so return false.
   1.496 -		for (HookManContList::iterator hmcl_iter2 = m_HookMans.begin();
   1.497 -			hmcl_iter2 != m_HookMans.end(); ++hmcl_iter2)
   1.498 -		{
   1.499 -			if (hmcl_iter2 != hmcl_iter)
   1.500 +				return m_VfnPtrList.back();
   1.501 +			}
   1.502 +			else
   1.503  			{
   1.504 -				for (CHookManagerContainer::iterator hmil_iter = hmcl_iter2->begin();
   1.505 -					hmil_iter != hmcl_iter2->end(); ++hmil_iter)
   1.506 -				{
   1.507 -					if (hmil_iter->m_VfnPtrs.find(cur_vfnptr) != hmil_iter->m_VfnPtrs.end())
   1.508 -						return 0;
   1.509 -				}
   1.510 +				return *iter;
   1.511  			}
   1.512  		}
   1.513  
   1.514 -		// Tell it to store the pointer if it's not already active
   1.515 -		if (hookman->m_VfnPtrs.empty())
   1.516 -			hookman->m_Func(HA_Register, &(*hookman));
   1.517 -
   1.518 -
   1.519 -		// find vfnptr
   1.520 -		if (mode == Hook_Normal || mode == Hook_VP)
   1.521 +		//////////////////////////////////////////////////////////////////////////
   1.522 +		// CVfnPtr
   1.523 +		//////////////////////////////////////////////////////////////////////////
   1.524 +		
   1.525 +		bool CVfnPtr::Patch(void *newValue)
   1.526  		{
   1.527 -			adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
   1.528 +			if (!SetMemAccess(m_Ptr, sizeof(void*), SH_MEM_READ | SH_MEM_WRITE))
   1.529 +				return false;
   1.530  
   1.531 -			cur_vtptr = *reinterpret_cast<void***>(
   1.532 -				reinterpret_cast<char*>(adjustediface) + tmp.m_VtblOffs);
   1.533 -			cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.m_VtblIdx);
   1.534 +			*reinterpret_cast<void**>(m_Ptr) = newValue;
   1.535  
   1.536 -			// For Hook_VP, adjustediface will be set to NULL later
   1.537 -			// because we first have to patch callclasses (callclasses are deprecated but left in for backwards compat)
   1.538 -		}
   1.539 -		else if (mode == Hook_DVP)
   1.540 -		{
   1.541 -			adjustediface = NULL;
   1.542 -
   1.543 -			cur_vtptr = reinterpret_cast<void**>(iface);
   1.544 -			cur_vfnptr = cur_vtptr + tmp.m_VtblIdx;
   1.545 +			return true;
   1.546  		}
   1.547  
   1.548 -		CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.find(cur_vfnptr);
   1.549 -
   1.550 -		if (vfnptr_iter == hookman->m_VfnPtrs.end())
   1.551 +		CIface &CVfnPtr::GetIface(void *iface)
   1.552  		{
   1.553 -			// Add a new one
   1.554 -			CVfnPtr vfp(cur_vfnptr, &m_OneIgnore);
   1.555 -
   1.556 -			// Alter vtable entry
   1.557 -			if (!SetMemAccess(cur_vtptr, sizeof(void*) * (tmp.m_VtblIdx + 1), SH_MEM_READ | SH_MEM_WRITE))
   1.558 -				return 0;
   1.559 -
   1.560 -			*reinterpret_cast<void**>(cur_vfnptr) = *reinterpret_cast<void**>(hookman->m_HookfuncVfnptr);
   1.561 -
   1.562 -			hookman->m_VfnPtrs.push_back(vfp);
   1.563 -
   1.564 -			// Make vfnptr_iter point to the new element
   1.565 -			vfnptr_iter = hookman->m_VfnPtrs.end();
   1.566 -			--vfnptr_iter;
   1.567 -
   1.568 -			// Now that it is done, check whether we have to update any callclasses
   1.569 -			ApplyCallClassPatches(adjustediface, tmp.m_VtblOffs, tmp.m_VtblIdx, vfp.m_OrigEntry);
   1.570 -		}
   1.571 -
   1.572 -		// If it's a VP hook, set adjustediface to NULL now ( see the comments at the beginning of sourcehook_impl.h )
   1.573 -		if (mode == Hook_VP)
   1.574 -			adjustediface = NULL;
   1.575 -
   1.576 -		CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.find(adjustediface);
   1.577 -		if (iface_iter == vfnptr_iter->m_Ifaces.end())
   1.578 -		{
   1.579 -			// Add a new one
   1.580 -			vfnptr_iter->m_Ifaces.push_back(CIface(adjustediface));
   1.581 -
   1.582 -			// Make iface_iter point to the new element
   1.583 -			iface_iter = vfnptr_iter->m_Ifaces.end();
   1.584 -			--iface_iter;
   1.585 -
   1.586 -			// If this is a VP-Hook-NULL interface, go through all other interfaces of this vfnptr and tell them!
   1.587 -			if (adjustediface == NULL)
   1.588 +			List<CIface>::iterator iter = m_IfaceList.find(iface);
   1.589 +			if (iter == m_IfaceList.end())
   1.590  			{
   1.591 -				for (CVfnPtr::IfaceListIter iface_iter2 = vfnptr_iter->m_Ifaces.begin();
   1.592 -					iface_iter2 != vfnptr_iter->m_Ifaces.end(); ++iface_iter2)
   1.593 +				CIface newIface(iface);
   1.594 +				if (iface == NULL)
   1.595  				{
   1.596 -					if (*iface_iter2 != NULL)
   1.597 -					{
   1.598 -						iface_iter2->m_PreHooks.SetVPList(&iface_iter->m_PreHooks.m_List);
   1.599 -						iface_iter2->m_PostHooks.SetVPList(&iface_iter->m_PostHooks.m_List);
   1.600 -					}
   1.601 +					m_IfaceList.push_front(newIface);
   1.602 +					return m_IfaceList.front();
   1.603 +				}
   1.604 +				else
   1.605 +				{
   1.606 +					m_IfaceList.push_back(newIface);
   1.607 +					return m_IfaceList.back();
   1.608  				}
   1.609  			}
   1.610  			else
   1.611  			{
   1.612 -				// If this is a new non-VP-Hook-NULL interface, look for a non-VP-Hook-NULL interface!
   1.613 -				for (CVfnPtr::IfaceListIter iface_iter2 = vfnptr_iter->m_Ifaces.begin();
   1.614 -					iface_iter2 != vfnptr_iter->m_Ifaces.end(); ++iface_iter2)
   1.615 -				{
   1.616 -					if (*iface_iter2 == NULL)
   1.617 -					{
   1.618 -						iface_iter->m_PreHooks.SetVPList(&iface_iter2->m_PreHooks.m_List);
   1.619 -						iface_iter->m_PostHooks.SetVPList(&iface_iter2->m_PostHooks.m_List);
   1.620 -						break;	// There can only be one!
   1.621 -					}
   1.622 -				}
   1.623 +				return *iter;
   1.624  			}
   1.625  		}
   1.626  
   1.627 -		// Add the hook
   1.628 -		HookInfo hookinfo;
   1.629 -		hookinfo.handler = handler;
   1.630 -		hookinfo.plug = plug;
   1.631 -		hookinfo.paused = false;
   1.632 -		hookinfo.thisptr_offs = thisptr_offs;
   1.633 -		hookinfo.hookid = m_HookIDMan.New(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx, cur_vfnptr,
   1.634 -			adjustediface, plug, thisptr_offs, handler, post);
   1.635 -
   1.636 -		if (post)
   1.637 -			iface_iter->m_PostHooks.m_List.push_back(hookinfo);
   1.638 -		else
   1.639 -			iface_iter->m_PreHooks.m_List.push_back(hookinfo);
   1.640 -
   1.641 -		return hookinfo.hookid;
   1.642 -	}
   1.643 -
   1.644 -	bool CSourceHookImpl::RemoveHookByID(Plugin plug, int hookid)
   1.645 -	{
   1.646 -		const CHookIDManager::Entry *hentry;
   1.647 -
   1.648 -		hentry = m_HookIDMan.QueryHook(hookid);
   1.649 -		if (!hentry)
   1.650 +		//////////////////////////////////////////////////////////////////////////
   1.651 +		// CHookIdManager
   1.652 +		//////////////////////////////////////////////////////////////////////////
   1.653 +		CHookIDManager::CHookIDManager()
   1.654  		{
   1.655 -			// hookid doesn't exist !
   1.656 -			return false;
   1.657  		}
   1.658  
   1.659 -		HookManContList::iterator hmcl_iter = m_HookMans.find(
   1.660 -			CHookManagerContainer::HMCI(hentry->proto.GetProto(), hentry->vtbl_offs, hentry->vtbl_idx));
   1.661 -		if (hmcl_iter == m_HookMans.end() || hmcl_iter->empty())
   1.662 -			return false;
   1.663 -		CHookManagerContainer::iterator hookman = hmcl_iter->begin();
   1.664 -
   1.665 -		// Find vfnptr
   1.666 -		CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.find(hentry->vfnptr);
   1.667 -		if (vfnptr_iter == hookman->m_VfnPtrs.end())
   1.668 -			return false;
   1.669 -
   1.670 -		// Find iface
   1.671 -		CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.find(hentry->adjustediface);
   1.672 -		if (iface_iter == vfnptr_iter->m_Ifaces.end())
   1.673 -			return false;
   1.674 -
   1.675 -		// Find hook
   1.676 -		List<HookInfo> &hooks = hentry->post ? iface_iter->m_PostHooks.m_List : iface_iter->m_PreHooks.m_List;
   1.677 -
   1.678 -		List<HookInfo>::iterator hookiter = hooks.find(hookid);
   1.679 -		if (hookiter == hooks.end())
   1.680 -			return false;
   1.681 -
   1.682 -		hookiter->handler->DeleteThis();
   1.683 +		int CHookIDManager::New(const CProto &proto, int vtbl_offs, int vtbl_idx, void *vfnptr,
   1.684 +			void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
   1.685 +		{
   1.686 +			Entry tmp(proto, vtbl_offs, vtbl_idx, vfnptr, adjustediface, plug, thisptr_offs, handler, post);
   1.687  
   1.688 -		// Move all iterators pointing at this
   1.689 -		List<HookInfo>::iterator oldhookiter = hookiter;
   1.690 -		hookiter = hooks.erase(hookiter);
   1.691 -		List<HookInfo>::iterator newhookiter = hookiter;
   1.692 -		--newhookiter; // The hook loop will ++ it then
   1.693 -		CHookList::CIter *pItIter;
   1.694 -		
   1.695 -		for (pItIter = iface_iter->m_PreHooks.m_UsedIters; pItIter; pItIter = pItIter->m_pNext)
   1.696 -			if (pItIter->m_Iter == oldhookiter)
   1.697 -				pItIter->m_Iter = newhookiter;
   1.698 -
   1.699 -		// If this is VP-Hook-NULL interface, also check all other interfaces of this vfnptr
   1.700 -		if (*iface_iter == NULL)
   1.701 -		{
   1.702 -			for (CVfnPtr::IfaceListIter iface_iter2 = vfnptr_iter->m_Ifaces.begin();
   1.703 -				iface_iter2 != vfnptr_iter->m_Ifaces.end(); ++iface_iter2)
   1.704 +			size_t cursize = m_Entries.size();
   1.705 +			for (size_t i = 0; i < cursize; ++i)
   1.706  			{
   1.707 -				if (*iface_iter2 != NULL)
   1.708 +				if (m_Entries[i].isfree)
   1.709  				{
   1.710 -					for (pItIter = iface_iter2->m_PreHooks.m_UsedIters; pItIter; pItIter = pItIter->m_pNext)
   1.711 -						if (pItIter->m_Iter == oldhookiter)
   1.712 -							pItIter->m_Iter = newhookiter;
   1.713 -				}
   1.714 -			}
   1.715 -		}
   1.716 -
   1.717 -		if (iface_iter->m_PostHooks.m_List.empty() && iface_iter->m_PreHooks.m_List.empty())
   1.718 -		{
   1.719 -			// If this is a VP-Hook-NULL interface, go through all other interfaces of this vfnptr and tell them!
   1.720 -			if (*iface_iter == NULL)
   1.721 -			{
   1.722 -				for (CVfnPtr::IfaceListIter iface_iter2 = vfnptr_iter->m_Ifaces.begin();
   1.723 -					iface_iter2 != vfnptr_iter->m_Ifaces.end(); ++iface_iter2)
   1.724 -				{
   1.725 -					if (iface_iter2->m_Ptr != NULL)
   1.726 -					{
   1.727 -						iface_iter2->m_PreHooks.ClearVPList();
   1.728 -						iface_iter2->m_PostHooks.ClearVPList();
   1.729 -					}
   1.730 +					m_Entries[i] = tmp;
   1.731 +					return static_cast<int>(i) + 1;
   1.732  				}
   1.733  			}
   1.734  
   1.735 +			m_Entries.push_back(tmp);
   1.736 +			return static_cast<int>(m_Entries.size());		// return size() because hookid = id+1 anyway
   1.737 +		}
   1.738  
   1.739 -			// There are no hooks on this iface anymore...
   1.740 -			for (HookLoopInfoStack::iterator hli_iter = m_HLIStack.begin();
   1.741 -				hli_iter != m_HLIStack.end(); ++hli_iter)
   1.742 -			{
   1.743 -				if (hli_iter->pCurIface == static_cast<IIface*>(&(*iface_iter)))
   1.744 -					hli_iter->shouldContinue = false;
   1.745 -			}
   1.746 +		bool CHookIDManager::Remove(int hookid)
   1.747 +		{
   1.748 +			int realid = hookid - 1;
   1.749 +			if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
   1.750 +				return false;
   1.751  
   1.752 -			iface_iter = vfnptr_iter->m_Ifaces.erase(iface_iter);
   1.753 -			if (vfnptr_iter->m_Ifaces.empty())
   1.754 -			{
   1.755 -				// No ifaces at all -> Deactivate the hook
   1.756 +			m_Entries[realid].isfree = true;
   1.757 +
   1.758 +			// :TODO: remove free ids from back sometimes ??
   1.759 +
   1.760 +			return true;
   1.761 +		}
   1.762  
   1.763 -				// Only patch the vfnptr back if the module is still in memory
   1.764 -				// If it's not, do not remove stuff like we did before
   1.765 -				// First off we did it wrong (shutdown the whole hookman, uh..) and secondly applications may be
   1.766 -				// confused by RemoveHook returning false then (yeah, I know, I made this one up, no one checks for RemoveHook error)
   1.767 -				if (ModuleInMemory(reinterpret_cast<char*>(vfnptr_iter->m_Ptr), SH_PTRSIZE))
   1.768 -				{
   1.769 -					*reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = vfnptr_iter->m_OrigEntry;
   1.770 -				}
   1.771 +		const CHookIDManager::Entry * CHookIDManager::QueryHook(int hookid)
   1.772 +		{
   1.773 +			int realid = hookid - 1;
   1.774 +			if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
   1.775 +				return NULL;
   1.776 +
   1.777 +			return &m_Entries[realid];
   1.778 +		}
   1.779  
   1.780 -				hookman->m_VfnPtrs.erase(vfnptr_iter);
   1.781 -
   1.782 -				// Remove callclass patch
   1.783 -				for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   1.784 -					if (cciter->m_Ptr == hentry->adjustediface)
   1.785 -						cciter->RemoveCallClassPatch(hentry->vtbl_offs, hentry->vtbl_idx);
   1.786 -
   1.787 -				if (hookman->m_VfnPtrs.empty())
   1.788 +		void CHookIDManager::FindAllHooks(CVector<int> &output, const CProto &proto, int vtbl_offs,
   1.789 +			int vtbl_idx, void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
   1.790 +		{
   1.791 +			// oh my god, a lot of parameters...
   1.792 +			size_t cursize = m_Entries.size();
   1.793 +			for (size_t i = 0; i < cursize; ++i)
   1.794 +			{
   1.795 +				if (!m_Entries[i].isfree && m_Entries[i].proto == proto && m_Entries[i].vtbl_offs == vtbl_offs &&
   1.796 +					m_Entries[i].vtbl_idx == vtbl_idx && m_Entries[i].adjustediface == adjustediface && m_Entries[i].plug == plug &&
   1.797 +					m_Entries[i].thisptr_offs == thisptr_offs && m_Entries[i].handler->IsEqual(handler) && m_Entries[i].post == post)
   1.798  				{
   1.799 -					// Unregister the hook manager
   1.800 -					hookman->m_Func(HA_Unregister, NULL);
   1.801 +					output.push_back(static_cast<int>(i) + 1);
   1.802  				}
   1.803  			}
   1.804  		}
   1.805  
   1.806 -		// Don't forget to remove the hookid from m_HookIDMan
   1.807 -		m_HookIDMan.Remove(hookid);
   1.808 -
   1.809 -		return true;
   1.810 -	}
   1.811 -
   1.812 -	bool CSourceHookImpl::RemoveHook(RemoveHookInfo info)
   1.813 -	{
   1.814 -		return RemoveHook(info.plug, info.iface, info.thisptr_offs, info.hookman, info.handler, info.post);
   1.815 -	}
   1.816 -
   1.817 -	bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   1.818 -	{
   1.819 -		// Get info about hook manager and compute adjustediface
   1.820 -		CHookManagerInfo tmp;
   1.821 -		if (myHookMan(HA_GetInfo, &tmp) != 0)
   1.822 -			return false;
   1.823 -
   1.824 -		void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
   1.825 +		void CHookIDManager::FindAllHooks(CVector<int> &output)
   1.826 +		{
   1.827 +			size_t cursize = m_Entries.size();
   1.828 +			for (size_t i = 0; i < cursize; ++i)
   1.829 +			{
   1.830 +				if (!m_Entries[i].isfree)
   1.831 +					output.push_back(static_cast<int>(i) + 1);
   1.832 +			}
   1.833 +		}
   1.834  
   1.835 -		// Loop through all hooks and remove those which match:
   1.836 -		//  hookman, vfnptr, iface, plug, adjusted iface, this ptr offs, handler, post
   1.837 -		CVector<int> removehooks;
   1.838 -		m_HookIDMan.FindAllHooks(removehooks, tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx, adjustediface, plug, thisptr_offs, handler, post);
   1.839 -
   1.840 -		if (removehooks.empty())
   1.841 -			return false;
   1.842 -
   1.843 -		bool status = false;
   1.844 -
   1.845 -		for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
   1.846 +		void CHookIDManager::FindAllHooks(CVector<int> &output, Plugin plug)
   1.847  		{
   1.848 -			if (RemoveHookByID(plug, *iter))
   1.849 -				status = true;
   1.850 -		}
   1.851 -		return status; 
   1.852 -	}
   1.853 -
   1.854 -	DeprecatedCallClass<void> *CSourceHookImpl::GetCallClass(void *iface, size_t size)
   1.855 -	{
   1.856 -		for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   1.857 -		{
   1.858 -			if (cciter->m_Ptr == iface && cciter->m_ObjSize == size)
   1.859 +			size_t cursize = m_Entries.size();
   1.860 +			for (size_t i = 0; i < cursize; ++i)
   1.861  			{
   1.862 -				++cciter->m_RefCounter;
   1.863 -				return &(*cciter);
   1.864 +				if (!m_Entries[i].isfree && m_Entries[i].plug == plug)
   1.865 +					output.push_back(static_cast<int>(i) + 1);
   1.866  			}
   1.867  		}
   1.868  
   1.869 -		// Make a new one
   1.870 +
   1.871 +		//////////////////////////////////////////////////////////////////////////
   1.872 +		// CSourceHookImpl
   1.873 +		//////////////////////////////////////////////////////////////////////////
   1.874 +		
   1.875  
   1.876 -		CCallClassImpl tmp(iface, size);
   1.877 -		ApplyCallClassPatches(tmp);
   1.878 -		m_CallClasses.push_back(tmp);
   1.879 -		return &m_CallClasses.back();
   1.880 -	}
   1.881 +		CSourceHookImpl::CSourceHookImpl()
   1.882 +		{
   1.883 +		}
   1.884 +		CSourceHookImpl::~CSourceHookImpl()
   1.885 +		{
   1.886 +		}
   1.887 +
   1.888 +		int CSourceHookImpl::GetIfaceVersion()
   1.889 +		{
   1.890 +			return SH_IFACE_VERSION;
   1.891 +		}
   1.892 +
   1.893 +		int CSourceHookImpl::GetImplVersion()
   1.894 +		{
   1.895 +			return SH_IMPL_VERSION;
   1.896 +		}
   1.897  
   1.898 -	void CSourceHookImpl::ReleaseCallClass(DeprecatedCallClass<void> *ptr)
   1.899 -	{
   1.900 -		Impl_CallClassList::iterator iter = m_CallClasses.find(ptr);
   1.901 -		if (iter == m_CallClasses.end())
   1.902 -			return;
   1.903 -		--iter->m_RefCounter;
   1.904 -		if (iter->m_RefCounter < 1)
   1.905 -			m_CallClasses.erase(iter);
   1.906 -	}
   1.907 +		int CSourceHookImpl::AddHook(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
   1.908 +			ISHDelegate *handler, bool post)
   1.909 +		{
   1.910 +			if (mode != Hook_Normal && mode != Hook_VP && mode != Hook_DVP)
   1.911 +				return 0;
   1.912 +
   1.913 +			// Get info about hook manager
   1.914 +			CHookManager hookManager(plug, myHookMan);
   1.915 +			if (!hookManager)
   1.916 +				return 0;
   1.917 +
   1.918 +			// Make sure that the container exists
   1.919 +			CHookManagerContainer &container = m_HookManContainers.GetContainer(hookManager.GetVtblOffs(),
   1.920 +				hookManager.GetVtblIdx(), hookManager.GetProto());
   1.921 +
   1.922 +			container.AddHookManager(hookManager);
   1.923 +
   1.924 +			if (!container)
   1.925 +			{
   1.926 +				// For some weird reason, the container is empty!
   1.927 +				SH_ASSERT(0, ("No hookman found - but we've just added one!"));
   1.928 +				return 0;
   1.929 +			}
   1.930 +
   1.931 +			CHookManager &hookMan = container.GetActiveHookManager();
   1.932  
   1.933 -	void CSourceHookImpl::ApplyCallClassPatches(CCallClassImpl &cc)
   1.934 -	{
   1.935 -		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
   1.936 -			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
   1.937 -		{
   1.938 -			for (CHookManagerContainer::iterator hookman = hmcl_iter->begin();
   1.939 -				hookman != hmcl_iter->end(); ++hookman)
   1.940 +			void *adjustediface = NULL;
   1.941 +			void **cur_vtptr = NULL;
   1.942 +			void *cur_vfnptr = NULL;
   1.943 +
   1.944 +			// find vfnptr
   1.945 +			switch (mode)
   1.946  			{
   1.947 -				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.begin();
   1.948 -					vfnptr_iter != hookman->m_VfnPtrs.end(); ++vfnptr_iter)
   1.949 -				{
   1.950 -					for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
   1.951 -						iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
   1.952 -					{
   1.953 -						if (iface_iter->m_Ptr >= cc.m_Ptr &&
   1.954 -							iface_iter->m_Ptr < (reinterpret_cast<char*>(cc.m_Ptr) + cc.m_ObjSize))
   1.955 -						{
   1.956 -							cc.ApplyCallClassPatch(static_cast<int>(reinterpret_cast<char*>(iface_iter->m_Ptr) -
   1.957 -								reinterpret_cast<char*>(cc.m_Ptr)) + hookman->m_VtblOffs,
   1.958 -								hookman->m_VtblIdx, vfnptr_iter->m_OrigEntry);
   1.959 -						}
   1.960 -					}
   1.961 -				}
   1.962 +			case Hook_Normal:
   1.963 +				adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
   1.964 +
   1.965 +				cur_vtptr = *reinterpret_cast<void***>(
   1.966 +					reinterpret_cast<char*>(adjustediface) + hookMan.GetVtblOffs());
   1.967 +				cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + hookMan.GetVtblIdx());
   1.968 +				break;
   1.969 +
   1.970 +			case Hook_VP:
   1.971 +
   1.972 +				adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
   1.973 +
   1.974 +				cur_vtptr = *reinterpret_cast<void***>(
   1.975 +					reinterpret_cast<char*>(adjustediface) + hookMan.GetVtblOffs());
   1.976 +				cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + hookMan.GetVtblIdx());
   1.977 +
   1.978 +				adjustediface = NULL;
   1.979 +				break;
   1.980 +
   1.981 +			case Hook_DVP:
   1.982 +				adjustediface = NULL;
   1.983 +
   1.984 +				cur_vtptr = reinterpret_cast<void**>(iface);
   1.985 +				cur_vfnptr = cur_vtptr + hookMan.GetVtblIdx();
   1.986 +
   1.987 +				break;
   1.988  			}
   1.989 +
   1.990 +			CVfnPtr &vfnPtr = hookMan.GetVfnPtr(cur_vfnptr);
   1.991 +			CIface &ifaceinst = vfnPtr.GetIface(adjustediface);
   1.992 +
   1.993 +			// Add the hook
   1.994 +			CHook hook(plug, thisptr_offs, handler, 
   1.995 +
   1.996 +				m_HookIDMan.New(hookMan.GetProto(), hookMan.GetVtblOffs(), hookMan.GetVtblIdx(),
   1.997 +					cur_vfnptr, adjustediface, plug, thisptr_offs, handler, post)
   1.998 +
   1.999 +				);
  1.1000 +
  1.1001 +			if (post)
  1.1002 +				ifaceinst.GetPostHookList().push_back(hook);
  1.1003 +			else
  1.1004 +				ifaceinst.GetPreHookList().push_back(hook);
  1.1005 +
  1.1006 +			return hook.GetID();
  1.1007  		}
  1.1008 -	}
  1.1009  
  1.1010 -	void CSourceHookImpl::ApplyCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx, void *orig_entry)
  1.1011 -	{
  1.1012 -		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
  1.1013 -			++cc_iter)
  1.1014 +		bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
  1.1015 +			ISHDelegate *handler, bool post)
  1.1016  		{
  1.1017 -			if (ifaceptr >= cc_iter->m_Ptr &&
  1.1018 -				ifaceptr < (reinterpret_cast<char*>(cc_iter->m_Ptr) + cc_iter->m_ObjSize))
  1.1019 +			// Get info about hook manager and compute adjustediface
  1.1020 +			CHookManager tmpHookMan(plug, myHookMan);
  1.1021 +
  1.1022 +			void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
  1.1023 +
  1.1024 +			// Loop through all hooks and remove those which match:
  1.1025 +			//  hookman, vfnptr, iface, plug, adjusted iface, this ptr offs, handler, post
  1.1026 +			CVector<int> removehooks;
  1.1027 +			m_HookIDMan.FindAllHooks(removehooks, tmpHookMan.GetProto(), tmpHookMan.GetVtblOffs(), tmpHookMan.GetVtblIdx(),
  1.1028 +				adjustediface, plug, thisptr_offs, handler, post);
  1.1029 +
  1.1030 +			if (removehooks.empty())
  1.1031 +				return false;
  1.1032 +
  1.1033 +			bool status = false;
  1.1034 +
  1.1035 +			for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
  1.1036  			{
  1.1037 -				cc_iter->ApplyCallClassPatch(static_cast<int>(reinterpret_cast<char*>(ifaceptr) -
  1.1038 -					reinterpret_cast<char*>(cc_iter->m_Ptr)) + vtbl_offs, vtbl_idx, orig_entry);
  1.1039 +				if (RemoveHookByID(*iter))
  1.1040 +					status = true;
  1.1041  			}
  1.1042 -		}
  1.1043 -	}
  1.1044 -
  1.1045 -	void CSourceHookImpl::RemoveCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx)
  1.1046 -	{
  1.1047 -		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
  1.1048 -			++cc_iter)
  1.1049 -		{
  1.1050 -			if (ifaceptr >= cc_iter->m_Ptr &&
  1.1051 -				ifaceptr < (reinterpret_cast<char*>(cc_iter->m_Ptr) + cc_iter->m_ObjSize))
  1.1052 -			{
  1.1053 -				cc_iter->RemoveCallClassPatch(vtbl_offs, vtbl_idx);
  1.1054 -			}
  1.1055 +			return status; 
  1.1056  		}
  1.1057 -	}
  1.1058  
  1.1059 -	void CSourceHookImpl::SetPluginPaused(Plugin plug, bool paused)
  1.1060 -	{
  1.1061 -		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
  1.1062 -		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
  1.1063 -			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
  1.1064 +		bool CSourceHookImpl::RemoveHookByID(int hookid)
  1.1065  		{
  1.1066 -			for (CHookManagerContainer::iterator hookmaniter = hmcl_iter->begin();
  1.1067 -				hookmaniter != hmcl_iter->end(); ++hookmaniter)
  1.1068 +			const CHookIDManager::Entry *hentry;
  1.1069 +
  1.1070 +			hentry = m_HookIDMan.QueryHook(hookid);
  1.1071 +			if (!hentry)
  1.1072  			{
  1.1073 -				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->m_VfnPtrs.begin();
  1.1074 -					vfnptr_iter != hookmaniter->m_VfnPtrs.end(); ++vfnptr_iter)
  1.1075 +				// hookid doesn't exist !
  1.1076 +				return false;
  1.1077 +			}
  1.1078 +
  1.1079 +			// find hookman
  1.1080 +			CHookManContainerList::iterator hmcl_iter = m_HookManContainers.find(
  1.1081 +				CHookManagerContainer::Descriptor(hentry->vtbl_offs, hentry->vtbl_idx, hentry->proto));
  1.1082 +
  1.1083 +			if (hmcl_iter == m_HookManContainers.end() || !(*hmcl_iter))
  1.1084 +				return false;
  1.1085 +
  1.1086 +			CHookManager &hookman = hmcl_iter->GetActiveHookManager();
  1.1087 +
  1.1088 +			// find vfnptr
  1.1089 +			List<CVfnPtr>::iterator vfnptr_iter = hookman.GetVfnPtrList().find(hentry->vfnptr);
  1.1090 +			if (vfnptr_iter == hookman.GetVfnPtrList().end())
  1.1091 +				return false;
  1.1092 +
  1.1093 +			// find iface
  1.1094 +			List<CIface>::iterator iface_iter = vfnptr_iter->GetIfaceList().find(hentry->adjustediface);
  1.1095 +			if (iface_iter == vfnptr_iter->GetIfaceList().end())
  1.1096 +				return false;
  1.1097 +
  1.1098 +			// find hook
  1.1099 +			List<CHook> &hooks = hentry->post ? iface_iter->GetPostHookList() : iface_iter->GetPreHookList();
  1.1100 +			List<CHook>::iterator hook_iter = hooks.find(hookid);
  1.1101 +			if (hook_iter == hooks.end())
  1.1102 +				return false;
  1.1103 +
  1.1104 +			hook_iter->GetHandler()->DeleteThis();
  1.1105 +
  1.1106 +			// Iterator movage!
  1.1107 +			List<CHook>::iterator oldhookiter = hook_iter;
  1.1108 +			hook_iter = hooks.erase(hook_iter);
  1.1109 +
  1.1110 +			for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
  1.1111 +				ctx_iter != m_ContextStack.end(); ++ctx_iter)
  1.1112 +			{
  1.1113 +				ctx_iter->HookRemoved(oldhookiter, hook_iter);
  1.1114 +			}
  1.1115 +
  1.1116 +			if (iface_iter->GetPreHookList().empty() && iface_iter->GetPostHookList().empty())
  1.1117 +			{
  1.1118 +				// -> Kill all contexts that use it!
  1.1119 +				for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
  1.1120 +					ctx_iter != m_ContextStack.end(); ++ctx_iter)
  1.1121  				{
  1.1122 -					for (CVfnPtr::IfaceListIter ifaceiter = vfnptr_iter->m_Ifaces.begin();
  1.1123 -						ifaceiter != vfnptr_iter->m_Ifaces.end(); ++ifaceiter)
  1.1124 +					ctx_iter->IfaceRemoved(&(*iface_iter));
  1.1125 +				}
  1.1126 +
  1.1127 +				// There are no hooks on this iface anymore...
  1.1128 +				iface_iter = vfnptr_iter->GetIfaceList().erase(iface_iter);
  1.1129 +
  1.1130 +				if (vfnptr_iter->GetIfaceList().empty())
  1.1131 +				{
  1.1132 +					// No ifaces at all -> Deactivate the hook
  1.1133 +
  1.1134 +					for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
  1.1135 +						ctx_iter != m_ContextStack.end(); ++ctx_iter)
  1.1136  					{
  1.1137 -						for (List<HookInfo>::iterator hookiter = ifaceiter->m_PreHooks.m_List.begin();
  1.1138 -							hookiter != ifaceiter->m_PreHooks.m_List.end(); ++hookiter)
  1.1139 -							if (plug == hookiter->plug)
  1.1140 -								hookiter->paused = paused;
  1.1141 +						ctx_iter->VfnPtrRemoved(&(*vfnptr_iter));
  1.1142 +					}
  1.1143  
  1.1144 -						for (List<HookInfo>::iterator hookiter = ifaceiter->m_PostHooks.m_List.begin();
  1.1145 -							hookiter != ifaceiter->m_PostHooks.m_List.end(); ++hookiter)
  1.1146 -							if (plug == hookiter->plug)
  1.1147 -								hookiter->paused = paused;
  1.1148 +					// Only patch the vfnptr back if the module is still in memory
  1.1149 +					// If it's not, do not remove stuff like we did before
  1.1150 +					// First off we did it wrong (shutdown the whole hookman, uh..) and secondly applications may be
  1.1151 +					// confused by RemoveHook returning false then (yeah, I know, I made this one up, no one checks for RemoveHook error)
  1.1152 +					if (ModuleInMemory(reinterpret_cast<char*>(vfnptr_iter->GetPtr()), SH_PTRSIZE))
  1.1153 +					{
  1.1154 +						vfnptr_iter->Revert();
  1.1155 +					}
  1.1156 +
  1.1157 +					hookman.GetVfnPtrList().erase(vfnptr_iter);
  1.1158 +
  1.1159 +					if (hookman.GetVfnPtrList().empty())
  1.1160 +					{
  1.1161 +						// Unregister the hook manager
  1.1162 +						hookman.Unregister();
  1.1163  					}
  1.1164  				}
  1.1165  			}
  1.1166 +
  1.1167 +			m_HookIDMan.Remove(hookid);
  1.1168 +			return true;
  1.1169  		}
  1.1170 -	}
  1.1171 -	void CSourceHookImpl::PausePlugin(Plugin plug)
  1.1172 -	{
  1.1173 -		SetPluginPaused(plug, true);
  1.1174 -	}
  1.1175 -
  1.1176 -	void CSourceHookImpl::UnpausePlugin(Plugin plug)
  1.1177 -	{
  1.1178 -		SetPluginPaused(plug, false);
  1.1179 -	}
  1.1180 -
  1.1181 -	void CSourceHookImpl::HookLoopBegin(IIface *pIface)
  1.1182 -	{
  1.1183 -		HookLoopInfo hli = {0};
  1.1184 -		hli.pCurIface = pIface;
  1.1185 -		hli.shouldContinue = true;
  1.1186 -		hli.recall = HookLoopInfo::Recall_No;
  1.1187  
  1.1188 -		static_cast<CIface*>(pIface)->m_PreHooks.RQFlagReset();
  1.1189 -		static_cast<CIface*>(pIface)->m_PostHooks.RQFlagReset();
  1.1190 -
  1.1191 -		m_HLIStack.push(hli);
  1.1192 -	}
  1.1193 -
  1.1194 -	void CSourceHookImpl::HookLoopEnd()
  1.1195 -	{
  1.1196 -		// When in a post recall... make sure status is high enough so that it returns the orig ret.
  1.1197 -		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
  1.1198 -			*m_HLIStack.front().pStatus = MRES_SUPERCEDE;			// THAT'LL TEACH THEM!
  1.1199 -		m_HLIStack.pop();
  1.1200 -	}
  1.1201 -
  1.1202 -	void CSourceHookImpl::SetRes(META_RES res)
  1.1203 -	{
  1.1204 -		*m_HLIStack.front().pCurRes = res;
  1.1205 -	}
  1.1206 -
  1.1207 -	META_RES CSourceHookImpl::GetPrevRes()
  1.1208 -	{
  1.1209 -		return *m_HLIStack.front().pPrevRes;
  1.1210 -	}
  1.1211 +		void CSourceHookImpl::SetRes(META_RES res)
  1.1212 +		{
  1.1213 +			*m_ContextStack.front().pCurRes = res;
  1.1214 +		}
  1.1215  
  1.1216 -	META_RES CSourceHookImpl::GetStatus()
  1.1217 -	{
  1.1218 -		return *m_HLIStack.front().pStatus;
  1.1219 -	}
  1.1220 -
  1.1221 -	const void *CSourceHookImpl::GetOrigRet()
  1.1222 -	{
  1.1223 -		// When in a post recall... return the orig ret of the previous hookloop.
  1.1224 -		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
  1.1225 -			return m_HLIStack.second().pOrigRet;
  1.1226 -
  1.1227 -		return m_HLIStack.front().pOrigRet;
  1.1228 -	}
  1.1229 -
  1.1230 -	const void *CSourceHookImpl::GetOverrideRet()
  1.1231 -	{
  1.1232 -		// pOverrideRet is always set since recalls were introduced
  1.1233 -		// GetOverrideRetPtr was added; a function which always returns pOverrideRet
  1.1234 -		// so that RETURN_META_VALUE_NEWPARAMS can provide an override result
  1.1235 +		META_RES CSourceHookImpl::GetPrevRes()
  1.1236 +		{
  1.1237 +			return *m_ContextStack.front().pPrevRes;
  1.1238 +		}
  1.1239  
  1.1240 -		// This means that we have to filter GetOverrideRet:
  1.1241 -		//  If the status variable is < MRES_OVERRIDE, return NULL.
  1.1242 -
  1.1243 -		return (*m_HLIStack.front().pStatus < MRES_OVERRIDE) ?
  1.1244 -			NULL : m_HLIStack.front().pOverrideRet;
  1.1245 -	}
  1.1246 +		META_RES CSourceHookImpl::GetStatus()
  1.1247 +		{
  1.1248 +			return *m_ContextStack.front().pStatus;
  1.1249  
  1.1250 -	void *CSourceHookImpl::GetOverrideRetPtr()
  1.1251 -	{
  1.1252 -		// As described in the comment above: always return pOverrideRet
  1.1253 -		return m_HLIStack.front().pOverrideRet;
  1.1254 -	}
  1.1255 -
  1.1256 -	void *CSourceHookImpl::GetIfacePtr()
  1.1257 -	{
  1.1258 -		return *m_HLIStack.front().pIfacePtrPtr;
  1.1259 -	}
  1.1260 -
  1.1261 -	void CSourceHookImpl::SetCurResPtr(META_RES *mres)
  1.1262 -	{
  1.1263 -		m_HLIStack.front().pCurRes = mres;
  1.1264 -	}
  1.1265 +		}
  1.1266  
  1.1267 -	void CSourceHookImpl::SetPrevResPtr(META_RES *mres)
  1.1268 -	{
  1.1269 -		m_HLIStack.front().pPrevRes = mres;
  1.1270 -
  1.1271 -		// If we're recalling, drag the previous mres value to the new hookfunc
  1.1272 -		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
  1.1273 -			*mres = *m_HLIStack.second().pPrevRes;
  1.1274 -	}
  1.1275 -
  1.1276 -	void CSourceHookImpl::SetStatusPtr(META_RES *mres)
  1.1277 -	{
  1.1278 -		m_HLIStack.front().pStatus = mres;
  1.1279 -
  1.1280 -		// If we're recalling, drag the previous mres value to the new hookfunc
  1.1281 -		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
  1.1282 -			*mres = *m_HLIStack.second().pStatus;
  1.1283 -	}
  1.1284 +		const void *CSourceHookImpl::GetOrigRet()
  1.1285 +		{
  1.1286 +			return m_ContextStack.front().pOrigRet;
  1.1287 +		}
  1.1288  
  1.1289 -	void CSourceHookImpl::SetIfacePtrPtr(void **pp)
  1.1290 -	{
  1.1291 -		m_HLIStack.front().pIfacePtrPtr = pp;
  1.1292 -	}
  1.1293 -
  1.1294 -	void CSourceHookImpl::SetOrigRetPtr(const void *ptr)
  1.1295 -	{
  1.1296 -		m_HLIStack.front().pOrigRet = ptr;
  1.1297 -	}
  1.1298 -	void CSourceHookImpl::SetOverrideRetPtr(void *ptr)
  1.1299 -	{
  1.1300 -		m_HLIStack.front().pOverrideRet = ptr;
  1.1301 -	}
  1.1302 -
  1.1303 -	// New function which does all of the above + more :)
  1.1304 -	void *CSourceHookImpl::SetupHookLoop(META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr,
  1.1305 -		void **ifacePtrPtr, const void *origRetPtr, void *overrideRetPtr)
  1.1306 -	{
  1.1307 -		HookLoopInfo &hli = m_HLIStack.front();
  1.1308 -		hli.pStatus = statusPtr;
  1.1309 -		hli.pPrevRes = prevResPtr;
  1.1310 -		hli.pCurRes = curResPtr;
  1.1311 -		hli.pIfacePtrPtr = ifacePtrPtr;
  1.1312 -		hli.pOrigRet = origRetPtr;
  1.1313 +		const void *CSourceHookImpl::GetOverrideRet()
  1.1314 +		{
  1.1315 +			return (*m_ContextStack.front().pStatus < MRES_OVERRIDE) ?
  1.1316 +				NULL : m_ContextStack.front().pOverrideRet;
  1.1317 +		}
  1.1318  
  1.1319 -		// Handle some recall stuff
  1.1320 -		if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
  1.1321 +		void *CSourceHookImpl::GetIfacePtr()
  1.1322  		{
  1.1323 -			HookLoopInfo &other = m_HLIStack.second();
  1.1324 -			*statusPtr = *other.pStatus;
  1.1325 -			*prevResPtr = *other.pStatus;
  1.1326 -
  1.1327 -			// When the status is low so there's no override return value and we're in a post recall,
  1.1328 -			// give it the orig return value as override return value.
  1.1329 -			if (*statusPtr < MRES_OVERRIDE && other.recall == HookLoopInfo::Recall_Post1)
  1.1330 -				hli.pOverrideRet = const_cast<void*>(other.pOrigRet);
  1.1331 -			else	// Otherwise, transfer override ret normally
  1.1332 -				hli.pOverrideRet = other.pOverrideRet;
  1.1333 -		}
  1.1334 -		else
  1.1335 -			hli.pOverrideRet = overrideRetPtr;
  1.1336 -
  1.1337 -		// Tell the hook func which override ret ptr to use
  1.1338 -		return hli.pOverrideRet;
  1.1339 -	}
  1.1340 -
  1.1341 -	bool CSourceHookImpl::ShouldContinue()
  1.1342 -	{
  1.1343 -		// If recall is true, we shall not continue either.
  1.1344 -		// This is because, if it's true and ShouldContinue is called, it suggests that the
  1.1345 -		// actual recall is done and that we are back in the original handler which shall return
  1.1346 -		// immediately.
  1.1347 -
  1.1348 -		// Post-recalls:
  1.1349 -		//  The second element on the stack has recall set to Recall_Post1.
  1.1350 -		//  This means that we want to skip this part and the original function calling thing, so
  1.1351 -		//  we store the status mres value, set status to MRES_SUPERCEDE, and return false.
  1.1352 -		//  We also set the recall flag to Recall_Post2, so the next time the thing calls us, we
  1.1353 -		//  can return true (so that the thing goes into post hooks).
  1.1354 -		if (m_HLIStack.size() > 1)
  1.1355 -		{
  1.1356 -			if (m_HLIStack.second().recall == HookLoopInfo::Recall_Post1)
  1.1357 +			// If in recall: return last one
  1.1358 +			if (m_ContextStack.front().m_State >= CHookContext::State_Recall_Pre &&
  1.1359 +				m_ContextStack.front().m_State <= CHookContext::State_Recall_PostVP)
  1.1360  			{
  1.1361 -				m_HLIStack.front().temporaryStatus = *m_HLIStack.front().pStatus;
  1.1362 -				*m_HLIStack.front().pStatus = MRES_SUPERCEDE;
  1.1363 -				m_HLIStack.second().recall = HookLoopInfo::Recall_Post2;
  1.1364 -				return false;
  1.1365 +				return m_ContextStack.second().pIfacePtr;
  1.1366  			}
  1.1367 -			else if (m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
  1.1368 +			else
  1.1369  			{
  1.1370 -				*m_HLIStack.front().pStatus = m_HLIStack.front().temporaryStatus;
  1.1371 -				return m_HLIStack.front().shouldContinue;
  1.1372 +				return m_ContextStack.front().pIfacePtr;
  1.1373  			}
  1.1374  		}
  1.1375 -		return m_HLIStack.front().shouldContinue && !m_HLIStack.front().recall;
  1.1376 -	}
  1.1377 +
  1.1378 +		void *CSourceHookImpl::GetOverrideRetPtr()
  1.1379 +		{
  1.1380 +			return m_ContextStack.front().pOverrideRet;
  1.1381 +		}
  1.1382 +
  1.1383 +		void CSourceHookImpl::UnloadPlugin(Plugin plug)
  1.1384 +		{
  1.1385 +			// 1) Remove all hooks by this plugin
  1.1386  
  1.1387 -	void CSourceHookImpl::DoRecall()
  1.1388 -	{
  1.1389 -		if (!m_HLIStack.empty())
  1.1390 +			CVector<int> removehooks;
  1.1391 +			m_HookIDMan.FindAllHooks(removehooks, plug);
  1.1392 +
  1.1393 +			for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
  1.1394 +				RemoveHookByID(*iter);
  1.1395 +
  1.1396 +			// 2) Remove all hook managers
  1.1397 +			m_HookManContainers.RemoveHookMans(plug);
  1.1398 +		}
  1.1399 +
  1.1400 +		void CSourceHookImpl::RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc)
  1.1401  		{
  1.1402 -			// Also watch out for post recalls! Described at the beginning of sourcehook_impl.h
  1.1403 -			m_HLIStack.front().recall =
  1.1404 -				static_cast<CIface*>(m_HLIStack.front().pCurIface)->m_PostHooks.RQFlagGet() ?
  1.1405 -				HookLoopInfo::Recall_Post1 : HookLoopInfo::Recall_Pre;
  1.1406 -			
  1.1407 -			CHookList *mlist = static_cast<CHookList*>(m_HLIStack.front().recall == HookLoopInfo::Recall_Pre ? 
  1.1408 -				m_HLIStack.front().pCurIface->GetPreHooks() : m_HLIStack.front().pCurIface->GetPostHooks());
  1.1409 -			mlist->m_Recall = true;
  1.1410 +			// 1) Remove all its hooks
  1.1411 +			CVector<int> removehooks;
  1.1412 +
  1.1413 +			// Get info about hook manager
  1.1414 +			CHookManager hookManager(plug, pubFunc);
  1.1415 +			if (!hookManager)
  1.1416 +				return;
  1.1417 +
  1.1418 +			// Make sure that the container exists
  1.1419 +			CHookManagerContainer &container = m_HookManContainers.GetContainer(hookManager.GetVtblOffs(),
  1.1420 +				hookManager.GetVtblIdx(), hookManager.GetProto());
  1.1421 +
  1.1422 +			CHookManagerContainer::iterator cont_iter = container.find(CHookManager::Descriptor(plug, pubFunc));
  1.1423 +
  1.1424 +			for (List<CVfnPtr>::iterator vfnptr_iter = cont_iter->GetVfnPtrList().begin();
  1.1425 +				vfnptr_iter != cont_iter->GetVfnPtrList().end(); ++vfnptr_iter)
  1.1426 +			{
  1.1427 +				for (List<CIface>::iterator iface_iter = vfnptr_iter->GetIfaceList().begin();
  1.1428 +					iface_iter != vfnptr_iter->GetIfaceList().end(); ++iface_iter)
  1.1429 +				{
  1.1430 +					List<CHook>::iterator hook_iter;
  1.1431 +					for (hook_iter = iface_iter->GetPreHookList().begin();
  1.1432 +						hook_iter != iface_iter->GetPreHookList().end(); ++hook_iter)
  1.1433 +						removehooks.push_back(hook_iter->GetID());
  1.1434 +
  1.1435 +					for (hook_iter = iface_iter->GetPostHookList().begin();
  1.1436 +						hook_iter != iface_iter->GetPostHookList().end(); ++hook_iter)
  1.1437 +						removehooks.push_back(hook_iter->GetID());
  1.1438 +				}
  1.1439 +			}
  1.1440 +
  1.1441 +			for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
  1.1442 +				RemoveHookByID(*iter);
  1.1443 +
  1.1444 +			// 2) Remove it
  1.1445 +			container.RemoveHookMans(plug, pubFunc);
  1.1446 +		}
  1.1447 +
  1.1448 +		void CSourceHookImpl::SetIgnoreHooks(void *vfnptr)
  1.1449 +		{
  1.1450 +			CHookContext ctx;
  1.1451 +			ctx.m_State = CHookContext::State_Ignore;
  1.1452 +			m_ContextStack.push(ctx);
  1.1453 +		}
  1.1454 +
  1.1455 +		void CSourceHookImpl::ResetIgnoreHooks(void *vfnptr)
  1.1456 +		{
  1.1457 +			if (!m_ContextStack.empty() && m_ContextStack.front().m_State == CHookContext::State_Ignore)
  1.1458 +				m_ContextStack.pop();
  1.1459 +		}
  1.1460 +
  1.1461 +		void CSourceHookImpl::DoRecall()
  1.1462 +		{
  1.1463 +			CHookContext newCtx;
  1.1464 +			CHookContext &curCtx = m_ContextStack.front();
  1.1465 +
  1.1466 +
  1.1467 +			newCtx.m_State = curCtx.m_State + (CHookContext::State_Recall_Pre - CHookContext::State_Pre);
  1.1468 +			if (newCtx.m_State == CHookContext::State_Recall_Post || newCtx.m_State == CHookContext::State_Recall_PostVP)
  1.1469 +			{
  1.1470 +				// Also save orig ret
  1.1471 +				newCtx.pOrigRet = curCtx.pOrigRet;
  1.1472 +			}
  1.1473  
  1.1474  			// The hookfunc usually does this, but it won't have a chance to see it, 
  1.1475  			// so for recalls, we update status here if it's required
  1.1476 -			if (*m_HLIStack.front().pCurRes > *m_HLIStack.front().pStatus) 
  1.1477 -				*m_HLIStack.front().pStatus = *m_HLIStack.front().pCurRes;
  1.1478 +			if (*curCtx.pCurRes > *curCtx.pStatus) 
  1.1479 +				*curCtx.pStatus = *curCtx.pCurRes;
  1.1480  
  1.1481 +			newCtx.pStatus = curCtx.pStatus;
  1.1482 +			newCtx.pOverrideRet = curCtx.pOverrideRet;
  1.1483 +			newCtx.pPrevRes = curCtx.pPrevRes;
  1.1484 +			newCtx.m_Iter = curCtx.m_Iter;
  1.1485 +
  1.1486 +			// Take this with us!
  1.1487 +			newCtx.pCurRes = curCtx.pCurRes;
  1.1488 +
  1.1489 +			m_ContextStack.push(newCtx);
  1.1490 +			curCtx.m_State = CHookContext::State_Dead;
  1.1491  		}
  1.1492 -	}
  1.1493 +
  1.1494 +		IHookContext *CSourceHookImpl::SetupHookLoop(IHookManagerInfo *hi, void *vfnptr, void *thisptr, void **origentry, META_RES *statusPtr,
  1.1495 +			META_RES *prevResPtr, META_RES *curResPtr, const void *origRetPtr, void *overrideRetPtr)
  1.1496 +		{
  1.1497 +			CHookContext *pCtx = NULL;
  1.1498 +			CHookContext *oldctx = m_ContextStack.empty() ? NULL : &m_ContextStack.front();
  1.1499 +			if (oldctx)
  1.1500 +			{
  1.1501 +				// SH_CALL
  1.1502 +				if (oldctx->m_State == CHookContext::State_Ignore)
  1.1503 +				{
  1.1504 +					*statusPtr = MRES_IGNORED;
  1.1505 +					oldctx->m_State = CHookContext::State_Dead;
  1.1506 +
  1.1507 +					List<CVfnPtr> &vfnptrList = static_cast<CHookManager*>(hi)->GetVfnPtrList();
  1.1508 +					List<CVfnPtr>::iterator vfnptr_iter = vfnptrList.find(vfnptr);
  1.1509 +					if (vfnptr_iter == vfnptrList.end())
  1.1510 +					{
  1.1511 +						// :TODO: what??
  1.1512 +					}
  1.1513 +					else
  1.1514 +					{
  1.1515 +						*origentry = vfnptr_iter->GetOrigEntry();
  1.1516 +					}
  1.1517 +
  1.1518 +					oldctx->pOrigRet = origRetPtr;
  1.1519 +					return oldctx;
  1.1520 +				}
  1.1521 +				// Recall
  1.1522 +				else if (oldctx->m_State >= CHookContext::State_Recall_Pre &&
  1.1523 +					oldctx->m_State <= CHookContext::State_Recall_PostVP)
  1.1524 +				{
  1.1525 +					pCtx = oldctx;
  1.1526 +
  1.1527 +					*statusPtr = *(oldctx->pStatus);
  1.1528 +					*prevResPtr = *(oldctx->pPrevRes);
  1.1529 +
  1.1530 +					pCtx->m_Iter = oldctx->m_Iter;
  1.1531 +
  1.1532 +					// Only have possibility of calling the orig func in pre recall mode
  1.1533 +					pCtx->m_CallOrig = (oldctx->m_State == CHookContext::State_Recall_Pre || 
  1.1534 +						oldctx->m_State == CHookContext::State_Recall_PreVP);
  1.1535 +
  1.1536 +					overrideRetPtr = pCtx->pOverrideRet;
  1.1537 +
  1.1538 +					// When the status is low so there's no override return value and we're in a post recall,
  1.1539 +					// give it the orig return value as override return value.
  1.1540 +					if (pCtx->m_State == CHookContext::State_Recall_Post ||
  1.1541 +						pCtx->m_State == CHookContext::State_Recall_PostVP)
  1.1542 +					{
  1.1543 +						origRetPtr = oldctx->pOrigRet;
  1.1544 +						if (*statusPtr < MRES_OVERRIDE)
  1.1545 +							overrideRetPtr = const_cast<void*>(pCtx->pOrigRet);
  1.1546 +					}
  1.1547 +				}
  1.1548 +			}
  1.1549 +			if (!pCtx)
  1.1550 +			{
  1.1551 +				pCtx = m_ContextStack.make_next();
  1.1552 +				pCtx->m_State = CHookContext::State_Born;
  1.1553 +				pCtx->m_CallOrig = true;
  1.1554 +			}
  1.1555 +
  1.1556 +			pCtx->pIface = NULL;
  1.1557  
  1.1558 -	void CSourceHookImpl::SetIgnoreHooks(Plugin plug, void *vfnptr)
  1.1559 -	{
  1.1560 -		m_OneIgnore = vfnptr;
  1.1561 -	}
  1.1562 +			List<CVfnPtr> &vfnptrList = static_cast<CHookManager*>(hi)->GetVfnPtrList();
  1.1563 +			List<CVfnPtr>::iterator vfnptr_iter = vfnptrList.find(vfnptr);
  1.1564 +			if (vfnptr_iter == vfnptrList.end())
  1.1565 +			{
  1.1566 +				pCtx->m_State = CHookContext::State_Dead;
  1.1567 +			}
  1.1568 +			else
  1.1569 +			{
  1.1570 +				pCtx->pVfnPtr = &(*vfnptr_iter);
  1.1571 +				*origentry = vfnptr_iter->GetOrigEntry();
  1.1572 +				pCtx->pIface = vfnptr_iter->FindIface(thisptr);
  1.1573 +			}
  1.1574 +
  1.1575 +			pCtx->pStatus = statusPtr;
  1.1576 +			pCtx->pPrevRes = prevResPtr;
  1.1577 +			pCtx->pCurRes = curResPtr;
  1.1578 +			pCtx->pThisPtr = thisptr;
  1.1579 +			pCtx->pOverrideRet = overrideRetPtr;
  1.1580 +			pCtx->pOrigRet = origRetPtr;
  1.1581 +
  1.1582 +			return pCtx;
  1.1583 +		}
  1.1584 +
  1.1585 +		void CSourceHookImpl::EndContext(IHookContext *pCtx)
  1.1586 +		{
  1.1587 +			m_ContextStack.pop();
  1.1588 +		}
  1.1589 +
  1.1590 +		void CSourceHookImpl::CompleteShutdown()
  1.1591 +		{
  1.1592 +			CVector<int> removehooks;
  1.1593 +			m_HookIDMan.FindAllHooks(removehooks);
  1.1594 +
  1.1595 +			for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
  1.1596 +				RemoveHookByID(*iter);
  1.1597 +		}
  1.1598 +
  1.1599 +		void CSourceHookImpl::PausePlugin(Plugin plug)
  1.1600 +		{
  1.1601 +			CVector<int> pausehooks;
  1.1602 +			m_HookIDMan.FindAllHooks(pausehooks, plug);
  1.1603 +
  1.1604 +			for (CVector<int>::iterator iter = pausehooks.begin(); iter != pausehooks.end(); ++iter)
  1.1605 +				PauseHookByID(*iter);
  1.1606 +		}
  1.1607 +
  1.1608 +		void CSourceHookImpl::UnpausePlugin(Plugin plug)
  1.1609 +		{
  1.1610 +			CVector<int> unpausehooks;
  1.1611 +			m_HookIDMan.FindAllHooks(unpausehooks, plug);
  1.1612 +
  1.1613 +			for (CVector<int>::iterator iter = unpausehooks.begin(); iter != unpausehooks.end(); ++iter)
  1.1614 +				UnpauseHookByID(*iter);
  1.1615 +		}
  1.1616 +
  1.1617 +		bool CSourceHookImpl::PauseHookByID(int hookid)
  1.1618 +		{
  1.1619 +			return SetHookPaused(hookid, true);
  1.1620 +		}
  1.1621 +
  1.1622 +		bool CSourceHookImpl::UnpauseHookByID(int hookid)
  1.1623 +		{
  1.1624 +			return SetHookPaused(hookid, false);
  1.1625 +		}
  1.1626 +
  1.1627 +		bool CSourceHookImpl::SetHookPaused(int hookid, bool paused)
  1.1628 +		{
  1.1629 +			const CHookIDManager::Entry *hentry;
  1.1630 +
  1.1631 +			hentry = m_HookIDMan.QueryHook(hookid);
  1.1632 +			if (!hentry)
  1.1633 +			{
  1.1634 +				// hookid doesn't exist !
  1.1635 +				return false;
  1.1636 +			}
  1.1637 +
  1.1638 +			// find hookman
  1.1639 +			CHookManContainerList::iterator hmcl_iter = m_HookManContainers.find(
  1.1640 +				CHookManagerContainer::Descriptor(hentry->vtbl_offs, hentry->vtbl_idx, hentry->proto));
  1.1641 +
  1.1642 +			if (hmcl_iter == m_HookManContainers.end() || !(*hmcl_iter))
  1.1643 +				return false;
  1.1644 +
  1.1645 +			CHookManager &hookman = hmcl_iter->GetActiveHookManager();
  1.1646  
  1.1647 -	void CSourceHookImpl::ResetIgnoreHooks(Plugin plug, void *vfnptr)
  1.1648 -	{
  1.1649 -		m_OneIgnore = NULL;
  1.1650 -	}
  1.1651 +			// find vfnptr
  1.1652 +			List<CVfnPtr>::iterator vfnptr_iter = hookman.GetVfnPtrList().find(hentry->vfnptr);
  1.1653 +			if (vfnptr_iter == hookman.GetVfnPtrList().end())
  1.1654 +				return false;
  1.1655 +
  1.1656 +			// find iface
  1.1657 +			List<CIface>::iterator iface_iter = vfnptr_iter->GetIfaceList().find(hentry->adjustediface);
  1.1658 +			if (iface_iter == vfnptr_iter->GetIfaceList().end())
  1.1659 +				return false;
  1.1660  
  1.1661 -	void *CSourceHookImpl::GetOrigVfnPtrEntry(void *vfnptr)
  1.1662 -	{
  1.1663 -		for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
  1.1664 -			hmcl_iter != m_HookMans.end(); ++hmcl_iter)
  1.1665 +			// find hook
  1.1666 +			List<CHook> &hooks = hentry->post ? iface_iter->GetPostHookList() : iface_iter->GetPreHookList();
  1.1667 +			List<CHook>::iterator hook_iter = hooks.find(hookid);
  1.1668 +			if (hook_iter == hooks.end())
  1.1669 +				return false;
  1.1670 +
  1.1671 +			hook_iter->SetPaused(paused);
  1.1672 +			return true;
  1.1673 +		}
  1.1674 +
  1.1675 +		//////////////////////////////////////////////////////////////////////////
  1.1676 +		// CHookContext
  1.1677 +		//////////////////////////////////////////////////////////////////////////
  1.1678 +		ISHDelegate *CHookContext::GetNext()
  1.1679  		{
  1.1680 -			for (CHookManagerContainer::iterator hookmaniter = hmcl_iter->begin();
  1.1681 -				hookmaniter != hmcl_iter->end(); ++hookmaniter)
  1.1682 +			CIface *pVPIface;
  1.1683 +
  1.1684 +			switch (m_State)
  1.1685  			{
  1.1686 -				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->m_VfnPtrs.begin();
  1.1687 -					vfnptr_iter != hookmaniter->m_VfnPtrs.end(); ++vfnptr_iter)
  1.1688 +			case State_Dead:
  1.1689 +				return NULL;
  1.1690 +
  1.1691 +			case State_Born:
  1.1692 +				m_Iter = List<CHook>::iterator();
  1.1693 +				m_State = State_Pre;
  1.1694 +
  1.1695 +				// fall-through
  1.1696 +			case State_Recall_Pre:
  1.1697 +				m_State = State_Pre;
  1.1698 +			case State_Pre:
  1.1699 +				if (pIface)
  1.1700 +				{
  1.1701 +					if (!m_Iter)
  1.1702 +						m_Iter = pIface->GetPreHookList().begin();
  1.1703 +					else
  1.1704 +						++m_Iter;
  1.1705 +					SkipPaused(m_Iter, pIface->GetPreHookList());
  1.1706 +
  1.1707 +					if (m_Iter != pIface->GetPreHookList().end())
  1.1708 +					{
  1.1709 +						pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
  1.1710 +						return m_Iter->GetHandler();
  1.1711 +					}
  1.1712 +				}
  1.1713 +
  1.1714 +				// end of normal hooks -> VP
  1.1715 +				
  1.1716 +				m_State = State_PreVP;
  1.1717 +				m_Iter = List<CHook>::iterator();
  1.1718 +
  1.1719 +				// fall-through
  1.1720 +			case State_Recall_PreVP:
  1.1721 +				m_State = State_PreVP;
  1.1722 +			case State_PreVP:
  1.1723 +				pVPIface = pVfnPtr->FindIface(NULL);
  1.1724 +				if (pVPIface)
  1.1725 +				{
  1.1726 +					if (!m_Iter)
  1.1727 +						m_Iter = pVPIface->GetPreHookList().begin();
  1.1728 +					else
  1.1729 +						++m_Iter;
  1.1730 +					SkipPaused(m_Iter, pVPIface->GetPreHookList());
  1.1731 +
  1.1732 +					if (m_Iter != pVPIface->GetPreHookList())
  1.1733 +					{
  1.1734 +						pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
  1.1735 +						return m_Iter->GetHandler();
  1.1736 +					}
  1.1737 +				}
  1.1738 +
  1.1739 +				// end VP hooks -> orig call
  1.1740 +
  1.1741 +				m_State = State_OrigCall;
  1.1742 +				return NULL;
  1.1743 +				
  1.1744 +			case State_OrigCall:
  1.1745 +				m_Iter = List<CHook>::iterator();
  1.1746 +				m_State = State_Post;
  1.1747 +
  1.1748 +				// fall-through
  1.1749 +			case State_Post:
  1.1750 +				if (pIface)
  1.1751  				{
  1.1752 -					if (vfnptr_iter->m_Ptr == vfnptr)
  1.1753 -						return vfnptr_iter->m_OrigEntry;
  1.1754 +					if (!m_Iter)
  1.1755 +						m_Iter = pIface->GetPostHookList().begin();
  1.1756 +					else
  1.1757 +						++m_Iter;
  1.1758 +					SkipPaused(m_Iter, pIface->GetPostHookList());
  1.1759 +
  1.1760 +					if (m_Iter != pIface->GetPostHookList().end())
  1.1761 +					{
  1.1762 +						pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
  1.1763 +						return m_Iter->GetHandler();
  1.1764 +					}
  1.1765 +				}
  1.1766 +				// end of normal hooks -> VP
  1.1767 +
  1.1768 +				m_State = State_PostVP;
  1.1769 +				m_Iter = List<CHook>::iterator();
  1.1770 +
  1.1771 +				// fall-through
  1.1772 +			case State_PostVP:
  1.1773 +				pVPIface = pVfnPtr->FindIface(NULL);
  1.1774 +				if (pVPIface)
  1.1775 +				{
  1.1776 +					if (!m_Iter)
  1.1777 +						m_Iter = pVPIface->GetPostHookList().begin();
  1.1778 +					else
  1.1779 +						++m_Iter;
  1.1780 +					SkipPaused(m_Iter, pVPIface->GetPostHookList());
  1.1781 +
  1.1782 +					if (m_Iter != pVPIface->GetPostHookList())
  1.1783 +					{
  1.1784 +						pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
  1.1785 +						return m_Iter->GetHandler();
  1.1786 +					}
  1.1787  				}
  1.1788 +
  1.1789 +				// end VP hooks -> done
  1.1790 +
  1.1791 +				m_State = State_Dead;
  1.1792 +				return NULL;
  1.1793 +
  1.1794 +			case State_Recall_Post:
  1.1795 +				// Skip pre hooks _and_ orig call
  1.1796 +				m_State = State_Post;
  1.1797 +				return NULL;
  1.1798 +
  1.1799 +			case State_Recall_PostVP:
  1.1800 +				// Skip pre hooks _and_ orig call
  1.1801 +				m_State = State_PostVP;
  1.1802 +				return NULL;
  1.1803 +			}
  1.1804 +			return NULL;
  1.1805 +		}
  1.1806 +
  1.1807 +		void *CHookContext::GetOverrideRetPtr()
  1.1808 +		{
  1.1809 +			return pOverrideRet;
  1.1810 +		}
  1.1811 +
  1.1812 +		const void *CHookContext::GetOrigRetPtr()
  1.1813 +		{
  1.1814 +			return pOrigRet;
  1.1815 +		}
  1.1816 +
  1.1817 +		bool CHookContext::ShouldCallOrig()
  1.1818 +		{
  1.1819 +			return m_CallOrig;
  1.1820 +		}
  1.1821 +
  1.1822 +		void CHookContext::HookRemoved(List<CHook>::iterator oldhookiter, List<CHook>::iterator nexthookiter)
  1.1823 +		{
  1.1824 +			if (m_Iter == oldhookiter)
  1.1825 +			{
  1.1826 +				m_Iter = nexthookiter;
  1.1827 +				--m_Iter;
  1.1828  			}
  1.1829  		}
  1.1830 -		return NULL;
  1.1831 -	}
  1.1832  
  1.1833 -	////////////////////////////
  1.1834 -	// CCallClassImpl
  1.1835 -	////////////////////////////
  1.1836 -	CSourceHookImpl::CCallClassImpl::CCallClassImpl(void *ptr, size_t size)
  1.1837 -		: m_Ptr(ptr), m_ObjSize(size), m_RefCounter(1)
  1.1838 -	{
  1.1839 -	}
  1.1840 -	CSourceHookImpl::CCallClassImpl::~CCallClassImpl()
  1.1841 -	{
  1.1842 -	}
  1.1843 -
  1.1844 -	void *CSourceHookImpl::CCallClassImpl::GetThisPtr()
  1.1845 -	{
  1.1846 -		return m_Ptr;
  1.1847 -	}
  1.1848 -	void *CSourceHookImpl::CCallClassImpl::GetOrigFunc(int vtbloffs, int vtblidx)
  1.1849 -	{
  1.1850 -		OrigVTables::iterator iter = m_VT.find(vtbloffs);
  1.1851 -		if (iter != m_VT.end() && iter->val.size() > (size_t)vtblidx)
  1.1852 +		void CHookContext::IfaceRemoved(CIface *iface)
  1.1853  		{
  1.1854 -			return iter->val[vtblidx];
  1.1855 +			if (pIface == iface)
  1.1856 +				pIface = NULL;
  1.1857  		}
  1.1858 -		return NULL;
  1.1859 -	}
  1.1860  
  1.1861 -	void CSourceHookImpl::CCallClassImpl::ApplyCallClassPatch(int vtbl_offs, int vtbl_idx, void *orig_entry)
  1.1862 -	{
  1.1863 -		OrigFuncs &tmpvec = m_VT[vtbl_offs];
  1.1864 -		if (tmpvec.size() <= (size_t)vtbl_idx)
  1.1865 -			tmpvec.resize(vtbl_idx+1, NULL);
  1.1866 -		tmpvec[vtbl_idx] = orig_entry;
  1.1867 -	}
  1.1868 -	void CSourceHookImpl::CCallClassImpl::RemoveCallClassPatch(int vtbl_offs, int vtbl_idx)
  1.1869 -	{
  1.1870 -		OrigVTables::iterator iter = m_VT.find(vtbl_offs);
  1.1871 -		if (iter != m_VT.end())
  1.1872 +		void CHookContext::VfnPtrRemoved(CVfnPtr *vfnptr)
  1.1873  		{
  1.1874 -			if (iter->val.size() > (size_t)vtbl_idx)
  1.1875 +			if (pVfnPtr == vfnptr)
  1.1876  			{
  1.1877 -				iter->val[vtbl_idx] = 0;
  1.1878 -
  1.1879 -				OrigFuncs &of = iter->val;
  1.1880 -				OrigFuncs::iterator lastused = of.end();
  1.1881 -				for (OrigFuncs::iterator viter = of.begin(); viter != of.end(); ++viter)
  1.1882 -				{
  1.1883 -					if (*viter)
  1.1884 -						lastused = viter;
  1.1885 -				}
  1.1886 -				if (lastused == of.end())
  1.1887 -				{
  1.1888 -					// No used element => Remove the whole vector
  1.1889 -					m_VT.erase(iter);
  1.1890 -					return;
  1.1891 -				}
  1.1892 -				of.resize(lastused - of.begin() + 1);
  1.1893 +				pVfnPtr = NULL;
  1.1894 +				m_State = State_Dead;
  1.1895  			}
  1.1896  		}
  1.1897  	}
  1.1898 -
  1.1899 -	////////////////////////////
  1.1900 -	// CHookManagerInfo
  1.1901 -	////////////////////////////
  1.1902 -	CSourceHookImpl::CHookManagerInfo::CHookManagerInfo() : m_HookManVersion(0)
  1.1903 -	{
  1.1904 -	}
  1.1905 -	CSourceHookImpl::CHookManagerInfo::~CHookManagerInfo()
  1.1906 -	{
  1.1907 -	}
  1.1908 -
  1.1909 -	IVfnPtr *CSourceHookImpl::CHookManagerInfo::FindVfnPtr(void *vfnptr)
  1.1910 -	{
  1.1911 -		VfnPtrListIter iter = m_VfnPtrs.find(vfnptr);
  1.1912 -		return iter == m_VfnPtrs.end() ? NULL : &(*iter);
  1.1913 -	}
  1.1914 -	void CSourceHookImpl::CHookManagerInfo::SetInfo(int vtbl_offs, int vtbl_idx, const char *proto)
  1.1915 -	{
  1.1916 -		m_VtblOffs = vtbl_offs;
  1.1917 -		m_VtblIdx = vtbl_idx;
  1.1918 -		m_Proto = proto;
  1.1919 -	}
  1.1920 -	void CSourceHookImpl::CHookManagerInfo::SetHookfuncVfnptr(void *hookfunc_vfnptr)
  1.1921 -	{
  1.1922 -		m_HookfuncVfnptr = hookfunc_vfnptr;
  1.1923 -	}
  1.1924 -	void CSourceHookImpl::CHookManagerInfo::SetVersion(int version)
  1.1925 -	{
  1.1926 -		m_HookManVersion = version;
  1.1927 -	}
  1.1928 -	////////////////////////////
  1.1929 -	// CVfnPtr
  1.1930 -	////////////////////////////
  1.1931 -
  1.1932 -
  1.1933 -	// If you get a crash here, the ptr passed is invalid
  1.1934 -	// This usually means a SH_DECL_MANUALHOOK* with wrong thisptroffs/vtbloffs/vtblidx
  1.1935 -	CSourceHookImpl::CVfnPtr::CVfnPtr(void *ptr, void **pOneIgnore) : m_Ptr(ptr), 
  1.1936 -		m_OrigEntry(*reinterpret_cast<void**>(ptr)), m_pOneIgnore(pOneIgnore)
  1.1937 -	{
  1.1938 -	}
  1.1939 -	CSourceHookImpl::CVfnPtr::~CVfnPtr()
  1.1940 -	{
  1.1941 -	}
  1.1942 -
  1.1943 -	void *CSourceHookImpl::CVfnPtr::GetVfnPtr()
  1.1944 -	{
  1.1945 -		return m_Ptr;
  1.1946 -	}
  1.1947 -
  1.1948 -	void *CSourceHookImpl::CVfnPtr::GetOrigEntry()
  1.1949 -	{
  1.1950 -		return m_OrigEntry;
  1.1951 -	}
  1.1952 -
  1.1953 -	IIface *CSourceHookImpl::CVfnPtr::FindIface(void *ptr)
  1.1954 -	{
  1.1955 -		if (m_Ptr == *m_pOneIgnore)
  1.1956 -		{
  1.1957 -			*m_pOneIgnore = NULL;		// Only once!
  1.1958 -			return NULL;
  1.1959 -		}
  1.1960 -
  1.1961 -		IfaceListIter iter = m_Ifaces.find(ptr);
  1.1962 -		
  1.1963 -		// If nothing is found, check for a NULL-interface (VP hooks only)
  1.1964 -		if (iter == m_Ifaces.end())
  1.1965 -		{
  1.1966 -			iter = m_Ifaces.find((void*)0);
  1.1967 -			return iter == m_Ifaces.end() ? NULL : &(*iter);
  1.1968 -		}
  1.1969 -		else
  1.1970 -		{
  1.1971 -			return &(*iter);
  1.1972 -		}
  1.1973 -	}
  1.1974 -
  1.1975 -	////////////////////////////
  1.1976 -	// CIface
  1.1977 -	////////////////////////////
  1.1978 -	CSourceHookImpl::CIface::CIface(void *ptr) : m_Ptr(ptr)
  1.1979 -	{
  1.1980 -	}
  1.1981 -	CSourceHookImpl::CIface::~CIface()
  1.1982 -	{
  1.1983 -	}
  1.1984 -
  1.1985 -	void *CSourceHookImpl::CIface::GetPtr()
  1.1986 -	{
  1.1987 -		return m_Ptr;
  1.1988 -	}
  1.1989 -
  1.1990 -	IHookList *CSourceHookImpl::CIface::GetPreHooks()
  1.1991 -	{
  1.1992 -		return &m_PreHooks;
  1.1993 -	}
  1.1994 -	IHookList *CSourceHookImpl::CIface::GetPostHooks()
  1.1995 -	{
  1.1996 -		return &m_PostHooks;
  1.1997 -	}
  1.1998 -
  1.1999 -	////////////////////////////
  1.2000 -	// CHookList
  1.2001 -	////////////////////////////
  1.2002 -
  1.2003 -	CSourceHookImpl::CHookList::CHookList() : m_VPList(NULL), m_FreeIters(NULL), m_UsedIters(NULL),
  1.2004 -		m_Recall(false)
  1.2005 -	{
  1.2006 -	}
  1.2007 -	CSourceHookImpl::CHookList::CHookList(const CHookList &other) : m_VPList(other.m_VPList), m_List(other.m_List),
  1.2008 -		m_FreeIters(NULL), m_UsedIters(NULL), m_Recall(false)
  1.2009 -	{
  1.2010 -	}
  1.2011 -
  1.2012 -	CSourceHookImpl::CHookList::~CHookList()
  1.2013 -	{
  1.2014 -		while (m_FreeIters)
  1.2015 -		{
  1.2016 -			CIter *iter = m_FreeIters->m_pNext;
  1.2017 -			delete m_FreeIters;
  1.2018 -			m_FreeIters = iter;
  1.2019 -		}
  1.2020 -		while (m_UsedIters)
  1.2021 -		{
  1.2022 -			CIter *iter = m_UsedIters->m_pNext;
  1.2023 -			delete m_UsedIters;
  1.2024 -			m_UsedIters = iter;
  1.2025 -		}
  1.2026 -	}
  1.2027 -	IHookList::IIter *CSourceHookImpl::CHookList::GetIter()
  1.2028 -	{
  1.2029 -		m_RQFlag = true;
  1.2030 -
  1.2031 -		CIter *ret;
  1.2032 -		if (m_FreeIters)
  1.2033 -		{
  1.2034 -			ret = m_FreeIters;
  1.2035 -			m_FreeIters = ret->m_pNext;
  1.2036 -			ret->GoToBegin();
  1.2037 -		}
  1.2038 -		else
  1.2039 -		{
  1.2040 -			ret = new CIter(this);
  1.2041 -		}
  1.2042 -		
  1.2043 -		// Muuuh, if we're recalling, it shall be a copy of the last iterator, incremented by one
  1.2044 -		if (m_Recall && m_UsedIters)
  1.2045 -		{
  1.2046 -			ret->Set(m_UsedIters);		// m_UsedIters is the last returned and not released iterator
  1.2047 -			ret->Next();				// Use next instead of directly incrementing its m_Iter:
  1.2048 -										// skips paused plugins
  1.2049 -		}
  1.2050 -
  1.2051 -		ret->m_pNext = m_UsedIters;
  1.2052 -		ret->m_pPrev = NULL;
  1.2053 -		if (m_UsedIters)
  1.2054 -			m_UsedIters->m_pPrev = ret;
  1.2055 -		m_UsedIters = ret;
  1.2056 -
  1.2057 -		m_Recall = false;
  1.2058 -
  1.2059 -		return ret;
  1.2060 -	}
  1.2061 -	void CSourceHookImpl::CHookList::ReleaseIter(IIter *pIter)
  1.2062 -	{
  1.2063 -		CIter *pIter2 = static_cast<CIter*>(pIter);
  1.2064 -
  1.2065 -		// Unlink from m_UsedIters
  1.2066 -
  1.2067 -		if (pIter2->m_pNext)
  1.2068 -			pIter2->m_pNext->m_pPrev = pIter2->m_pPrev;
  1.2069 -		if (pIter2->m_pPrev)
  1.2070 -			pIter2->m_pPrev->m_pNext = pIter2->m_pNext;
  1.2071 -		if (pIter2 == m_UsedIters)
  1.2072 -			m_UsedIters = NULL;
  1.2073 -
  1.2074 -		// Link to m_FreeIters
  1.2075 -
  1.2076 -		pIter2->m_pNext = m_FreeIters;
  1.2077 -
  1.2078 -		m_FreeIters = pIter2;
  1.2079 -
  1.2080 -		// Reset recall state.
  1.2081 -		m_Recall = false;
  1.2082 -	}
  1.2083 -
  1.2084 -	void CSourceHookImpl::CHookList::SetVPList(List<HookInfo> *newList)
  1.2085 -	{
  1.2086 -		m_VPList = newList;
  1.2087 -
  1.2088 -		// Update cached CIter objects
  1.2089 -
  1.2090 -		CIter *pTmp;
  1.2091 -		pTmp = m_FreeIters;
  1.2092 -		while (pTmp)
  1.2093 -		{
  1.2094 -			pTmp->m_Iter.SetListLeft(m_VPList);
  1.2095 -			pTmp = pTmp->m_pNext;
  1.2096 -		}
  1.2097 -
  1.2098 -		pTmp = m_UsedIters;
  1.2099 -		while (pTmp)
  1.2100 -		{
  1.2101 -			pTmp->m_Iter.SetListLeft(m_VPList);
  1.2102 -			pTmp = pTmp->m_pNext;
  1.2103 -		}
  1.2104 -	}
  1.2105 -
  1.2106 -	void CSourceHookImpl::CHookList::ClearVPList()
  1.2107 -	{
  1.2108 -		SetVPList(NULL);
  1.2109 -	}
  1.2110 -
  1.2111 -	CSourceHookImpl::CHookList::CIter::CIter(CHookList *pList) : m_pList(pList), 
  1.2112 -		m_Iter(pList->m_VPList, &m_pList->m_List), m_pNext(NULL)
  1.2113 -	{
  1.2114 -	}
  1.2115 -	CSourceHookImpl::CHookList::CIter::~CIter()
  1.2116 -	{
  1.2117 -	}
  1.2118 -
  1.2119 -	void CSourceHookImpl::CHookList::CIter::Set(CIter *pOther)
  1.2120 -	{
  1.2121 -		m_Iter = pOther->m_Iter;
  1.2122 -	}
  1.2123 -
  1.2124 -	void CSourceHookImpl::CHookList::CIter::GoToBegin()
  1.2125 -	{
  1.2126 -		m_Iter.GoToBegin();
  1.2127 -		SkipPaused();
  1.2128 -	}
  1.2129 -
  1.2130 -	bool CSourceHookImpl::CHookList::CIter::End()
  1.2131 -	{
  1.2132 -		if (!m_pList)
  1.2133 -			return false;
  1.2134 -		return m_Iter.End();;
  1.2135 -	}
  1.2136 -	void CSourceHookImpl::CHookList::CIter::Next()
  1.2137 -	{
  1.2138 -		if (!m_pList)
  1.2139 -			return;
  1.2140 -		++m_Iter;
  1.2141 -		SkipPaused();
  1.2142 -	}
  1.2143 -	void CSourceHookImpl::CHookList::CIter::Clear()
  1.2144 -	{
  1.2145 -		m_pList = NULL;
  1.2146 -	}
  1.2147 -	void CSourceHookImpl::CHookList::CIter::SkipPaused()
  1.2148 -	{
  1.2149 -		while (!m_Iter.End() && m_Iter->paused)
  1.2150 -			++m_Iter;
  1.2151 -	}
  1.2152 -
  1.2153 -	ISHDelegate *CSourceHookImpl::CHookList::CIter::Handler()
  1.2154 -	{
  1.2155 -		return m_Iter->handler;
  1.2156 -	}
  1.2157 -	int CSourceHookImpl::CHookList::CIter::ThisPtrOffs()
  1.2158 -	{
  1.2159 -		return m_Iter->thisptr_offs;
  1.2160 -	}
  1.2161 -
  1.2162 -	//////////////////////////////////////////////////////////////////////////
  1.2163 -	// CProto
  1.2164 -	//////////////////////////////////////////////////////////////////////////
  1.2165 -	char *CSourceHookImpl::CProto::DupProto(const char *p)
  1.2166 -	{
  1.2167 -		if (!p)
  1.2168 -			return NULL;
  1.2169 -
  1.2170 -		char *newproto;
  1.2171 -		if (*p)
  1.2172 -		{
  1.2173 -			size_t len = strlen(p);
  1.2174 -			newproto = new char[len+1];
  1.2175 -			memcpy(newproto, p, len+1);
  1.2176 -		} else {
  1.2177 -			const ProtoInfo *pi1 = reinterpret_cast<const ProtoInfo *>(p);
  1.2178 -			int *ar_copy = new int[pi1->numOfParams + 1];
  1.2179 -			for (int i = 0; i <= pi1->numOfParams; i++)
  1.2180 -				ar_copy[i] = pi1->params[i];
  1.2181 -			ProtoInfo *copy = new ProtoInfo(pi1->retTypeSize, pi1->numOfParams, ar_copy);
  1.2182 -			newproto = reinterpret_cast<char *>(copy);
  1.2183 -		}
  1.2184 -
  1.2185 -		return newproto;
  1.2186 -	}
  1.2187 -
  1.2188 -	void CSourceHookImpl::CProto::FreeProto(char *prot)
  1.2189 -	{
  1.2190 -		if (!prot)
  1.2191 -			return;
  1.2192 -
  1.2193 -		if (*prot)
  1.2194 -		{
  1.2195 -			delete [] prot;
  1.2196 -		} else {
  1.2197 -			ProtoInfo *pi = reinterpret_cast<ProtoInfo *>(prot);
  1.2198 -			delete [] pi->params;
  1.2199 -			delete pi;
  1.2200 -		}
  1.2201 -	}
  1.2202 -
  1.2203 -	bool CSourceHookImpl::CProto::Equal(const char *p1, const char *p2)
  1.2204 -	{
  1.2205 -		if (!p1 || !p2)
  1.2206 -			return false;
  1.2207 -
  1.2208 -		if (*p1 && *p2)			// Case1: Both old
  1.2209 -		{
  1.2210 -			// As in old versions
  1.2211 -			return strcmp(p1, p2) == 0;
  1.2212 -		}
  1.2213 -		else if (!*p1 && !*p2)	// Case2: Both new
  1.2214 -		{
  1.2215 -			const ProtoInfo *pi1 = reinterpret_cast<const ProtoInfo*>(p1);
  1.2216 -			const ProtoInfo *pi2 = reinterpret_cast<const ProtoInfo*>(p2);
  1.2217 -
  1.2218 -			if (pi1->retTypeSize == pi2->retTypeSize &&
  1.2219 -				pi1->numOfParams == pi2->numOfParams)
  1.2220 -			{
  1.2221 -				// params[0] is 0 for "normal" functions and -1 for vararg functions
  1.2222 -				// params[1] is size of first parameter
  1.2223 -				// params[2] is size of second parameter ...
  1.2224 -				for (int i = 0; i <= pi1->numOfParams; ++i)
  1.2225 -				{
  1.2226 -					if (pi1->params[i] != pi2->params[i])
  1.2227 -						return false;
  1.2228 -				}
  1.2229 -				return true;
  1.2230 -			}
  1.2231 -			else
  1.2232 -			{
  1.2233 -				return false;
  1.2234 -			}
  1.2235 -		}
  1.2236 -		else					// Case3: Mixed old/new
  1.2237 -		{
  1.2238 -			// Trust the user
  1.2239 -			return true;
  1.2240 -		}
  1.2241 -	}
  1.2242 -
  1.2243 -
  1.2244 -	//////////////////////////////////////////////////////////////////////////
  1.2245 -	// CHookManagerContainer
  1.2246 -	//////////////////////////////////////////////////////////////////////////
  1.2247 -	void CSourceHookImpl::CHookManagerContainer::AddHookManager(Plugin plug, const CHookManagerInfo &hookman)
  1.2248 -	{
  1.2249 -		iterator iter;
  1.2250 -		// Check whether such a hook manager already exists; if yes, ignore.
  1.2251 -		for (iter = begin(); iter != end(); ++iter)
  1.2252 -		{
  1.2253 -			if (iter->m_Plug == plug && iter->m_Func == hookman.m_Func)
  1.2254 -				return;
  1.2255 -		}
  1.2256 -
  1.2257 -		// It doesn't -> add it. Add it to the end of its version group.
  1.2258 -		for (iter = begin(); iter != end(); ++iter)
  1.2259 -		{
  1.2260 -			if (iter->m_HookManVersion < hookman.m_HookManVersion)
  1.2261 -				break;
  1.2262 -		}
  1.2263 -
  1.2264 -		bool isBeginning = iter == begin();
  1.2265 -
  1.2266 -		insert(iter, hookman);
  1.2267 -
  1.2268 -		// If we inserted it at the beginning and if the dam breaks open many years too soon
  1.2269 -		// and if there is more than one hookman and if the second one isn't empty, transfer
  1.2270 -		// hooks from second to first
  1.2271 -
  1.2272 -		if (isBeginning && size() > 1)
  1.2273 -		{
  1.2274 -			iter = begin();
  1.2275 -			iterator second = iter;
  1.2276 -			++second;
  1.2277 -
  1.2278 -			if (!second->m_VfnPtrs.empty())
  1.2279 -			{
  1.2280 -				// Move the vfnptrs from the old hook manager to the new one
  1.2281 -				iter->m_VfnPtrs = second->m_VfnPtrs;
  1.2282 -				second->m_VfnPtrs.clear();
  1.2283 -
  1.2284 -				// Unregister the old one, register the new one
  1.2285 -				second->m_Func(HA_Unregister, NULL);
  1.2286 -				iter->m_Func(HA_Register, &(*iter));
  1.2287 -
  1.2288 -				// Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
  1.2289 -				// or whatever
  1.2290 -				for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = iter->m_VfnPtrs.begin();
  1.2291 -					vfnptr_iter != iter->m_VfnPtrs.end(); ++vfnptr_iter)
  1.2292 -				{
  1.2293 -					// And DEREFERENCE newHookMan->m_HookfuncVfnptr!
  1.2294 -					// otherwise it will be executing the vtable... had to find out the hard way
  1.2295 -					*reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = *reinterpret_cast<void**>(iter->m_HookfuncVfnptr);
  1.2296 -				}
  1.2297 -			}
  1.2298 -		}
  1.2299 -	}
  1.2300 -
  1.2301 -	//////////////////////////////////////////////////////////////////////////
  1.2302 -	// CHookIDManager
  1.2303 -	//////////////////////////////////////////////////////////////////////////
  1.2304 -	CSourceHookImpl::CHookIDManager::CHookIDManager()
  1.2305 -	{
  1.2306 -	}
  1.2307 -
  1.2308 -	int CSourceHookImpl::CHookIDManager::New(const CProto &proto, int vtbl_offs, int vtbl_idx, void *vfnptr,
  1.2309 -		void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
  1.2310 -	{
  1.2311 -		Entry tmp(proto, vtbl_offs, vtbl_idx, vfnptr, adjustediface, plug, thisptr_offs, handler, post);
  1.2312 -
  1.2313 -		size_t cursize = m_Entries.size();
  1.2314 -		for (size_t i = 0; i < cursize; ++i)
  1.2315 -		{
  1.2316 -			if (m_Entries[i].isfree)
  1.2317 -			{
  1.2318 -				m_Entries[i] = tmp;
  1.2319 -				return static_cast<int>(i) + 1;
  1.2320 -			}
  1.2321 -		}
  1.2322 -
  1.2323 -		m_Entries.push_back(tmp);
  1.2324 -		return static_cast<int>(m_Entries.size());		// return size() because hookid = id+1 anyway
  1.2325 -	}
  1.2326 -
  1.2327 -	bool CSourceHookImpl::CHookIDManager::Remove(int hookid)
  1.2328 -	{
  1.2329 -		int realid = hookid - 1;
  1.2330 -		if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
  1.2331 -			return false;
  1.2332 -
  1.2333 -		m_Entries[realid].isfree = true;
  1.2334 -
  1.2335 -		// :TODO: remove free ids from back sometimes ??
  1.2336 -
  1.2337 -		return true;
  1.2338 -	}
  1.2339 -
  1.2340 -	const CSourceHookImpl::CHookIDManager::Entry * CSourceHookImpl::CHookIDManager::QueryHook(int hookid)
  1.2341 -	{
  1.2342 -		int realid = hookid - 1;
  1.2343 -		if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
  1.2344 -			return NULL;
  1.2345 -
  1.2346 -		return &m_Entries[realid];
  1.2347 -	}
  1.2348 -
  1.2349 -	void CSourceHookImpl::CHookIDManager::FindAllHooks(CVector<int> &output, const CProto &proto, int vtbl_offs,
  1.2350 -		int vtbl_idx, void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
  1.2351 -	{
  1.2352 -		// oh my god, a lot of parameters...
  1.2353 -		size_t cursize = m_Entries.size();
  1.2354 -		for (size_t i = 0; i < cursize; ++i)
  1.2355 -		{
  1.2356 -			if (!m_Entries[i].isfree && m_Entries[i].proto == proto && m_Entries[i].vtbl_offs == vtbl_offs &&
  1.2357 -				m_Entries[i].vtbl_idx == vtbl_idx && m_Entries[i].adjustediface == adjustediface && m_Entries[i].plug == plug &&
  1.2358 -				m_Entries[i].thisptr_offs == thisptr_offs && m_Entries[i].handler->IsEqual(handler) && m_Entries[i].post == post)
  1.2359 -			{
  1.2360 -				output.push_back(static_cast<int>(i) + 1);
  1.2361 -			}
  1.2362 -		}
  1.2363 -	} 
  1.2364  }