sourcehook/sourcehook.cpp
author Pavol Marko <pavolmarko@gmail.com>
Thu May 05 10:40:47 2005 +0000 (2005-05-05)
changeset 58 71016f952503
parent 50 4b6bbaf375dc
child 83 b41900c40742
permissions -rw-r--r--
Added code for proper handling of thisptr adjustors, added new test, version info, more options for GetFuncInfo
     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 * ============================
     9 */
    10 
    11 /**
    12  * @file sourcehook.cpp
    13  * @brief Contains the implementation of the SourceHook API
    14 */
    15 
    16 #include <algorithm>
    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 					std::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 		std::list<RemoveHookInfo> hookstoremove;
    74 #define TMP_CHECK_LIST(name, ispost) \
    75 	for (hook_iter = iface_iter->name.begin(); hook_iter != iface_iter->name.end(); ++hook_iter) \
    76 		if (hook_iter->plug == plug) \
    77 			hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->ptr, \
    78 			hook_iter->thisptr_offs, hmil_iter->func, hook_iter->handler, ispost))
    79 		for (HookManInfoList::iterator hmil_iter = m_HookMans.begin(); hmil_iter != m_HookMans.end(); ++hmil_iter)
    80 		{
    81 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->vfnptrs.begin();
    82 				vfnptr_iter != hmil_iter->vfnptrs.end(); ++vfnptr_iter)
    83 			{
    84 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
    85 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
    86 				{
    87 					std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hook_iter;
    88 					TMP_CHECK_LIST(hooks_pre, false);
    89 					TMP_CHECK_LIST(hooks_post, true);
    90 				}
    91 			}
    92 		}
    93 #undef TMP_CHECK_LIST
    94 
    95 		for (std::list<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
    96 			RemoveHook(*rmiter);
    97 
    98 		// 2) Other plugins may use hook managers in this plugin.
    99 		// Get a list of hook managers that are in this plugin and are used by other plugins
   100 		// Delete all hook managers that are in this plugin
   101 
   102 		HookManInfoList tmphookmans;
   103 		bool erase = false;
   104 		for (HookManInfoList::iterator hmil_iter = m_HookMans.begin(); hmil_iter != m_HookMans.end();
   105 			erase ? hmil_iter=m_HookMans.erase(hmil_iter) : ++hmil_iter)
   106 		{
   107 			if (hmil_iter->plug == plug)
   108 			{
   109 				if (!hmil_iter->vfnptrs.empty())
   110 				{
   111 					// All hooks by this plugin are already removed
   112 					// So if there is a vfnptr, it has to be used by an other plugin
   113 					tmphookmans.push_back(*hmil_iter);
   114 				}
   115 				erase = true;
   116 			}
   117 			else
   118 				erase = false;
   119 		}
   120 		
   121 		// For each hook manager:
   122 		for (HookManInfoList::iterator hmil_iter = tmphookmans.begin(); hmil_iter != tmphookmans.end(); ++hmil_iter)
   123 		{
   124 			// Find a suitable hook manager in an other plugin
   125 			HookManInfoList::iterator newHookMan = FindHookMan(m_HookMans.begin(), m_HookMans.end(),
   126 				hmil_iter->proto, hmil_iter->vtbl_offs, hmil_iter->vtbl_idx);
   127 
   128 			// This should _never_ happen.
   129 			// If there is a hook from an other plugin, the plugin must have provided a hook manager as well.
   130 			SH_ASSERT(newHookMan != m_HookMans.end(),
   131 				"Could not find a suitable hook manager in an other plugin!");
   132 
   133 			// AddHook should make sure that every plugin only has _one_ hook manager for _one_ proto/vi/vo
   134 			SH_ASSERT(newHookMan->plug != plug, "New hook manager from same plugin!");
   135 
   136 			// The first hook manager should be always used - so the new hook manager has to be empty
   137 			SH_ASSERT(newHookMan->vfnptrs.empty(), "New hook manager not empty!");
   138 
   139 			// Move the vfnptrs from the old hook manager to the new one
   140 			newHookMan->vfnptrs = hmil_iter->vfnptrs;
   141 
   142 			// Unregister the old one, register the new one
   143 			hmil_iter->func(HA_Unregister, NULL);
   144 			newHookMan->func(HA_Register, &(*newHookMan));
   145 		}
   146 	}
   147 
   148 	void CSourceHookImpl::CompleteShutdown()
   149 	{
   150 		std::list<RemoveHookInfo> hookstoremove;
   151 #define TMP_CHECK_LIST(name, ispost) \
   152 	for (hook_iter = iface_iter->name.begin(); hook_iter != iface_iter->name.end(); ++hook_iter) \
   153 		hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->ptr, \
   154 		hook_iter->thisptr_offs, hmil_iter->func, hook_iter->handler, ispost))
   155 		for (HookManInfoList::iterator hmil_iter = m_HookMans.begin(); hmil_iter != m_HookMans.end(); ++hmil_iter)
   156 		{
   157 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->vfnptrs.begin();
   158 				vfnptr_iter != hmil_iter->vfnptrs.end(); ++vfnptr_iter)
   159 			{
   160 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   161 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
   162 				{
   163 					std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hook_iter;
   164 					TMP_CHECK_LIST(hooks_pre, false);
   165 					TMP_CHECK_LIST(hooks_post, true);
   166 				}
   167 			}
   168 		}
   169 #undef TMP_CHECK_LIST
   170 
   171 		for (std::list<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   172 			RemoveHook(*rmiter);
   173 
   174 		m_HookMans.clear();
   175 	}
   176 
   177 	bool CSourceHookImpl::AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   178 	{
   179 		void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
   180 		// 1) Get info about the hook manager
   181 		HookManagerInfo tmp;
   182 		if (myHookMan(HA_GetInfo, &tmp) != 0)
   183 			return false;
   184 
   185 		// 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
   186 		HookManInfoList::iterator hkmi_iter;
   187 		for (hkmi_iter = m_HookMans.begin(); hkmi_iter != m_HookMans.end(); ++hkmi_iter)
   188 		{
   189 			if (hkmi_iter->plug == plug && strcmp(hkmi_iter->proto, tmp.proto) == 0 &&
   190 				hkmi_iter->vtbl_offs == tmp.vtbl_offs && hkmi_iter->vtbl_idx == tmp.vtbl_idx)
   191 				break;
   192 		}
   193 		if (hkmi_iter == m_HookMans.end())
   194 		{
   195 			// No such hook manager from this plugin yet, add it!
   196 			tmp.func = myHookMan;
   197 			tmp.plug = plug;
   198 			m_HookMans.push_back(tmp);
   199 		}
   200 
   201 		// Then, search for a suitable hook manager (from the beginning)
   202 		HookManInfoList::iterator hookman = FindHookMan(m_HookMans.begin(), m_HookMans.end(), tmp.proto, tmp.vtbl_offs, tmp.vtbl_idx);
   203 		SH_ASSERT(hookman != m_HookMans.end(), "No hookman found - but if there was none, we've just added one!");
   204 
   205 		// Tell it to store the pointer if it's not already active
   206 		if (hookman->vfnptrs.empty())
   207 			hookman->func(HA_Register, &(*hookman));
   208 
   209 		void **cur_vtptr = *reinterpret_cast<void***>(
   210 			reinterpret_cast<char*>(adjustediface) + tmp.vtbl_offs);
   211 		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.vtbl_idx);
   212 
   213 		HookManagerInfo::VfnPtrListIter vfnptr_iter = std::find(
   214 			hookman->vfnptrs.begin(), hookman->vfnptrs.end(), cur_vfnptr);
   215 
   216 		if (vfnptr_iter == hookman->vfnptrs.end())
   217 		{
   218 			// Add a new one
   219 			HookManagerInfo::VfnPtr vfp;
   220 			vfp.vfnptr = cur_vfnptr;
   221 			vfp.orig_entry = *reinterpret_cast<void**>(cur_vfnptr);
   222 
   223 			// Alter vtable entry
   224 			if (!SetMemAccess(cur_vtptr, sizeof(void*) * (tmp.vtbl_idx + 1), SH_MEM_READ | SH_MEM_WRITE))
   225 				return false;
   226 			
   227 			*reinterpret_cast<void**>(cur_vfnptr) = *reinterpret_cast<void**>(hookman->hookfunc_vfnptr);
   228 
   229 			hookman->vfnptrs.push_back(vfp);
   230 			
   231 			// Make vfnptr_iter point to the new element
   232 			vfnptr_iter = hookman->vfnptrs.end();
   233 			--vfnptr_iter;
   234 
   235 			// Now that it is done, check whether we have to update any callclasses
   236 			ApplyCallClassPatches(adjustediface, tmp.vtbl_offs, tmp.vtbl_idx, vfp.orig_entry);
   237 		}
   238 
   239 		HookManagerInfo::VfnPtr::IfaceListIter iface_iter = std::find(
   240 			vfnptr_iter->ifaces.begin(), vfnptr_iter->ifaces.end(), adjustediface);
   241 		if (iface_iter == vfnptr_iter->ifaces.end())
   242 		{
   243 			// Add a new one
   244 			HookManagerInfo::VfnPtr::Iface ifs;
   245 			ifs.ptr = adjustediface;
   246 			vfnptr_iter->ifaces.push_back(ifs);
   247 
   248 			// Make iface_iter point to the new element
   249 			iface_iter = vfnptr_iter->ifaces.end();
   250 			--iface_iter;
   251 		}
   252 
   253 		// Add the hook
   254 		HookManagerInfo::VfnPtr::Iface::Hook hookinfo;
   255 		hookinfo.handler = handler;
   256 		hookinfo.plug = plug;
   257 		hookinfo.paused = false;
   258 		hookinfo.thisptr_offs = thisptr_offs;
   259 		if (post)
   260    			iface_iter->hooks_post.push_back(hookinfo);
   261 		else
   262 			iface_iter->hooks_pre.push_back(hookinfo);
   263 
   264 
   265 		return true;
   266 	}
   267 
   268 	bool CSourceHookImpl::RemoveHook(RemoveHookInfo info)
   269 	{
   270 		return RemoveHook(info.plug, info.iface, info.thisptr_offs, info.hookman, info.handler, info.post);
   271 	}
   272 
   273 	bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   274 	{
   275 		void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
   276 		HookManagerInfo tmp;
   277 		if (myHookMan(HA_GetInfo, &tmp) != 0)
   278 			return false;
   279 
   280 		// Find the hook manager and the hook
   281 		HookManInfoList::iterator hookman = FindHookMan(m_HookMans.begin(), m_HookMans.end(), 
   282 			tmp.proto, tmp.vtbl_offs, tmp.vtbl_idx);
   283 		if (hookman == m_HookMans.end())
   284 			return false;
   285 
   286 		void **cur_vtptr = *reinterpret_cast<void***>(
   287 			reinterpret_cast<char*>(adjustediface) + tmp.vtbl_offs);
   288 		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.vtbl_idx);
   289 
   290 		HookManagerInfo::VfnPtrListIter vfnptr_iter = std::find(hookman->vfnptrs.begin(), hookman->vfnptrs.end(), cur_vfnptr);
   291 		if (vfnptr_iter == hookman->vfnptrs.end())
   292 			return false;
   293 
   294 		for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   295 			iface_iter != vfnptr_iter->ifaces.end();)
   296 		{
   297 			std::list<HookManagerInfo::VfnPtr::Iface::Hook> &hooks =
   298 				post ? iface_iter->hooks_post : iface_iter->hooks_pre;
   299 
   300 			bool erase;
   301 			for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = hooks.begin();
   302 				hookiter != hooks.end(); erase ? hookiter = hooks.erase(hookiter) : ++hookiter)
   303 			{
   304 				erase = hookiter->plug == plug && hookiter->handler->IsEqual(handler) &&
   305 					hookiter->thisptr_offs == thisptr_offs;
   306 				if (erase)
   307 					hookiter->handler->DeleteThis();			// Make the _plugin_ delete the handler object
   308 			}
   309 			if (iface_iter->hooks_post.empty() && iface_iter->hooks_pre.empty())
   310 			{
   311 				iface_iter = vfnptr_iter->ifaces.erase(iface_iter);
   312 				if (vfnptr_iter->ifaces.empty())
   313 				{
   314 					// Deactivate the hook
   315 					*reinterpret_cast<void**>(vfnptr_iter->vfnptr) = vfnptr_iter->orig_entry;
   316 					
   317 					hookman->vfnptrs.erase(vfnptr_iter);
   318 
   319 					// Remove callclass patch
   320 					for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   321 						if (cciter->cc.ptr == adjustediface)
   322 							RemoveCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx);
   323 
   324 					if (hookman->vfnptrs.empty())
   325 					{
   326 						// Unregister the hook manager
   327 						hookman->func(HA_Unregister, NULL);
   328 					}
   329 
   330 					// Don't try to continue looping through ifaces
   331 					// - the list is already invalid
   332 					return true;
   333 				}
   334 			}
   335 			else
   336 				++iface_iter;
   337 		}
   338 		return true;
   339 	}
   340 
   341 	GenericCallClass *CSourceHookImpl::GetCallClass(void *iface, size_t size)
   342 	{
   343 		for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   344 		{
   345 			if (cciter->cc.ptr == iface && cciter->cc.objsize == size)
   346 			{
   347 				++cciter->refcounter;
   348 				return &cciter->cc;
   349 			}
   350 		}
   351 
   352 		CallClassInfo tmp;
   353 		tmp.refcounter = 1;
   354 		tmp.cc.ptr = iface;
   355 		tmp.cc.objsize = size;
   356 
   357 		ApplyCallClassPatches(tmp);
   358 
   359 		m_CallClasses.push_back(tmp);
   360 		return &m_CallClasses.back().cc;
   361 	}
   362 
   363 	void CSourceHookImpl::ReleaseCallClass(GenericCallClass *ptr)
   364 	{
   365 		Impl_CallClassList::iterator iter = std::find(m_CallClasses.begin(), m_CallClasses.end(), ptr);
   366 		if (iter == m_CallClasses.end())
   367 			return;
   368 		--iter->refcounter;
   369 		if (iter->refcounter < 1)
   370 			m_CallClasses.erase(iter);
   371 	}
   372 
   373 	void CSourceHookImpl::ApplyCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx, void *orig_entry)
   374 	{
   375 		OrigFuncs &tmpvec = cc.cc.vt[vtbl_offs];
   376 		if (tmpvec.size() <= (size_t)vtbl_idx)
   377 			tmpvec.resize(vtbl_idx+1);
   378 		tmpvec[vtbl_idx] = orig_entry;
   379 	}
   380 
   381 	void CSourceHookImpl::ApplyCallClassPatches(CallClassInfo &cc)
   382 	{
   383 		for (HookManInfoList::iterator hookman = m_HookMans.begin(); hookman != m_HookMans.end(); ++hookman)
   384 		{
   385 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->vfnptrs.begin();
   386 				vfnptr_iter != hookman->vfnptrs.end(); ++vfnptr_iter)
   387 			{
   388 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   389 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
   390 				{
   391 					if (iface_iter->ptr >= cc.cc.ptr &&
   392 						iface_iter->ptr < (reinterpret_cast<char*>(cc.cc.ptr) + cc.cc.objsize))
   393 					{
   394 						ApplyCallClassPatch(cc, static_cast<int>(reinterpret_cast<char*>(iface_iter->ptr) - 
   395 							reinterpret_cast<char*>(cc.cc.ptr)) + hookman->vtbl_offs,
   396 							hookman->vtbl_idx, vfnptr_iter->orig_entry);
   397 					}
   398 				}
   399 			}
   400 		}
   401 	}
   402 
   403 	void CSourceHookImpl::ApplyCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx, void *orig_entry)
   404 	{
   405 		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
   406 			++cc_iter)
   407 		{
   408 			if (ifaceptr >= cc_iter->cc.ptr &&
   409 				ifaceptr < (reinterpret_cast<char*>(cc_iter->cc.ptr) + cc_iter->cc.objsize))
   410 			{
   411 				ApplyCallClassPatch(*cc_iter, static_cast<int>(reinterpret_cast<char*>(ifaceptr) - 
   412 					reinterpret_cast<char*>(cc_iter->cc.ptr)) + vtbl_offs, vtbl_idx, orig_entry);
   413 			}
   414 		}
   415 	}
   416 
   417 	void CSourceHookImpl::RemoveCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx)
   418 	{
   419 		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
   420 			++cc_iter)
   421 		{
   422 			if (ifaceptr >= cc_iter->cc.ptr &&
   423 				ifaceptr < (reinterpret_cast<char*>(cc_iter->cc.ptr) + cc_iter->cc.objsize))
   424 			{
   425 				RemoveCallClassPatch(*cc_iter, vtbl_offs, vtbl_idx);
   426 			}
   427 		}
   428 	}
   429 
   430 	void CSourceHookImpl::RemoveCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx)
   431 	{
   432 		OrigVTables::iterator iter = cc.cc.vt.find(vtbl_offs);
   433 		if (iter != cc.cc.vt.end())
   434 		{
   435 			if (iter->second.size() > (size_t)vtbl_idx)
   436 			{
   437 				iter->second[vtbl_idx] = 0;
   438 				// Free some memory if possible
   439 				OrigFuncs::reverse_iterator riter;
   440 				for (riter = iter->second.rbegin(); riter != iter->second.rend(); ++riter)
   441 				{
   442 					if (*riter != 0)
   443 						break;
   444 				}
   445 				iter->second.resize(iter->second.size() - (riter - iter->second.rbegin()));
   446 				if (!iter->second.size())
   447 					cc.cc.vt.erase(iter);
   448 			}
   449 		}
   450 	}
   451 
   452 	CSourceHookImpl::HookManInfoList::iterator CSourceHookImpl::FindHookMan(HookManInfoList::iterator begin,
   453 		HookManInfoList::iterator end, const char *proto, int vtblofs, int vtblidx)
   454 	{
   455 		HookManInfoList::iterator hookmaniter; 
   456 		for (hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   457 		{
   458 			if (strcmp(hookmaniter->proto, proto) == 0 && hookmaniter->vtbl_offs == vtblofs &&
   459 				hookmaniter->vtbl_idx == vtblidx)
   460 				break;
   461 		}
   462 		return hookmaniter;
   463 	}
   464 
   465 	void CSourceHookImpl::PausePlugin(Plugin plug)
   466 	{
   467 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   468 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   469 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   470 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   471 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   472 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   473 				{
   474 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   475 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   476 						if (plug == hookiter->plug)
   477 							hookiter->paused = true;
   478 
   479 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   480 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   481 						if (plug == hookiter->plug)
   482 							hookiter->paused = true;
   483 				}
   484 	}
   485 
   486 	void CSourceHookImpl::UnpausePlugin(Plugin plug)
   487 	{
   488 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   489 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   490 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   491 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   492 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   493 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   494 				{
   495 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   496 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   497 						if (plug == hookiter->plug)
   498 							hookiter->paused = false;
   499 
   500 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   501 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   502 						if (plug == hookiter->plug)
   503 							hookiter->paused = false;
   504 				}
   505 	}
   506 
   507 	void CSourceHookImpl::SetRes(META_RES res)
   508 	{
   509 		m_CurRes = res;
   510 	}
   511 
   512 	META_RES CSourceHookImpl::GetPrevRes()
   513 	{
   514 		return m_PrevRes;
   515 	}
   516 
   517 	META_RES CSourceHookImpl::GetStatus()
   518 	{
   519 		return m_Status;
   520 	}
   521 
   522 	const void *CSourceHookImpl::GetOrigRet()
   523 	{
   524 		return m_OrigRet;
   525 	}
   526 
   527 	const void *CSourceHookImpl::GetOverrideRet()
   528 	{
   529 		return m_OverrideRet;
   530 	}
   531 
   532 	META_RES &CSourceHookImpl::GetCurResRef()
   533 	{
   534 		return m_CurRes;
   535 	}
   536 
   537 	META_RES &CSourceHookImpl::GetPrevResRef()
   538 	{
   539 		return m_PrevRes;
   540 	}
   541 
   542 	META_RES &CSourceHookImpl::GetStatusRef()
   543 	{
   544 		return m_Status;
   545 	}
   546 
   547 	void * &CSourceHookImpl::GetIfacePtrRef()
   548 	{
   549 		return m_IfacePtr;
   550 	}
   551 
   552 	void CSourceHookImpl::SetOrigRet(const void *ptr)
   553 	{
   554 		m_OrigRet = ptr;
   555 	}
   556 
   557 	void CSourceHookImpl::SetOverrideRet(const void *ptr)
   558 	{
   559 		m_OverrideRet = ptr;
   560 	}
   561 
   562 	void *CSourceHookImpl::GetIfacePtr()
   563 	{
   564 		return m_IfacePtr;
   565 	}
   566 }