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