sourcehook/sourcehook.cpp
author David Anderson <dvander@alliedmods.net>
Tue Sep 13 20:24:58 2005 +0000 (2005-09-13)
changeset 108 305ad7e181d5
parent 107 1d6e7e0bdcd9
child 117 e322da4af2d2
permissions -rw-r--r--
stdint is gnuc only
     1 /* ======== SourceHook ========
     2 * Copyright (C) 2004-2005 Metamod:Source Development Team
     3 * No warranties of any kind
     4 *
     5 * License: zlib/libpng
     6 *
     7 * Author(s): Pavol "PM OnoTo" Marko
     8 * Contributors: Scott "Damaged Soul" Ehlert
     9 * ============================
    10 */
    11 
    12 /**
    13  * @file sourcehook.cpp
    14  * @brief Contains the implementation of the SourceHook API
    15 */
    16 
    17 #if defined __GNUC__
    18 #include <stdint.h>
    19 #endif
    20 #include "sourcehook_impl.h"
    21 #include "sh_tinyhash.h"
    22 
    23 namespace SourceHook
    24 {
    25 	template<>
    26 	int SourceHook::HashFunction<int>(const int & k)
    27 	{
    28 		return k;
    29 	}
    30 	template<>
    31 	int SourceHook::Compare<int>(const int & k1, const int & k2)
    32 	{
    33 		if (k1 == k2)
    34 			return 0;
    35 		if (k1 > k2)
    36 			return 1;
    37 		if (k1 < k2)
    38 			return -1;
    39 		return 0;
    40 	}
    41 	CSourceHookImpl::CSourceHookImpl()
    42 	{
    43 	}
    44 
    45 	CSourceHookImpl::~CSourceHookImpl()
    46 	{
    47 	}
    48 
    49 	int CSourceHookImpl::GetIfaceVersion()
    50 	{
    51 		return SH_IFACE_VERSION;
    52 	}
    53 
    54 	int CSourceHookImpl::GetImplVersion()
    55 	{
    56 		return SH_IMPL_VERSION;
    57 	}
    58 
    59 	bool CSourceHookImpl::IsPluginInUse(Plugin plug)
    60 	{
    61 		// Iterate through all hook managers which are in this plugin
    62 		// Iterate through their vfnptrs, ifaces, hooks
    63 		// If a hook from an other plugin is found, return true
    64 		// Return false otherwise
    65 #define TMP_CHECK_LIST(name) \
    66 	for (hook_iter = iface_iter->name.begin(); hook_iter != iface_iter->name.end(); ++hook_iter) \
    67 		if (hook_iter->plug == plug) \
    68 			return true;
    69 
    70 		for (HookManInfoList::iterator hmil_iter = m_HookMans.begin(); hmil_iter != m_HookMans.end(); ++hmil_iter)
    71 		{
    72 			if (hmil_iter->plug != plug)
    73 				continue;
    74 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->vfnptrs.begin();
    75 				vfnptr_iter != hmil_iter->vfnptrs.end(); ++vfnptr_iter)
    76 			{
    77 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
    78 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
    79 				{
    80 					List<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hook_iter;
    81 					TMP_CHECK_LIST(hooks_pre);
    82 					TMP_CHECK_LIST(hooks_post);
    83 				}
    84 			}
    85 		}
    86 #undef TMP_CHECK_LIST
    87 		return false;
    88 	}
    89 
    90 	void CSourceHookImpl::UnloadPlugin(Plugin plug)
    91 	{
    92 		// 1) Manually remove all hooks by this plugin
    93 		List<RemoveHookInfo> hookstoremove;
    94 		HookManInfoList::iterator hmil_iter;
    95 
    96 #define TMP_CHECK_LIST(name, ispost) \
    97 	for (hook_iter = iface_iter->name.begin(); hook_iter != iface_iter->name.end(); ++hook_iter) \
    98 		if (hook_iter->plug == plug) \
    99 			hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->ptr, \
   100 			hook_iter->thisptr_offs, hmil_iter->func, hook_iter->handler, ispost))
   101 		for (hmil_iter = m_HookMans.begin(); hmil_iter != m_HookMans.end(); ++hmil_iter)
   102 		{
   103 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->vfnptrs.begin();
   104 				vfnptr_iter != hmil_iter->vfnptrs.end(); ++vfnptr_iter)
   105 			{
   106 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   107 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
   108 				{
   109 					List<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hook_iter;
   110 					TMP_CHECK_LIST(hooks_pre, false);
   111 					TMP_CHECK_LIST(hooks_post, true);
   112 				}
   113 			}
   114 		}
   115 #undef TMP_CHECK_LIST
   116 
   117 		for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   118 			RemoveHook(*rmiter);
   119 
   120 		// 2) Other plugins may use hook managers in this plugin.
   121 		// Get a list of hook managers that are in this plugin and are used by other plugins
   122 		// Delete all hook managers that are in this plugin
   123 
   124 		HookManInfoList tmphookmans;
   125 		bool erase = false;
   126 		for (hmil_iter = m_HookMans.begin(); hmil_iter != m_HookMans.end();
   127 			erase ? hmil_iter=m_HookMans.erase(hmil_iter) : ++hmil_iter)
   128 		{
   129 			if (hmil_iter->plug == plug)
   130 			{
   131 				if (!hmil_iter->vfnptrs.empty())
   132 				{
   133 					// All hooks by this plugin are already removed
   134 					// So if there is a vfnptr, it has to be used by an other plugin
   135 					tmphookmans.push_back(*hmil_iter);
   136 				}
   137 				erase = true;
   138 			}
   139 			else
   140 				erase = false;
   141 		}
   142 		
   143 		// For each hook manager:
   144 		for (hmil_iter = tmphookmans.begin(); hmil_iter != tmphookmans.end(); ++hmil_iter)
   145 		{
   146 			// Find a suitable hook manager in an other plugin
   147 			HookManInfoList::iterator newHookMan = FindHookMan(m_HookMans.begin(), m_HookMans.end(),
   148 				hmil_iter->proto, hmil_iter->vtbl_offs, hmil_iter->vtbl_idx);
   149 
   150 			// This should _never_ happen.
   151 			// If there is a hook from an other plugin, the plugin must have provided a hook manager as well.
   152 			SH_ASSERT(newHookMan != m_HookMans.end(),
   153 				"Could not find a suitable hook manager in an other plugin!");
   154 
   155 			// AddHook should make sure that every plugin only has _one_ hook manager for _one_ proto/vi/vo
   156 			SH_ASSERT(newHookMan->plug != plug, "New hook manager from same plugin!");
   157 
   158 			// The first hook manager should be always used - so the new hook manager has to be empty
   159 			SH_ASSERT(newHookMan->vfnptrs.empty(), "New hook manager not empty!");
   160 
   161 			// Move the vfnptrs from the old hook manager to the new one
   162 			newHookMan->vfnptrs = hmil_iter->vfnptrs;
   163 
   164 			// Unregister the old one, register the new one
   165 			hmil_iter->func(HA_Unregister, NULL);
   166 			newHookMan->func(HA_Register, &(*newHookMan));
   167 
   168 			// zOMG BAIL, here is part of what you wanted:
   169 
   170 			// Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
   171 			// or whatever
   172 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = newHookMan->vfnptrs.begin();
   173 				vfnptr_iter != newHookMan->vfnptrs.end(); ++vfnptr_iter)
   174 			{
   175 				// And DEREFERENCE newHookMan->hookfunc_vfnptr!
   176 				// otherwise it will be executing the vtable... had to find out the hard way
   177 				*reinterpret_cast<void**>(vfnptr_iter->vfnptr) = *reinterpret_cast<void**>(newHookMan->hookfunc_vfnptr);
   178 			}
   179 
   180 			// That should fix it, bail!
   181 		}
   182 	}
   183 
   184 	void CSourceHookImpl::CompleteShutdown()
   185 	{
   186 		List<RemoveHookInfo> hookstoremove;
   187 #define TMP_CHECK_LIST(name, ispost) \
   188 	for (hook_iter = iface_iter->name.begin(); hook_iter != iface_iter->name.end(); ++hook_iter) \
   189 		hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->ptr, \
   190 		hook_iter->thisptr_offs, hmil_iter->func, hook_iter->handler, ispost))
   191 		for (HookManInfoList::iterator hmil_iter = m_HookMans.begin(); hmil_iter != m_HookMans.end(); ++hmil_iter)
   192 		{
   193 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->vfnptrs.begin();
   194 				vfnptr_iter != hmil_iter->vfnptrs.end(); ++vfnptr_iter)
   195 			{
   196 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   197 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
   198 				{
   199 					List<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hook_iter;
   200 					TMP_CHECK_LIST(hooks_pre, false);
   201 					TMP_CHECK_LIST(hooks_post, true);
   202 				}
   203 			}
   204 		}
   205 #undef TMP_CHECK_LIST
   206 
   207 		for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   208 			RemoveHook(*rmiter);
   209 
   210 		m_HookMans.clear();
   211 	}
   212 
   213 	bool CSourceHookImpl::AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   214 	{
   215 		void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
   216 		// 1) Get info about the hook manager
   217 		HookManagerInfo tmp;
   218 		if (myHookMan(HA_GetInfo, &tmp) != 0)
   219 			return false;
   220 
   221 		// Add the proposed hook manager to the _end_ of the list if the plugin doesn't have a hook manager with this proto/vo/vi registered
   222 		HookManInfoList::iterator hkmi_iter;
   223 		for (hkmi_iter = m_HookMans.begin(); hkmi_iter != m_HookMans.end(); ++hkmi_iter)
   224 		{
   225 			if (hkmi_iter->plug == plug && strcmp(hkmi_iter->proto, tmp.proto) == 0 &&
   226 				hkmi_iter->vtbl_offs == tmp.vtbl_offs && hkmi_iter->vtbl_idx == tmp.vtbl_idx)
   227 				break;
   228 		}
   229 		if (hkmi_iter == m_HookMans.end())
   230 		{
   231 			// No such hook manager from this plugin yet, add it!
   232 			tmp.func = myHookMan;
   233 			tmp.plug = plug;
   234 			m_HookMans.push_back(tmp);
   235 		}
   236 
   237 		// Then, search for a suitable hook manager (from the beginning)
   238 		HookManInfoList::iterator hookman = FindHookMan(m_HookMans.begin(), m_HookMans.end(), tmp.proto, tmp.vtbl_offs, tmp.vtbl_idx);
   239 		SH_ASSERT(hookman != m_HookMans.end(), "No hookman found - but if there was none, we've just added one!");
   240 
   241 		// Tell it to store the pointer if it's not already active
   242 		if (hookman->vfnptrs.empty())
   243 			hookman->func(HA_Register, &(*hookman));
   244 
   245 		void **cur_vtptr = *reinterpret_cast<void***>(
   246 			reinterpret_cast<char*>(adjustediface) + tmp.vtbl_offs);
   247 		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.vtbl_idx);
   248 
   249 		HookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->vfnptrs.find(cur_vfnptr);
   250 
   251 		if (vfnptr_iter == hookman->vfnptrs.end())
   252 		{
   253 			// Add a new one
   254 			HookManagerInfo::VfnPtr vfp;
   255 			vfp.vfnptr = cur_vfnptr;
   256 			vfp.orig_entry = *reinterpret_cast<void**>(cur_vfnptr);
   257 
   258 			// Alter vtable entry
   259 			if (!SetMemAccess(cur_vtptr, sizeof(void*) * (tmp.vtbl_idx + 1), SH_MEM_READ | SH_MEM_WRITE))
   260 				return false;
   261 			
   262 			*reinterpret_cast<void**>(cur_vfnptr) = *reinterpret_cast<void**>(hookman->hookfunc_vfnptr);
   263 
   264 			hookman->vfnptrs.push_back(vfp);
   265 			
   266 			// Make vfnptr_iter point to the new element
   267 			vfnptr_iter = hookman->vfnptrs.end();
   268 			--vfnptr_iter;
   269 
   270 			// Now that it is done, check whether we have to update any callclasses
   271 			ApplyCallClassPatches(adjustediface, tmp.vtbl_offs, tmp.vtbl_idx, vfp.orig_entry);
   272 		}
   273 
   274 		HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.find(adjustediface);
   275 		if (iface_iter == vfnptr_iter->ifaces.end())
   276 		{
   277 			// Add a new one
   278 			HookManagerInfo::VfnPtr::Iface ifs;
   279 			ifs.ptr = adjustediface;
   280 			vfnptr_iter->ifaces.push_back(ifs);
   281 
   282 			// Make iface_iter point to the new element
   283 			iface_iter = vfnptr_iter->ifaces.end();
   284 			--iface_iter;
   285 		}
   286 
   287 		// Add the hook
   288 		HookManagerInfo::VfnPtr::Iface::Hook hookinfo;
   289 		hookinfo.handler = handler;
   290 		hookinfo.plug = plug;
   291 		hookinfo.paused = false;
   292 		hookinfo.thisptr_offs = thisptr_offs;
   293 		if (post)
   294    			iface_iter->hooks_post.push_back(hookinfo);
   295 		else
   296 			iface_iter->hooks_pre.push_back(hookinfo);
   297 
   298 
   299 		return true;
   300 	}
   301 
   302 	bool CSourceHookImpl::RemoveHook(RemoveHookInfo info)
   303 	{
   304 		return RemoveHook(info.plug, info.iface, info.thisptr_offs, info.hookman, info.handler, info.post);
   305 	}
   306 
   307 	bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   308 	{
   309 		void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
   310 		HookManagerInfo tmp;
   311 		if (myHookMan(HA_GetInfo, &tmp) != 0)
   312 			return false;
   313 
   314 		// Find the hook manager and the hook
   315 		HookManInfoList::iterator hookman = FindHookMan(m_HookMans.begin(), m_HookMans.end(), 
   316 			tmp.proto, tmp.vtbl_offs, tmp.vtbl_idx);
   317 		if (hookman == m_HookMans.end())
   318 			return false;
   319 
   320 		if (IsBadReadPtr(reinterpret_cast<char*>(adjustediface) + tmp.vtbl_offs, sizeof(char)))
   321 		{
   322 			hookman->vfnptrs.clear();
   323 			hookman->func(HA_Unregister, NULL);
   324 			return true;
   325 		}
   326 
   327 		void **cur_vtptr = *reinterpret_cast<void***>(
   328 			reinterpret_cast<char*>(adjustediface) + tmp.vtbl_offs);
   329 		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.vtbl_idx);
   330 
   331 		HookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->vfnptrs.find(cur_vfnptr);
   332 
   333 		if (vfnptr_iter == hookman->vfnptrs.end())
   334 			return false;
   335 
   336 		for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   337 			iface_iter != vfnptr_iter->ifaces.end();)
   338 		{
   339 			List<HookManagerInfo::VfnPtr::Iface::Hook> &hooks =
   340 				post ? iface_iter->hooks_post : iface_iter->hooks_pre;
   341 
   342 			bool erase;
   343 			for (List<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = hooks.begin();
   344 				hookiter != hooks.end(); erase ? hookiter = hooks.erase(hookiter) : ++hookiter)
   345 			{
   346 				erase = hookiter->plug == plug && hookiter->handler->IsEqual(handler) &&
   347 					hookiter->thisptr_offs == thisptr_offs;
   348 				if (erase)
   349 					hookiter->handler->DeleteThis();			// Make the _plugin_ delete the handler object
   350 			}
   351 			if (iface_iter->hooks_post.empty() && iface_iter->hooks_pre.empty())
   352 			{
   353 				iface_iter = vfnptr_iter->ifaces.erase(iface_iter);
   354 				if (vfnptr_iter->ifaces.empty())
   355 				{
   356 					// Deactivate the hook
   357 					*reinterpret_cast<void**>(vfnptr_iter->vfnptr) = vfnptr_iter->orig_entry;
   358 					
   359 					hookman->vfnptrs.erase(vfnptr_iter);
   360 
   361 					// Remove callclass patch
   362 					for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   363 						if (cciter->cc.ptr == adjustediface)
   364 							RemoveCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx);
   365 
   366 					if (hookman->vfnptrs.empty())
   367 					{
   368 						// Unregister the hook manager
   369 						hookman->func(HA_Unregister, NULL);
   370 					}
   371 
   372 					// Don't try to continue looping through ifaces
   373 					// - the list is already invalid
   374 					return true;
   375 				}
   376 			}
   377 			else
   378 				++iface_iter;
   379 		}
   380 		return true;
   381 	}
   382 
   383 	GenericCallClass *CSourceHookImpl::GetCallClass(void *iface, size_t size)
   384 	{
   385 		for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   386 		{
   387 			if (cciter->cc.ptr == iface && cciter->cc.objsize == size)
   388 			{
   389 				++cciter->refcounter;
   390 				return &cciter->cc;
   391 			}
   392 		}
   393 
   394 		CallClassInfo tmp;
   395 		tmp.refcounter = 1;
   396 		tmp.cc.ptr = iface;
   397 		tmp.cc.objsize = size;
   398 
   399 		ApplyCallClassPatches(tmp);
   400 
   401 		m_CallClasses.push_back(tmp);
   402 		return &m_CallClasses.back().cc;
   403 	}
   404 
   405 	void CSourceHookImpl::ReleaseCallClass(GenericCallClass *ptr)
   406 	{
   407 		Impl_CallClassList::iterator iter = m_CallClasses.find(ptr);
   408 		if (iter == m_CallClasses.end())
   409 			return;
   410 		--iter->refcounter;
   411 		if (iter->refcounter < 1)
   412 			m_CallClasses.erase(iter);
   413 	}
   414 
   415 	void CSourceHookImpl::ApplyCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx, void *orig_entry)
   416 	{
   417 		OrigFuncs &tmpvec = cc.cc.vt[vtbl_offs];
   418 		if (tmpvec.size() <= (size_t)vtbl_idx)
   419 			tmpvec.resize(vtbl_idx+1);
   420 		tmpvec[vtbl_idx] = orig_entry;
   421 	}
   422 
   423 	void CSourceHookImpl::ApplyCallClassPatches(CallClassInfo &cc)
   424 	{
   425 		for (HookManInfoList::iterator hookman = m_HookMans.begin(); hookman != m_HookMans.end(); ++hookman)
   426 		{
   427 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->vfnptrs.begin();
   428 				vfnptr_iter != hookman->vfnptrs.end(); ++vfnptr_iter)
   429 			{
   430 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   431 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
   432 				{
   433 					if (iface_iter->ptr >= cc.cc.ptr &&
   434 						iface_iter->ptr < (reinterpret_cast<char*>(cc.cc.ptr) + cc.cc.objsize))
   435 					{
   436 						ApplyCallClassPatch(cc, static_cast<int>(reinterpret_cast<char*>(iface_iter->ptr) - 
   437 							reinterpret_cast<char*>(cc.cc.ptr)) + hookman->vtbl_offs,
   438 							hookman->vtbl_idx, vfnptr_iter->orig_entry);
   439 					}
   440 				}
   441 			}
   442 		}
   443 	}
   444 
   445 	void CSourceHookImpl::ApplyCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx, void *orig_entry)
   446 	{
   447 		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
   448 			++cc_iter)
   449 		{
   450 			if (ifaceptr >= cc_iter->cc.ptr &&
   451 				ifaceptr < (reinterpret_cast<char*>(cc_iter->cc.ptr) + cc_iter->cc.objsize))
   452 			{
   453 				ApplyCallClassPatch(*cc_iter, static_cast<int>(reinterpret_cast<char*>(ifaceptr) - 
   454 					reinterpret_cast<char*>(cc_iter->cc.ptr)) + vtbl_offs, vtbl_idx, orig_entry);
   455 			}
   456 		}
   457 	}
   458 
   459 	void CSourceHookImpl::RemoveCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx)
   460 	{
   461 		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
   462 			++cc_iter)
   463 		{
   464 			if (ifaceptr >= cc_iter->cc.ptr &&
   465 				ifaceptr < (reinterpret_cast<char*>(cc_iter->cc.ptr) + cc_iter->cc.objsize))
   466 			{
   467 				RemoveCallClassPatch(*cc_iter, vtbl_offs, vtbl_idx);
   468 			}
   469 		}
   470 	}
   471 
   472 	void CSourceHookImpl::RemoveCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx)
   473 	{
   474 		OrigVTables::iterator iter = cc.cc.vt.find(vtbl_offs);
   475 		if (iter != cc.cc.vt.end())
   476 		{
   477 			if (iter->val.size() > (size_t)vtbl_idx)
   478 			{
   479 				iter->val[vtbl_idx] = 0;
   480 				// Free some memory if possible
   481 				// :TODO: add this back in!
   482 				/*
   483 				OrigFuncs::reverse_iterator riter;
   484 				for (riter = iter->second.rbegin(); riter != iter->second.rend(); ++riter)
   485 				{
   486 					if (*riter != 0)
   487 						break;
   488 				}
   489 				iter->second.resize(iter->second.size() - (riter - iter->second.rbegin()));
   490 				if (!iter->second.size())
   491 					cc.cc.vt.erase(iter);*/
   492 			}
   493 		}
   494 	}
   495 
   496 	CSourceHookImpl::HookManInfoList::iterator CSourceHookImpl::FindHookMan(HookManInfoList::iterator begin,
   497 		HookManInfoList::iterator end, const char *proto, int vtblofs, int vtblidx)
   498 	{
   499 		HookManInfoList::iterator hookmaniter; 
   500 		for (hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   501 		{
   502 			if (strcmp(hookmaniter->proto, proto) == 0 && hookmaniter->vtbl_offs == vtblofs &&
   503 				hookmaniter->vtbl_idx == vtblidx)
   504 				break;
   505 		}
   506 		return hookmaniter;
   507 	}
   508 
   509 	void CSourceHookImpl::PausePlugin(Plugin plug)
   510 	{
   511 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   512 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   513 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   514 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   515 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   516 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   517 				{
   518 					for (List<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   519 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   520 						if (plug == hookiter->plug)
   521 							hookiter->paused = true;
   522 
   523 					for (List<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   524 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   525 						if (plug == hookiter->plug)
   526 							hookiter->paused = true;
   527 				}
   528 	}
   529 
   530 	void CSourceHookImpl::UnpausePlugin(Plugin plug)
   531 	{
   532 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   533 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   534 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   535 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   536 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   537 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   538 				{
   539 					for (List<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   540 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   541 						if (plug == hookiter->plug)
   542 							hookiter->paused = false;
   543 
   544 					for (List<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   545 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   546 						if (plug == hookiter->plug)
   547 							hookiter->paused = false;
   548 				}
   549 	}
   550 
   551 	void CSourceHookImpl::SetRes(META_RES res)
   552 	{
   553 		m_CurRes = res;
   554 	}
   555 
   556 	META_RES CSourceHookImpl::GetPrevRes()
   557 	{
   558 		return m_PrevRes;
   559 	}
   560 
   561 	META_RES CSourceHookImpl::GetStatus()
   562 	{
   563 		return m_Status;
   564 	}
   565 
   566 	const void *CSourceHookImpl::GetOrigRet()
   567 	{
   568 		return m_OrigRet;
   569 	}
   570 
   571 	const void *CSourceHookImpl::GetOverrideRet()
   572 	{
   573 		return m_OverrideRet;
   574 	}
   575 
   576 	META_RES &CSourceHookImpl::GetCurResRef()
   577 	{
   578 		return m_CurRes;
   579 	}
   580 
   581 	META_RES &CSourceHookImpl::GetPrevResRef()
   582 	{
   583 		return m_PrevRes;
   584 	}
   585 
   586 	META_RES &CSourceHookImpl::GetStatusRef()
   587 	{
   588 		return m_Status;
   589 	}
   590 
   591 	void * &CSourceHookImpl::GetIfacePtrRef()
   592 	{
   593 		return m_IfacePtr;
   594 	}
   595 
   596 	void CSourceHookImpl::SetOrigRet(const void *ptr)
   597 	{
   598 		m_OrigRet = ptr;
   599 	}
   600 
   601 	void CSourceHookImpl::SetOverrideRet(const void *ptr)
   602 	{
   603 		m_OverrideRet = ptr;
   604 	}
   605 
   606 	void *CSourceHookImpl::GetIfacePtr()
   607 	{
   608 		return m_IfacePtr;
   609 	}
   610 
   611 #ifdef __linux__
   612 	bool g_BadReadCalled;
   613 	jmp_buf g_BadReadJmpBuf;
   614 
   615 	// Windows has an implementation for this already, but Linux does not :(
   616 	bool IsBadReadPtr(const void *ptr, size_t len)
   617 	{
   618 		void(*prevHandler)(int sig);
   619 		g_BadReadCalled = true;
   620 
   621 		if (setjmp(g_BadReadJmpBuf))
   622 			return true;
   623 
   624 		prevHandler = signal(SIGSEGV, BadReadHandler);
   625 
   626 		volatile const char *p = reinterpret_cast<const char*>(ptr);
   627 		char dummy;
   628 
   629 		for (size_t i = 0; i < len; i++)
   630 			dummy = p[i];
   631 
   632 		g_BadReadCalled = false;
   633 
   634 		signal(SIGSEGV, prevHandler);
   635 
   636 		return false;
   637 	}
   638 
   639 	void BadReadHandler(int sig)
   640 	{
   641 		if (g_BadReadCalled)
   642 			longjmp(g_BadReadJmpBuf, 1);
   643 	}
   644 #endif
   645 }