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