sourcehook/sourcehook.cpp
author Pavol Marko <pavolmarko@gmail.com>
Sat Apr 16 20:26:33 2005 +0000 (2005-04-16)
changeset 8 07e339563a28
parent 6 4803fd7d28bb
child 10 406d8e5ddfc4
permissions -rw-r--r--
Added plugin pausing, the Plugin typedef is now an int, SH_GLOB_PLUGPTR is now g_PLID by default
     1 /* ======== SourceHook ========
     2 * By PM
     3 * No warranties of any kind
     4 * ============================
     5 */
     6 
     7 /**
     8 *	@file sourcehook.cpp
     9 *	@brief Contains the implementation of the SourceHook API
    10 */
    11 
    12 #include <algorithm>
    13 #include "sourcehook_impl.h"
    14 
    15 #if SH_SYS == SH_SYS_WIN32
    16 # include <windows.h>
    17 #elif SH_SYS == SH_SYS_LINUX
    18 # include <sys/mman.h>
    19 # include <sys/limits.h>
    20 # include <unistd.h>
    21 # ifndef PAGESIZE
    22 #  define PAGESIZE 4096
    23 # endif
    24 #endif
    25 
    26 #if SH_RUNTIME_CODEGEN == 1
    27 # if SH_COMP == SH_COMP_GCC
    28 #  define SH_CCC_CODESIZE 15
    29 	//	 :TODO:
    30 	//void SH_CCC_MakeGate(void *origthisptr, unsigned char* &ptr, void *origvtable, int i)
    31 	//{
    32 	//}
    33 # elif SH_COMP == SH_COMP_MSVC
    34 #  define SH_CCC_CODESIZE 19
    35 	void SH_CCC_MakeGate(void *origthisptr, void *ccthisptr, unsigned char* ptr, void *origfunc)
    36 	{
    37 		// --Subtract old this pointer to get the offset
    38 		// 00417EDF 81 E9 A1 7B 33 01 sub         ecx,1337BA1h 
    39 		*ptr++ = 0x81;
    40 		*ptr++ = 0xE9;
    41 		*reinterpret_cast<void**>(ptr) = ccthisptr;
    42 		ptr += sizeof(void*);
    43 		// --Add it to the new this pointer
    44 		// 00417EE5 81 C1 37 13 37 13 add         ecx,13371337h 
    45 		*ptr++ = 0x81;
    46 		*ptr++ = 0xC1;
    47 		*reinterpret_cast<void**>(ptr) = origthisptr;
    48 		ptr += sizeof(void*);
    49 		// --Prepare address
    50 		// 00417EEB B8 EF BE AD DE   mov         eax,0DEADBEEFh 
    51 		*ptr++ = 0xB8;
    52 		*reinterpret_cast<void**>(ptr) = origfunc;
    53 		ptr += sizeof(void*);
    54 		// -- Do actual jump
    55 		// 00417EF0 FF E0            jmp         eax  
    56 		*ptr++ = 0xFF;
    57 		*ptr++ = 0xE0;
    58 	}
    59 # endif
    60 #endif
    61 
    62 
    63 namespace SourceHook
    64 {
    65 	CSourceHookImpl::CSourceHookImpl()
    66 	{
    67 		// Get page size
    68 #if SH_SYS == SH_SYS_WIN32
    69 		SYSTEM_INFO sysinfo;
    70 		GetSystemInfo(&sysinfo);
    71 		m_PageSize = sysinfo.dwPageSize;
    72 #elif SH_SYS == SH_SYS_LINUX
    73 		m_PageSize = PAGESIZE;
    74 #else
    75 # error Unsupported system
    76 #endif
    77 	}
    78 
    79 	CSourceHookImpl::~CSourceHookImpl()
    80 	{
    81 
    82 	}
    83 
    84 	bool CSourceHookImpl::IsPluginInUse(Plugin plug)
    85 	{
    86 		// Iterate through all hook managers which are in this plugin
    87 		// Iterate through their hooks
    88 		// If a hook from an other plugin is found, return true
    89 		// Return false otherwise
    90 #define TMP_CHECK_LIST(name) \
    91 	for (iter3 = iter2->name.begin(); iter3 != iter2->name.end(); ++iter3) \
    92 		if (iter3->plug == plug) \
    93 			return true;
    94 
    95 		for (HookManInfoList::iterator iter = m_HookMans.begin(); iter != m_HookMans.end(); ++iter)
    96 		{
    97 			if (iter->plug == plug && !iter->ifaces.empty())
    98 			{
    99 				for (std::list<HookManagerInfo::Iface>::iterator iter2 = iter->ifaces.begin(); iter2 != iter->ifaces.end(); ++iter2)
   100 				{
   101 					std::list<HookManagerInfo::Iface::Hook>::iterator iter3;
   102 					TMP_CHECK_LIST(hooks_pre);
   103 					TMP_CHECK_LIST(hooks_post);
   104 				}
   105 			}
   106 		}
   107 #undef TMP_CHECK_LIST
   108 		return false;
   109 	}
   110 
   111 	void CSourceHookImpl::UnloadPlugin(Plugin plug)
   112 	{
   113 		// 1) Manually remove all hooks by this plugin
   114 		std::list<RemoveHookInfo> hookstoremove;
   115 
   116 		for (HookManInfoList::iterator iter = m_HookMans.begin(); iter != m_HookMans.end(); ++iter)
   117 		{
   118 			for (std::list<HookManagerInfo::Iface>::iterator iter2 = iter->ifaces.begin(); iter2 != iter->ifaces.end();
   119 				++iter2)
   120 			{
   121 				for (std::list<HookManagerInfo::Iface::Hook>::iterator iter3 = iter2->hooks_pre.begin(); iter3 != iter2->hooks_pre.end(); ++iter3)
   122 					if (iter3->plug == plug)
   123 						hookstoremove.push_back(RemoveHookInfo(iter3->plug, iter2->ptr, iter->func, iter3->handler, false));
   124 
   125 				for (std::list<HookManagerInfo::Iface::Hook>::iterator iter3 = iter2->hooks_post.begin(); iter3 != iter2->hooks_post.end(); ++iter3)
   126 					if (iter3->plug == plug)
   127 						hookstoremove.push_back(RemoveHookInfo(iter3->plug, iter2->ptr, iter->func, iter3->handler, true));
   128 			}
   129 		}
   130 
   131 		for (std::list<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   132 			RemoveHook(rmiter->plug, rmiter->iface, rmiter->hpf, rmiter->handler, rmiter->post);
   133 
   134 		// 2) Other plugins may use hook managers in this plugin.
   135 		// Get a list of hook managers that are in this plugin and are used by other plugins
   136 		// Delete all hook managers that are in this plugin
   137 
   138 		HookManInfoList tmphookmans;
   139 		bool erase = false;
   140 		for (HookManInfoList::iterator iter = m_HookMans.begin(); iter != m_HookMans.end();
   141 			erase ? iter=m_HookMans.erase(iter) : ++iter)
   142 		{
   143 			if (iter->plug == plug)
   144 			{
   145 				if (!iter->ifaces.empty())
   146 				{
   147 					// All hooks by this plugin are already removed
   148 					// So if there is an iface, it has to be used by an other plugin
   149 					tmphookmans.push_back(*iter);
   150 				}
   151 				erase = true;
   152 			}
   153 			else
   154 				erase = false;
   155 		}
   156 		
   157 		// For each hook manager:
   158 		for (HookManInfoList::iterator iter = tmphookmans.begin(); iter != tmphookmans.end(); ++iter)
   159 		{
   160 			// Find a suitable hook manager in an other plugin
   161 			HookManInfoList::iterator newHookMan = FindHookMan(m_HookMans.begin(), m_HookMans.end(),
   162 				iter->proto, iter->vtbl_offs, iter->vtbl_idx, iter->thisptr_offs);
   163 			if (newHookMan == m_HookMans.end())
   164 			{
   165 				// This should _never_ happen.
   166 				// If there is a hook from an other plugin, the plugin must have provided a hook manager as well.
   167 				SH_ASSERT(0);
   168 			}
   169 
   170 			// AddHook should make sure that every plugin only has _one_ hook manager for _one_ proto/vi/vo/thisptroffs
   171 			SH_ASSERT(newHookMan->plug != plug);
   172 
   173 			// The first hooker should be always used - so the new hook manager has to be empty
   174 			SH_ASSERT(newHookMan->ifaces.empty());
   175 
   176 			// Move the ifaces from the old hook manager to the new one
   177 			newHookMan->ifaces = iter->ifaces;
   178 
   179 			// Unregister the old one, register the new one
   180 			iter->func(HA_Unregister, NULL);
   181 			newHookMan->func(HA_Register, &(*newHookMan));
   182 		}
   183 	}
   184 
   185 	void CSourceHookImpl::CompleteShutdown()
   186 	{
   187 		std::list<RemoveHookInfo> hookstoremove;
   188 
   189 		for (HookManInfoList::iterator iter = m_HookMans.begin(); iter != m_HookMans.end(); ++iter)
   190 		{
   191 			for (std::list<HookManagerInfo::Iface>::iterator iter2 = iter->ifaces.begin(); iter2 != iter->ifaces.end();
   192 				++iter2)
   193 			{
   194 				for (std::list<HookManagerInfo::Iface::Hook>::iterator iter3 = iter2->hooks_pre.begin(); iter3 != iter2->hooks_pre.end(); ++iter3)
   195 					hookstoremove.push_back(RemoveHookInfo(iter3->plug, iter2->ptr, iter->func, iter3->handler, false));
   196 				
   197 				for (std::list<HookManagerInfo::Iface::Hook>::iterator iter3 = iter2->hooks_post.begin(); iter3 != iter2->hooks_post.end(); ++iter3)
   198 					hookstoremove.push_back(RemoveHookInfo(iter3->plug, iter2->ptr, iter->func, iter3->handler, true));
   199 			}
   200 		}
   201 
   202 		for (std::list<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   203 			RemoveHook(rmiter->plug, rmiter->iface, rmiter->hpf, rmiter->handler, rmiter->post);
   204 
   205 		m_HookMans.clear();
   206 	}
   207 
   208 	bool CSourceHookImpl::AddHook(Plugin plug, void *iface, int ifacesize, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   209 	{
   210 		// 1) Get info about the hook manager
   211 		HookManagerInfo tmp;
   212 		if (myHookMan(HA_GetInfo, &tmp) != 0)
   213 			return false;
   214 
   215 		// 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
   216 		HookManInfoList::iterator hookmaniter;
   217 		for (hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   218 		{
   219 			if (hookmaniter->plug == plug && strcmp(hookmaniter->proto, tmp.proto) == 0 &&
   220 				hookmaniter->vtbl_offs == tmp.vtbl_offs && hookmaniter->vtbl_idx == tmp.vtbl_idx &&
   221 				hookmaniter->thisptr_offs == tmp.thisptr_offs)
   222 				break;
   223 		}
   224 		if (hookmaniter == m_HookMans.end())
   225 		{
   226 			// No such hook manager from this plugin yet, add it!
   227 			tmp.func = myHookMan;
   228 			tmp.plug = plug;
   229 			m_HookMans.push_back(tmp);
   230 		}
   231 
   232 		// Then, search for a suitable hook manager (from the beginning)
   233 		HookManInfoList::iterator hookman = FindHookMan(m_HookMans.begin(), m_HookMans.end(), tmp.proto, tmp.vtbl_offs, tmp.vtbl_idx, tmp.thisptr_offs);
   234 		SH_ASSERT(hookman != m_HookMans.end());
   235 
   236 		// Tell it to store the pointer if it's not already active
   237 		if (hookman->ifaces.empty())
   238 			hookman->func(HA_Register, &(*hookman));
   239 
   240 		std::list<HookManagerInfo::Iface>::iterator ifsiter = std::find(hookman->ifaces.begin(), hookman->ifaces.end(), iface);
   241 
   242 		if (ifsiter == hookman->ifaces.end())
   243 		{
   244 			HookManagerInfo::Iface ifs;
   245 			ifs.ptr = iface;
   246 			ifs.callclass = GetCallClass(iface, ifacesize);
   247 			void *vtableptr = *reinterpret_cast<void**>(reinterpret_cast<char*>(iface) + hookman->vtbl_offs);
   248 			SetMemAccess(vtableptr, sizeof(void*) * hookman->vtbl_idx, SH_MEM_READ | SH_MEM_WRITE);
   249 			ifs.orig_entry = (*reinterpret_cast<void***>(reinterpret_cast<char*>(iface) + hookman->vtbl_offs))[hookman->vtbl_idx];
   250 			(*reinterpret_cast<void***>(reinterpret_cast<char*>(iface) + hookman->vtbl_offs))[hookman->vtbl_idx] =
   251 				(*reinterpret_cast<void***>(reinterpret_cast<char*>(hookman->hookfunc_inst) + hookman->hookfunc_vtbl_offs))[hookman->hookfunc_vtbl_idx];
   252 			hookman->ifaces.push_back(ifs);
   253 			ifsiter = hookman->ifaces.end();
   254 			--ifsiter;
   255 		}
   256 		HookManagerInfo::Iface::Hook hookinfo;
   257 		hookinfo.handler = handler;
   258 		hookinfo.plug = plug;
   259 		hookinfo.paused = false;
   260 		if (post)
   261    			ifsiter->hooks_post.push_back(hookinfo);
   262 		else
   263 			ifsiter->hooks_pre.push_back(hookinfo);
   264 
   265 
   266 		// Now that it is done, check whether we have to update any callclasses
   267 		for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   268 		{
   269 			if (cciter->iface == iface)
   270 			{
   271 				ApplyCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx, ifsiter->orig_entry);
   272 
   273 				// We can assume that there is no more callclass with the same iface
   274 				break;
   275 			}
   276 		}
   277 
   278 		return true;
   279 	}
   280 
   281 	bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   282 	{
   283 		HookManagerInfo tmp;
   284 		if (myHookMan(HA_GetInfo, &tmp) != 0)
   285 			return false;
   286 
   287 		// Find the hook manager and the hook
   288 		HookManInfoList::iterator hookman = FindHookMan(m_HookMans.begin(), m_HookMans.end(), 
   289 			tmp.proto, tmp.vtbl_offs, tmp.vtbl_idx, tmp.thisptr_offs);
   290 		if (hookman == m_HookMans.end())
   291 			return false;
   292 
   293 		for (std::list<HookManagerInfo::Iface>::iterator ifaceiter = hookman->ifaces.begin(); ifaceiter != hookman->ifaces.end(); ++ifaceiter)
   294 		{
   295 			if (ifaceiter->ptr == iface)
   296 			{
   297 				std::list<HookManagerInfo::Iface::Hook> &hooks = post ? ifaceiter->hooks_post : ifaceiter->hooks_pre;
   298 				bool erase;
   299 				for (std::list<HookManagerInfo::Iface::Hook>::iterator hookiter = hooks.begin();
   300 					hookiter != hooks.end(); erase ? hookiter = hooks.erase(hookiter) : ++hookiter)
   301 				{
   302 					erase = hookiter->plug == plug && hookiter->handler->IsEqual(handler);
   303 					if (erase)
   304 						hookiter->handler->DeleteThis();			// Make the _plugin_ delete the handler object
   305 				}
   306 				if (ifaceiter->hooks_post.empty() && ifaceiter->hooks_pre.empty())
   307 				{
   308 					// Deactivate the hook
   309 					(*reinterpret_cast<void***>(reinterpret_cast<char*>(ifaceiter->ptr) +
   310 						hookman->vtbl_offs))[hookman->vtbl_idx]= ifaceiter->orig_entry;
   311 
   312 					// Release the callclass
   313 					ReleaseCallClass(ifaceiter->callclass);
   314 
   315 					// Remove the iface info
   316 					hookman->ifaces.erase(ifaceiter);
   317 
   318 					if (hookman->ifaces.empty())
   319 						hookman->func(HA_Unregister, NULL);
   320 				}
   321 				// :TODO: Better return value? Or none?
   322 				return true;
   323 			}
   324 		}
   325 		return false;
   326 	}
   327 
   328 	void *CSourceHookImpl::GetCallClass(void *iface, size_t size)
   329 	{
   330 		for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   331 		{
   332 			if (cciter->iface == iface)
   333 			{
   334 				++cciter->refcounter;
   335 				return cciter->ptr;
   336 			}
   337 		}
   338 
   339 		// The layout of callclasses is:
   340 		//  Copy of the class; vtable entries pointing to gates
   341 		//  Pointer to the corresponding CallClass object
   342 		//  Copy of the class; vtable entries pointing to original functions
   343 
   344 		CallClass tmp;
   345 		char *ptr = new char[size * 2 + sizeof(void*)];
   346 		tmp.ptr = reinterpret_cast<void*>(ptr);
   347 		memcpy(reinterpret_cast<void*>(ptr), iface, size);
   348 		memcpy(reinterpret_cast<void*>(ptr + size + sizeof(void*)), iface, size);
   349 		tmp.iface = iface;
   350 		tmp.size = size;
   351 		tmp.refcounter = 1;
   352 
   353 		// Go through _all_ hooks and apply any needed patches
   354 		for (HookManInfoList::iterator hookman = m_HookMans.begin(); hookman != m_HookMans.end(); ++hookman)
   355 		{
   356 			for (std::list<HookManagerInfo::Iface>::iterator ifaceiter = hookman->ifaces.begin(); ifaceiter != hookman->ifaces.end(); ++ifaceiter)
   357 			{
   358 				if (ifaceiter->ptr == iface)
   359 				{
   360 					if (!ApplyCallClassPatch(tmp, hookman->vtbl_offs, hookman->vtbl_idx, ifaceiter->orig_entry))
   361 					{
   362 						FreeCallClass(tmp);
   363 						return NULL;
   364 					}
   365 				}
   366 			}
   367 		}
   368 		m_CallClasses.push_back(tmp);
   369 		// The object has to be followed by the pointer to the vtable info object
   370 		*reinterpret_cast<void**>(ptr + size) = &m_CallClasses.back();
   371 		return tmp.ptr;
   372 	}
   373 
   374 	void CSourceHookImpl::ReleaseCallClass(void *ptr)
   375 	{
   376 		Impl_CallClassList::iterator iter = std::find(m_CallClasses.begin(), m_CallClasses.end(), ptr);
   377 		if (iter == m_CallClasses.end())
   378 			return;
   379 		--iter->refcounter;
   380 		if (iter->refcounter < 1)
   381 		{
   382 			FreeCallClass(*iter);
   383 			m_CallClasses.erase(iter);
   384 		}
   385 	}
   386 
   387 	void CSourceHookImpl::FreeCallClass(CallClass &cc)
   388 	{
   389 		for (CallClass::VTableList::iterator vtbliter = cc.vtables.begin(); vtbliter != cc.vtables.end(); ++vtbliter)
   390 		{
   391 #if SH_RUNTIME_CODEGEN == 1
   392 			// Delete generated callgates
   393 			for (std::list<int>::iterator cgiter = vtbliter->patches.begin(); cgiter != vtbliter->patches.end(); ++cgiter)
   394 			{
   395 				char *cgptr = reinterpret_cast<char**>(vtbliter->ptr)[*cgiter];
   396 				delete [] cgptr;
   397 			}
   398 #endif
   399 			delete [] reinterpret_cast<char*>(vtbliter->ptr);
   400 		}
   401 		delete [] reinterpret_cast<char*>(cc.ptr);
   402 	}
   403 
   404 	bool CSourceHookImpl::ApplyCallClassPatch(CallClass &cc, int vtbl_offs, int vtbl_idx, void *orig_entry)
   405 	{
   406 		char *ptr = reinterpret_cast<char*>(cc.ptr);
   407 		void *vtable = *reinterpret_cast<void**>(ptr + vtbl_offs);
   408 
   409 		// Check whether we already know that vtable
   410 		CallClass::VTableList::iterator vtbliter = std::find(cc.vtables.begin(),
   411 			cc.vtables.end(), reinterpret_cast<void*>(vtable));
   412 		int actvtablesize=MAX_VTABLE_LEN;
   413 		if (vtbliter == cc.vtables.end())
   414 		{
   415 			CallClass::VTable newvtableinfo;
   416 			int pagesnum = (MAX_VTABLE_LEN % m_PageSize == 0) ? MAX_VTABLE_LEN / m_PageSize : MAX_VTABLE_LEN / m_PageSize + 1;
   417 			// Set all pages in the range to readwrite
   418 			// :TODO: Fix this!
   419 			char *pagebegin = reinterpret_cast<char*>(vtable) - (reinterpret_cast<int>(vtable) % m_PageSize);
   420 			for (int ipage = 0; ipage < pagesnum; ++ipage)
   421 			{
   422 				if (!SetMemAccess(reinterpret_cast<void*>(pagebegin + ipage * m_PageSize), 1,
   423 					SH_MEM_READ | SH_MEM_WRITE))
   424 				{
   425 					// We can't go here anymore
   426 					actvtablesize = static_cast<int>((pagebegin + ipage * m_PageSize) - reinterpret_cast<char*>(vtable));
   427 					break;
   428 				}
   429 			}
   430 			if (actvtablesize < 1)
   431 			{
   432 				// We can't access the vtable -> Quit
   433 				return false;
   434 			}
   435 			// Create a new vtable
   436 			newvtableinfo.ptr = reinterpret_cast<void*>(new char[actvtablesize]);
   437 			// Fill it with the information from the old vtable
   438 			memcpy(newvtableinfo.ptr, vtable, actvtablesize);
   439 			newvtableinfo.actsize = actvtablesize;
   440 			// Set the pointer in the object and add it to the list of already known vtables
   441 			*reinterpret_cast<void**>(ptr + vtbl_offs) = newvtableinfo.ptr;
   442 			cc.vtables.push_back(newvtableinfo);
   443 
   444 			vtbliter = cc.vtables.end();
   445 			--vtbliter;
   446 			// :TODO: When not codegen, patch the other vtable?
   447 		}
   448 
   449 		// Check whether we already have this patch
   450 		if (std::find(vtbliter->patches.begin(), vtbliter->patches.end(), vtbl_idx) == vtbliter->patches.end())
   451 		{
   452 			// No -> apply it
   453 
   454 			// Get a call gate
   455 			void *callgate = NULL;
   456 #if SH_RUNTIME_CODEGEN == 1
   457 			unsigned char *cggen = new unsigned char[SH_CCC_CODESIZE];
   458 			SH_CCC_MakeGate(cc.iface, cc.ptr, cggen, orig_entry);
   459 			callgate = (void*)cggen;
   460 			SetMemAccess(callgate, SH_CCC_CODESIZE, SH_MEM_READ | SH_MEM_WRITE | SH_MEM_EXEC);
   461 #else
   462 			// :TODO:
   463 #error Not supported yet!
   464 #endif
   465 			vtbliter->patches.push_back(vtbl_idx);
   466 			reinterpret_cast<void**>(vtbliter->ptr)[vtbl_idx] = callgate;
   467 		}
   468 		return true;
   469 	}
   470 
   471 
   472 	CSourceHookImpl::HookManInfoList::iterator CSourceHookImpl::FindHookMan(HookManInfoList::iterator begin,
   473 		HookManInfoList::iterator end, const char *proto, int vtblofs, int vtblidx, int thisptrofs)
   474 	{
   475 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   476 		{
   477 			if (strcmp(hookmaniter->proto, proto) == 0 && hookmaniter->vtbl_offs == vtblofs && hookmaniter->vtbl_idx == vtblidx &&
   478 				hookmaniter->thisptr_offs == thisptrofs)
   479 				break;
   480 		}
   481 		return hookmaniter;
   482 	}
   483 
   484 	void CSourceHookImpl::PausePlugin(Plugin plug)
   485 	{
   486 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   487 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   488 			for (std::list<HookManagerInfo::Iface>::iterator ifaceiter = hookmaniter->ifaces.begin();
   489 				ifaceiter != hookmaniter->ifaces.end(); ++ifaceiter)
   490 			{
   491 				for (std::list<HookManagerInfo::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   492 					hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   493 					if (plug == hookiter->plug)
   494 						hookiter->paused = true;
   495 
   496 				for (std::list<HookManagerInfo::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   497 					hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   498 					if (plug == hookiter->plug)
   499 						hookiter->paused = true;
   500 			}
   501 	}
   502 
   503 	void CSourceHookImpl::UnpausePlugin(Plugin plug)
   504 	{
   505 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to normal
   506 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   507 			for (std::list<HookManagerInfo::Iface>::iterator ifaceiter = hookmaniter->ifaces.begin();
   508 				ifaceiter != hookmaniter->ifaces.end(); ++ifaceiter)
   509 			{
   510 				for (std::list<HookManagerInfo::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   511 					hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   512 					if (plug == hookiter->plug)
   513 						hookiter->paused = false;
   514 
   515 				for (std::list<HookManagerInfo::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   516 					hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   517 					if (plug == hookiter->plug)
   518 						hookiter->paused = false;
   519 			}
   520 	}
   521 
   522 	void CSourceHookImpl::SetRes(META_RES res)
   523 	{
   524 		m_CurRes = res;
   525 	}
   526 
   527 	META_RES CSourceHookImpl::GetPrevRes()
   528 	{
   529 		return m_PrevRes;
   530 	}
   531 
   532 	META_RES CSourceHookImpl::GetStatus()
   533 	{
   534 		return m_Status;
   535 	}
   536 
   537 	const void *CSourceHookImpl::GetOrigRet()
   538 	{
   539 		return m_OrigRet;
   540 	}
   541 
   542 	const void *CSourceHookImpl::GetOverrideRet()
   543 	{
   544 		return m_OverrideRet;
   545 	}
   546 
   547 	META_RES &CSourceHookImpl::GetCurResRef()
   548 	{
   549 		return m_CurRes;
   550 	}
   551 
   552 	META_RES &CSourceHookImpl::GetPrevResRef()
   553 	{
   554 		return m_PrevRes;
   555 	}
   556 
   557 	META_RES &CSourceHookImpl::GetStatusRef()
   558 	{
   559 		return m_Status;
   560 	}
   561 
   562 	void CSourceHookImpl::SetOrigRet(const void *ptr)
   563 	{
   564 		m_OrigRet = ptr;
   565 	}
   566 
   567 	void CSourceHookImpl::SetOverrideRet(const void *ptr)
   568 	{
   569 		m_OverrideRet = ptr;
   570 	}
   571 
   572 	void CSourceHookImpl::SetIfacePtr(void *ptr)
   573 	{
   574 		m_IfacePtr = ptr;
   575 	}
   576 	void *CSourceHookImpl::GetIfacePtr()
   577 	{
   578 		return m_IfacePtr;
   579 	}
   580 }