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