sourcehook/sourcehook.cpp
author Pavol Marko <pavolmarko@gmail.com>
Sat Jul 02 10:09:40 2005 +0000 (2005-07-02)
changeset 83 b41900c40742
parent 58 71016f952503
child 86 0c0c0ab2e9ba
permissions -rw-r--r--
Truly gone fishing... It's fixed!
     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 		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 					std::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 (std::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 		std::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 					std::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 (std::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 = std::find(
   230 			hookman->vfnptrs.begin(), hookman->vfnptrs.end(), cur_vfnptr);
   231 
   232 		if (vfnptr_iter == hookman->vfnptrs.end())
   233 		{
   234 			// Add a new one
   235 			HookManagerInfo::VfnPtr vfp;
   236 			vfp.vfnptr = cur_vfnptr;
   237 			vfp.orig_entry = *reinterpret_cast<void**>(cur_vfnptr);
   238 
   239 			// Alter vtable entry
   240 			if (!SetMemAccess(cur_vtptr, sizeof(void*) * (tmp.vtbl_idx + 1), SH_MEM_READ | SH_MEM_WRITE))
   241 				return false;
   242 			
   243 			*reinterpret_cast<void**>(cur_vfnptr) = *reinterpret_cast<void**>(hookman->hookfunc_vfnptr);
   244 
   245 			hookman->vfnptrs.push_back(vfp);
   246 			
   247 			// Make vfnptr_iter point to the new element
   248 			vfnptr_iter = hookman->vfnptrs.end();
   249 			--vfnptr_iter;
   250 
   251 			// Now that it is done, check whether we have to update any callclasses
   252 			ApplyCallClassPatches(adjustediface, tmp.vtbl_offs, tmp.vtbl_idx, vfp.orig_entry);
   253 		}
   254 
   255 		HookManagerInfo::VfnPtr::IfaceListIter iface_iter = std::find(
   256 			vfnptr_iter->ifaces.begin(), vfnptr_iter->ifaces.end(), adjustediface);
   257 		if (iface_iter == vfnptr_iter->ifaces.end())
   258 		{
   259 			// Add a new one
   260 			HookManagerInfo::VfnPtr::Iface ifs;
   261 			ifs.ptr = adjustediface;
   262 			vfnptr_iter->ifaces.push_back(ifs);
   263 
   264 			// Make iface_iter point to the new element
   265 			iface_iter = vfnptr_iter->ifaces.end();
   266 			--iface_iter;
   267 		}
   268 
   269 		// Add the hook
   270 		HookManagerInfo::VfnPtr::Iface::Hook hookinfo;
   271 		hookinfo.handler = handler;
   272 		hookinfo.plug = plug;
   273 		hookinfo.paused = false;
   274 		hookinfo.thisptr_offs = thisptr_offs;
   275 		if (post)
   276    			iface_iter->hooks_post.push_back(hookinfo);
   277 		else
   278 			iface_iter->hooks_pre.push_back(hookinfo);
   279 
   280 
   281 		return true;
   282 	}
   283 
   284 	bool CSourceHookImpl::RemoveHook(RemoveHookInfo info)
   285 	{
   286 		return RemoveHook(info.plug, info.iface, info.thisptr_offs, info.hookman, info.handler, info.post);
   287 	}
   288 
   289 	bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   290 	{
   291 		void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
   292 		HookManagerInfo tmp;
   293 		if (myHookMan(HA_GetInfo, &tmp) != 0)
   294 			return false;
   295 
   296 		// Find the hook manager and the hook
   297 		HookManInfoList::iterator hookman = FindHookMan(m_HookMans.begin(), m_HookMans.end(), 
   298 			tmp.proto, tmp.vtbl_offs, tmp.vtbl_idx);
   299 		if (hookman == m_HookMans.end())
   300 			return false;
   301 
   302 		void **cur_vtptr = *reinterpret_cast<void***>(
   303 			reinterpret_cast<char*>(adjustediface) + tmp.vtbl_offs);
   304 		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.vtbl_idx);
   305 
   306 		HookManagerInfo::VfnPtrListIter vfnptr_iter = std::find(hookman->vfnptrs.begin(), hookman->vfnptrs.end(), cur_vfnptr);
   307 		if (vfnptr_iter == hookman->vfnptrs.end())
   308 			return false;
   309 
   310 		for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   311 			iface_iter != vfnptr_iter->ifaces.end();)
   312 		{
   313 			std::list<HookManagerInfo::VfnPtr::Iface::Hook> &hooks =
   314 				post ? iface_iter->hooks_post : iface_iter->hooks_pre;
   315 
   316 			bool erase;
   317 			for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = hooks.begin();
   318 				hookiter != hooks.end(); erase ? hookiter = hooks.erase(hookiter) : ++hookiter)
   319 			{
   320 				erase = hookiter->plug == plug && hookiter->handler->IsEqual(handler) &&
   321 					hookiter->thisptr_offs == thisptr_offs;
   322 				if (erase)
   323 					hookiter->handler->DeleteThis();			// Make the _plugin_ delete the handler object
   324 			}
   325 			if (iface_iter->hooks_post.empty() && iface_iter->hooks_pre.empty())
   326 			{
   327 				iface_iter = vfnptr_iter->ifaces.erase(iface_iter);
   328 				if (vfnptr_iter->ifaces.empty())
   329 				{
   330 					// Deactivate the hook
   331 					*reinterpret_cast<void**>(vfnptr_iter->vfnptr) = vfnptr_iter->orig_entry;
   332 					
   333 					hookman->vfnptrs.erase(vfnptr_iter);
   334 
   335 					// Remove callclass patch
   336 					for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   337 						if (cciter->cc.ptr == adjustediface)
   338 							RemoveCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx);
   339 
   340 					if (hookman->vfnptrs.empty())
   341 					{
   342 						// Unregister the hook manager
   343 						hookman->func(HA_Unregister, NULL);
   344 					}
   345 
   346 					// Don't try to continue looping through ifaces
   347 					// - the list is already invalid
   348 					return true;
   349 				}
   350 			}
   351 			else
   352 				++iface_iter;
   353 		}
   354 		return true;
   355 	}
   356 
   357 	GenericCallClass *CSourceHookImpl::GetCallClass(void *iface, size_t size)
   358 	{
   359 		for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   360 		{
   361 			if (cciter->cc.ptr == iface && cciter->cc.objsize == size)
   362 			{
   363 				++cciter->refcounter;
   364 				return &cciter->cc;
   365 			}
   366 		}
   367 
   368 		CallClassInfo tmp;
   369 		tmp.refcounter = 1;
   370 		tmp.cc.ptr = iface;
   371 		tmp.cc.objsize = size;
   372 
   373 		ApplyCallClassPatches(tmp);
   374 
   375 		m_CallClasses.push_back(tmp);
   376 		return &m_CallClasses.back().cc;
   377 	}
   378 
   379 	void CSourceHookImpl::ReleaseCallClass(GenericCallClass *ptr)
   380 	{
   381 		Impl_CallClassList::iterator iter = std::find(m_CallClasses.begin(), m_CallClasses.end(), ptr);
   382 		if (iter == m_CallClasses.end())
   383 			return;
   384 		--iter->refcounter;
   385 		if (iter->refcounter < 1)
   386 			m_CallClasses.erase(iter);
   387 	}
   388 
   389 	void CSourceHookImpl::ApplyCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx, void *orig_entry)
   390 	{
   391 		OrigFuncs &tmpvec = cc.cc.vt[vtbl_offs];
   392 		if (tmpvec.size() <= (size_t)vtbl_idx)
   393 			tmpvec.resize(vtbl_idx+1);
   394 		tmpvec[vtbl_idx] = orig_entry;
   395 	}
   396 
   397 	void CSourceHookImpl::ApplyCallClassPatches(CallClassInfo &cc)
   398 	{
   399 		for (HookManInfoList::iterator hookman = m_HookMans.begin(); hookman != m_HookMans.end(); ++hookman)
   400 		{
   401 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->vfnptrs.begin();
   402 				vfnptr_iter != hookman->vfnptrs.end(); ++vfnptr_iter)
   403 			{
   404 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   405 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
   406 				{
   407 					if (iface_iter->ptr >= cc.cc.ptr &&
   408 						iface_iter->ptr < (reinterpret_cast<char*>(cc.cc.ptr) + cc.cc.objsize))
   409 					{
   410 						ApplyCallClassPatch(cc, static_cast<int>(reinterpret_cast<char*>(iface_iter->ptr) - 
   411 							reinterpret_cast<char*>(cc.cc.ptr)) + hookman->vtbl_offs,
   412 							hookman->vtbl_idx, vfnptr_iter->orig_entry);
   413 					}
   414 				}
   415 			}
   416 		}
   417 	}
   418 
   419 	void CSourceHookImpl::ApplyCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx, void *orig_entry)
   420 	{
   421 		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
   422 			++cc_iter)
   423 		{
   424 			if (ifaceptr >= cc_iter->cc.ptr &&
   425 				ifaceptr < (reinterpret_cast<char*>(cc_iter->cc.ptr) + cc_iter->cc.objsize))
   426 			{
   427 				ApplyCallClassPatch(*cc_iter, static_cast<int>(reinterpret_cast<char*>(ifaceptr) - 
   428 					reinterpret_cast<char*>(cc_iter->cc.ptr)) + vtbl_offs, vtbl_idx, orig_entry);
   429 			}
   430 		}
   431 	}
   432 
   433 	void CSourceHookImpl::RemoveCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx)
   434 	{
   435 		for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
   436 			++cc_iter)
   437 		{
   438 			if (ifaceptr >= cc_iter->cc.ptr &&
   439 				ifaceptr < (reinterpret_cast<char*>(cc_iter->cc.ptr) + cc_iter->cc.objsize))
   440 			{
   441 				RemoveCallClassPatch(*cc_iter, vtbl_offs, vtbl_idx);
   442 			}
   443 		}
   444 	}
   445 
   446 	void CSourceHookImpl::RemoveCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx)
   447 	{
   448 		OrigVTables::iterator iter = cc.cc.vt.find(vtbl_offs);
   449 		if (iter != cc.cc.vt.end())
   450 		{
   451 			if (iter->second.size() > (size_t)vtbl_idx)
   452 			{
   453 				iter->second[vtbl_idx] = 0;
   454 				// Free some memory if possible
   455 				OrigFuncs::reverse_iterator riter;
   456 				for (riter = iter->second.rbegin(); riter != iter->second.rend(); ++riter)
   457 				{
   458 					if (*riter != 0)
   459 						break;
   460 				}
   461 				iter->second.resize(iter->second.size() - (riter - iter->second.rbegin()));
   462 				if (!iter->second.size())
   463 					cc.cc.vt.erase(iter);
   464 			}
   465 		}
   466 	}
   467 
   468 	CSourceHookImpl::HookManInfoList::iterator CSourceHookImpl::FindHookMan(HookManInfoList::iterator begin,
   469 		HookManInfoList::iterator end, const char *proto, int vtblofs, int vtblidx)
   470 	{
   471 		HookManInfoList::iterator hookmaniter; 
   472 		for (hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   473 		{
   474 			if (strcmp(hookmaniter->proto, proto) == 0 && hookmaniter->vtbl_offs == vtblofs &&
   475 				hookmaniter->vtbl_idx == vtblidx)
   476 				break;
   477 		}
   478 		return hookmaniter;
   479 	}
   480 
   481 	void CSourceHookImpl::PausePlugin(Plugin plug)
   482 	{
   483 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   484 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   485 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   486 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   487 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   488 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   489 				{
   490 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   491 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   492 						if (plug == hookiter->plug)
   493 							hookiter->paused = true;
   494 
   495 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   496 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   497 						if (plug == hookiter->plug)
   498 							hookiter->paused = true;
   499 				}
   500 	}
   501 
   502 	void CSourceHookImpl::UnpausePlugin(Plugin plug)
   503 	{
   504 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   505 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   506 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   507 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   508 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   509 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   510 				{
   511 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   512 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   513 						if (plug == hookiter->plug)
   514 							hookiter->paused = false;
   515 
   516 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   517 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   518 						if (plug == hookiter->plug)
   519 							hookiter->paused = false;
   520 				}
   521 	}
   522 
   523 	void CSourceHookImpl::SetRes(META_RES res)
   524 	{
   525 		m_CurRes = res;
   526 	}
   527 
   528 	META_RES CSourceHookImpl::GetPrevRes()
   529 	{
   530 		return m_PrevRes;
   531 	}
   532 
   533 	META_RES CSourceHookImpl::GetStatus()
   534 	{
   535 		return m_Status;
   536 	}
   537 
   538 	const void *CSourceHookImpl::GetOrigRet()
   539 	{
   540 		return m_OrigRet;
   541 	}
   542 
   543 	const void *CSourceHookImpl::GetOverrideRet()
   544 	{
   545 		return m_OverrideRet;
   546 	}
   547 
   548 	META_RES &CSourceHookImpl::GetCurResRef()
   549 	{
   550 		return m_CurRes;
   551 	}
   552 
   553 	META_RES &CSourceHookImpl::GetPrevResRef()
   554 	{
   555 		return m_PrevRes;
   556 	}
   557 
   558 	META_RES &CSourceHookImpl::GetStatusRef()
   559 	{
   560 		return m_Status;
   561 	}
   562 
   563 	void * &CSourceHookImpl::GetIfacePtrRef()
   564 	{
   565 		return m_IfacePtr;
   566 	}
   567 
   568 	void CSourceHookImpl::SetOrigRet(const void *ptr)
   569 	{
   570 		m_OrigRet = ptr;
   571 	}
   572 
   573 	void CSourceHookImpl::SetOverrideRet(const void *ptr)
   574 	{
   575 		m_OverrideRet = ptr;
   576 	}
   577 
   578 	void *CSourceHookImpl::GetIfacePtr()
   579 	{
   580 		return m_IfacePtr;
   581 	}
   582 }