sourcehook/sourcehook.cpp
author Pavol Marko <pavolmarko@gmail.com>
Sun Oct 07 22:10:07 2007 +0000 (2007-10-07)
changeset 380 f9e21a2ac558
parent 333 3813f1ac0cfe
child 386 08583103ba6f
permissions -rw-r--r--
New auto-hookfunc-gen friendly interface
! breaks binary compatibility !
     1 /* ======== SourceHook ========
     2 * Copyright (C) 2004-2007 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 #if defined __GNUC__
    18 #include <stdint.h>
    19 #endif
    20 
    21 #include "sourcehook_impl.h"
    22 #include "sh_memory.h"
    23 
    24 namespace SourceHook
    25 {
    26 	template<>
    27 	int HashFunction<int>(const int & k)
    28 	{
    29 		return k;
    30 	}
    31 	template<>
    32 	int Compare<int>(const int & k1, const int & k2)
    33 	{
    34 		if (k1 == k2)
    35 			return 0;
    36 		if (k1 > k2)
    37 			return 1;
    38 		if (k1 < k2)
    39 			return -1;
    40 		return 0;
    41 	}
    42 
    43 	namespace Impl
    44 	{
    45 		//////////////////////////////////////////////////////////////////////////
    46 		// CProto
    47 		//////////////////////////////////////////////////////////////////////////
    48 		ProtoInfo *CProto::DupProto(const ProtoInfo *src)
    49 		{
    50 			if (src == NULL)
    51 				return NULL;
    52 
    53 			PassInfo *newParamsPassInfo = new PassInfo[src->numOfParams + 1];
    54 			for (int i = 0; i <= src->numOfParams; ++i)
    55 				newParamsPassInfo[i] = src->paramsPassInfo[i];
    56 
    57 			ProtoInfo *newProto = new ProtoInfo;
    58 			newProto->retPassInfo = src->retPassInfo;
    59 			newProto->paramsPassInfo = newParamsPassInfo;
    60 			newProto->numOfParams = src->numOfParams;
    61 			newProto->convention = src->convention;
    62 
    63 			return newProto;
    64 		}
    65 
    66 		void CProto::FreeProto(ProtoInfo *prot)
    67 		{
    68 			if (!prot)
    69 				return;
    70 
    71 			delete [] prot->paramsPassInfo;
    72 			delete prot;
    73 		}
    74 
    75 		bool CProto::Equal(const ProtoInfo *p1, const ProtoInfo *p2)
    76 		{
    77 			if (!p1 || !p2)
    78 				return false;
    79 
    80 			if (p1->numOfParams != p2->numOfParams)
    81 				return false;
    82 
    83 			if (p1->convention != ProtoInfo::CallConv_Unknown && p2->convention != ProtoInfo::CallConv_Unknown &&
    84 				p1->convention != p2->convention)
    85 				return false;
    86 
    87 			if (p1->retPassInfo.size != p2->retPassInfo.size)
    88 				return false;
    89 
    90 			// Skip params[0] : dummy
    91 			for (int i = 1; i <= p1->numOfParams; ++i)
    92 			{
    93 				if (p1->paramsPassInfo[i].size != p2->paramsPassInfo[i].size)
    94 					return false;
    95 				if (p1->paramsPassInfo[i].type != PassInfo::PassType_Unknown && p2->paramsPassInfo[i].type != PassInfo::PassType_Unknown)
    96 				{
    97 					if (p1->paramsPassInfo[i].type != p2->paramsPassInfo[i].type)
    98 						return false;
    99 					if (p1->paramsPassInfo[i].flags != p2->paramsPassInfo[i].flags)
   100 						return false;
   101 				}
   102 			}
   103 
   104 			return true;
   105 		}
   106 
   107 
   108 		//////////////////////////////////////////////////////////////////////////
   109 		// CHookManContainerList
   110 		//////////////////////////////////////////////////////////////////////////
   111 		CHookManagerContainer &CHookManContainerList::GetContainer(int vtbloffs, int vtblidx, const CProto &proto)
   112 		{
   113 			iterator iter = find(CHookManagerContainer::Descriptor(vtbloffs, vtblidx, proto));
   114 			if (iter == end())
   115 			{
   116 				CHookManagerContainer newCont(vtbloffs, vtblidx, proto);
   117 				push_back(newCont);
   118 				return back();
   119 			}
   120 			else
   121 			{
   122 				return *iter;
   123 			}
   124 		}
   125 
   126 		void CHookManContainerList::RemoveHookMans(Plugin plug)
   127 		{
   128 			for (iterator iter = begin(); iter != end(); ++iter)
   129 				iter->RemoveHookMans(plug);
   130 		}
   131 
   132 		void CHookManContainerList::RemoveHookMans(Plugin plug, HookManagerPubFunc pubFunc)
   133 		{
   134 			for (iterator iter = begin(); iter != end(); ++iter)
   135 				iter->RemoveHookMans(plug, pubFunc);
   136 		}
   137 
   138 		//////////////////////////////////////////////////////////////////////////
   139 		// CHookManagerContainer
   140 		//////////////////////////////////////////////////////////////////////////
   141 		
   142 		bool CHookManagerContainer::AddHookManager(const CHookManager &hookMan)
   143 		{
   144 			iterator iter;
   145 
   146 			// Don't accept invalid hook managers
   147 			if (!hookMan)
   148 				return false;
   149 
   150 			// Check whether such a hook manager already exists; if yes, ignore.
   151 			iter = find(hookMan);
   152 			if (iter != end())
   153 			{
   154 				// but make sure that it's activated (ms_HI stored)
   155 				iter->Register();
   156 				return true;
   157 			}
   158 
   159 			// It doesn't -> add it. Add it to the end of its version group.
   160 			for (iter = begin(); iter != end(); ++iter)
   161 			{
   162 				if (iter->GetVersion() < hookMan.GetVersion())
   163 					break;
   164 			}
   165 
   166 			bool isBeginning = iter == begin();
   167 
   168 			insert(iter, hookMan);
   169 
   170 			if (isBeginning)
   171 			{
   172 				iter = begin();
   173 
   174 				if (size() > 1)
   175 				{
   176 					// If the next hookman isn't empty (there were hooks before, but this hookman is better)
   177 					// transfer its vfnptrs and deactivate it
   178 
   179 					iterator second = iter;
   180 					++second;
   181 
   182 					if (!second->GetVfnPtrList().empty())
   183 					{
   184 						// Move the vfnptrs from the old hook manager to the new one
   185 						iter->GetVfnPtrList() = second->GetVfnPtrList();
   186 						second->GetVfnPtrList().clear();
   187 
   188 						// Unregister the old one, register the new one
   189 						second->Unregister();
   190 
   191 						// Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
   192 						// :TODO: change this to something like for_all :X
   193 						for (List<CVfnPtr>::iterator vfnptr_iter = iter->GetVfnPtrList().begin();
   194 							vfnptr_iter != iter->GetVfnPtrList().end(); ++vfnptr_iter)
   195 						{
   196 							vfnptr_iter->Patch(iter->GetHookFunc());
   197 						}
   198 					}
   199 				}
   200 
   201 				// activate the new active hookman
   202 				iter->Register();
   203 			}
   204 			
   205 			return true;
   206 		}
   207 
   208 		void CHookManagerContainer::RemoveHookMans(Plugin plug, HookManagerPubFunc pubFunc)
   209 		{
   210 			bool erasethis = false;
   211 
   212 			for (iterator iter = begin(); iter != end(); erasethis ? (iter = erase(iter)) : ++iter)
   213 			{
   214 				erasethis = false;
   215 				if (iter->GetOwnerPlugin() == plug
   216 					&& (pubFunc == NULL ? true : (iter->GetPubFunc() == pubFunc)))
   217 				{
   218 					if (iter == begin() && !iter->GetVfnPtrList().empty())
   219 					{
   220 						// The hook manager is active
   221 						// -> Transfer its hooks to the next hook manager (which _has_ to exist)
   222 						SH_ASSERT(size() > 1, ("No more hook managers!?"));
   223 
   224 						iterator second = iter;
   225 						++second;
   226 
   227 						SH_ASSERT(second->GetOwnerPlugin() != plug, ("New hook manager from same plugin!"));
   228 
   229 						second->GetVfnPtrList() = iter->GetVfnPtrList();
   230 						iter->GetVfnPtrList().clear();
   231 
   232 						second->Register();
   233 						iter->Unregister();
   234 
   235 						// Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
   236 						// :TODO: change this to something like for_all :X
   237 						for (List<CVfnPtr>::iterator vfnptr_iter = second->GetVfnPtrList().begin();
   238 							vfnptr_iter != second->GetVfnPtrList().end(); ++vfnptr_iter)
   239 						{
   240 							vfnptr_iter->Patch(second->GetHookFunc());
   241 						}
   242 					}
   243 					erasethis = true;
   244 				}
   245 			}
   246 		}
   247 		
   248 		//////////////////////////////////////////////////////////////////////////
   249 		// CHookManager
   250 		//////////////////////////////////////////////////////////////////////////
   251 		void CHookManager::SetInfo(int hookman_version, int vtbloffs, int vtblidx,
   252 			ProtoInfo *proto, void *hookfunc_vfnptr)
   253 		{
   254 			m_Version = hookman_version;
   255 			m_VtblOffs = vtbloffs;
   256 			m_VtblIdx = vtblidx;
   257 			m_Proto = proto;
   258 			m_HookfuncVfnptr = hookfunc_vfnptr;
   259 		}
   260 
   261 		CVfnPtr &CHookManager::GetVfnPtr(void *vfnptr)
   262 		{
   263 			List<CVfnPtr>::iterator iter = m_VfnPtrList.find(vfnptr);
   264 			if (iter == m_VfnPtrList.end())
   265 			{
   266 				CVfnPtr newVfnPtr(vfnptr);
   267 				m_VfnPtrList.push_back(newVfnPtr);
   268 
   269 				newVfnPtr.Patch(GetHookFunc());
   270 
   271 				return m_VfnPtrList.back();
   272 			}
   273 			else
   274 			{
   275 				return *iter;
   276 			}
   277 		}
   278 
   279 		//////////////////////////////////////////////////////////////////////////
   280 		// CVfnPtr
   281 		//////////////////////////////////////////////////////////////////////////
   282 		
   283 		bool CVfnPtr::Patch(void *newValue)
   284 		{
   285 			if (!SetMemAccess(m_Ptr, sizeof(void*), SH_MEM_READ | SH_MEM_WRITE))
   286 				return false;
   287 
   288 			*reinterpret_cast<void**>(m_Ptr) = newValue;
   289 
   290 			return true;
   291 		}
   292 
   293 		CIface &CVfnPtr::GetIface(void *iface)
   294 		{
   295 			List<CIface>::iterator iter = m_IfaceList.find(iface);
   296 			if (iter == m_IfaceList.end())
   297 			{
   298 				CIface newIface(iface);
   299 				if (iface == NULL)
   300 				{
   301 					m_IfaceList.push_front(newIface);
   302 					return m_IfaceList.front();
   303 				}
   304 				else
   305 				{
   306 					m_IfaceList.push_back(newIface);
   307 					return m_IfaceList.back();
   308 				}
   309 			}
   310 			else
   311 			{
   312 				return *iter;
   313 			}
   314 		}
   315 
   316 		//////////////////////////////////////////////////////////////////////////
   317 		// CHookIdManager
   318 		//////////////////////////////////////////////////////////////////////////
   319 		CHookIDManager::CHookIDManager()
   320 		{
   321 		}
   322 
   323 		int CHookIDManager::New(const CProto &proto, int vtbl_offs, int vtbl_idx, void *vfnptr,
   324 			void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
   325 		{
   326 			Entry tmp(proto, vtbl_offs, vtbl_idx, vfnptr, adjustediface, plug, thisptr_offs, handler, post);
   327 
   328 			size_t cursize = m_Entries.size();
   329 			for (size_t i = 0; i < cursize; ++i)
   330 			{
   331 				if (m_Entries[i].isfree)
   332 				{
   333 					m_Entries[i] = tmp;
   334 					return static_cast<int>(i) + 1;
   335 				}
   336 			}
   337 
   338 			m_Entries.push_back(tmp);
   339 			return static_cast<int>(m_Entries.size());		// return size() because hookid = id+1 anyway
   340 		}
   341 
   342 		bool CHookIDManager::Remove(int hookid)
   343 		{
   344 			int realid = hookid - 1;
   345 			if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
   346 				return false;
   347 
   348 			m_Entries[realid].isfree = true;
   349 
   350 			// :TODO: remove free ids from back sometimes ??
   351 
   352 			return true;
   353 		}
   354 
   355 		const CHookIDManager::Entry * CHookIDManager::QueryHook(int hookid)
   356 		{
   357 			int realid = hookid - 1;
   358 			if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
   359 				return NULL;
   360 
   361 			return &m_Entries[realid];
   362 		}
   363 
   364 		void CHookIDManager::FindAllHooks(CVector<int> &output, const CProto &proto, int vtbl_offs,
   365 			int vtbl_idx, void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
   366 		{
   367 			// oh my god, a lot of parameters...
   368 			size_t cursize = m_Entries.size();
   369 			for (size_t i = 0; i < cursize; ++i)
   370 			{
   371 				if (!m_Entries[i].isfree && m_Entries[i].proto == proto && m_Entries[i].vtbl_offs == vtbl_offs &&
   372 					m_Entries[i].vtbl_idx == vtbl_idx && m_Entries[i].adjustediface == adjustediface && m_Entries[i].plug == plug &&
   373 					m_Entries[i].thisptr_offs == thisptr_offs && m_Entries[i].handler->IsEqual(handler) && m_Entries[i].post == post)
   374 				{
   375 					output.push_back(static_cast<int>(i) + 1);
   376 				}
   377 			}
   378 		}
   379 
   380 		void CHookIDManager::FindAllHooks(CVector<int> &output)
   381 		{
   382 			size_t cursize = m_Entries.size();
   383 			for (size_t i = 0; i < cursize; ++i)
   384 			{
   385 				if (!m_Entries[i].isfree)
   386 					output.push_back(static_cast<int>(i) + 1);
   387 			}
   388 		}
   389 
   390 		void CHookIDManager::FindAllHooks(CVector<int> &output, Plugin plug)
   391 		{
   392 			size_t cursize = m_Entries.size();
   393 			for (size_t i = 0; i < cursize; ++i)
   394 			{
   395 				if (!m_Entries[i].isfree && m_Entries[i].plug == plug)
   396 					output.push_back(static_cast<int>(i) + 1);
   397 			}
   398 		}
   399 
   400 
   401 		//////////////////////////////////////////////////////////////////////////
   402 		// CSourceHookImpl
   403 		//////////////////////////////////////////////////////////////////////////
   404 		
   405 
   406 		CSourceHookImpl::CSourceHookImpl()
   407 		{
   408 		}
   409 		CSourceHookImpl::~CSourceHookImpl()
   410 		{
   411 		}
   412 
   413 		int CSourceHookImpl::GetIfaceVersion()
   414 		{
   415 			return SH_IFACE_VERSION;
   416 		}
   417 
   418 		int CSourceHookImpl::GetImplVersion()
   419 		{
   420 			return SH_IMPL_VERSION;
   421 		}
   422 
   423 		int CSourceHookImpl::AddHook(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
   424 			ISHDelegate *handler, bool post)
   425 		{
   426 			if (mode != Hook_Normal && mode != Hook_VP && mode != Hook_DVP)
   427 				return 0;
   428 
   429 			// Get info about hook manager
   430 			CHookManager hookManager(plug, myHookMan);
   431 			if (!hookManager)
   432 				return 0;
   433 
   434 			// Make sure that the container exists
   435 			CHookManagerContainer &container = m_HookManContainers.GetContainer(hookManager.GetVtblOffs(),
   436 				hookManager.GetVtblIdx(), hookManager.GetProto());
   437 
   438 			container.AddHookManager(hookManager);
   439 
   440 			if (!container)
   441 			{
   442 				// For some weird reason, the container is empty!
   443 				SH_ASSERT(0, ("No hookman found - but we've just added one!"));
   444 				return 0;
   445 			}
   446 
   447 			CHookManager &hookMan = container.GetActiveHookManager();
   448 
   449 			void *adjustediface = NULL;
   450 			void **cur_vtptr = NULL;
   451 			void *cur_vfnptr = NULL;
   452 
   453 			// find vfnptr
   454 			switch (mode)
   455 			{
   456 			case Hook_Normal:
   457 				adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
   458 
   459 				cur_vtptr = *reinterpret_cast<void***>(
   460 					reinterpret_cast<char*>(adjustediface) + hookMan.GetVtblOffs());
   461 				cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + hookMan.GetVtblIdx());
   462 				break;
   463 
   464 			case Hook_VP:
   465 
   466 				adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
   467 
   468 				cur_vtptr = *reinterpret_cast<void***>(
   469 					reinterpret_cast<char*>(adjustediface) + hookMan.GetVtblOffs());
   470 				cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + hookMan.GetVtblIdx());
   471 
   472 				adjustediface = NULL;
   473 				break;
   474 
   475 			case Hook_DVP:
   476 				adjustediface = NULL;
   477 
   478 				cur_vtptr = reinterpret_cast<void**>(iface);
   479 				cur_vfnptr = cur_vtptr + hookMan.GetVtblIdx();
   480 
   481 				break;
   482 			}
   483 
   484 			CVfnPtr &vfnPtr = hookMan.GetVfnPtr(cur_vfnptr);
   485 			CIface &ifaceinst = vfnPtr.GetIface(adjustediface);
   486 
   487 			// Add the hook
   488 			CHook hook(plug, thisptr_offs, handler, 
   489 
   490 				m_HookIDMan.New(hookMan.GetProto(), hookMan.GetVtblOffs(), hookMan.GetVtblIdx(),
   491 					cur_vfnptr, adjustediface, plug, thisptr_offs, handler, post)
   492 
   493 				);
   494 
   495 			if (post)
   496 				ifaceinst.GetPostHookList().push_back(hook);
   497 			else
   498 				ifaceinst.GetPreHookList().push_back(hook);
   499 
   500 			return hook.GetID();
   501 		}
   502 
   503 		bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
   504 			ISHDelegate *handler, bool post)
   505 		{
   506 			// Get info about hook manager and compute adjustediface
   507 			CHookManager tmpHookMan(plug, myHookMan);
   508 
   509 			void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
   510 
   511 			// Loop through all hooks and remove those which match:
   512 			//  hookman, vfnptr, iface, plug, adjusted iface, this ptr offs, handler, post
   513 			CVector<int> removehooks;
   514 			m_HookIDMan.FindAllHooks(removehooks, tmpHookMan.GetProto(), tmpHookMan.GetVtblOffs(), tmpHookMan.GetVtblIdx(),
   515 				adjustediface, plug, thisptr_offs, handler, post);
   516 
   517 			if (removehooks.empty())
   518 				return false;
   519 
   520 			bool status = false;
   521 
   522 			for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
   523 			{
   524 				if (RemoveHookByID(*iter))
   525 					status = true;
   526 			}
   527 			return status; 
   528 		}
   529 
   530 		bool CSourceHookImpl::RemoveHookByID(int hookid)
   531 		{
   532 			const CHookIDManager::Entry *hentry;
   533 
   534 			hentry = m_HookIDMan.QueryHook(hookid);
   535 			if (!hentry)
   536 			{
   537 				// hookid doesn't exist !
   538 				return false;
   539 			}
   540 
   541 			// find hookman
   542 			CHookManContainerList::iterator hmcl_iter = m_HookManContainers.find(
   543 				CHookManagerContainer::Descriptor(hentry->vtbl_offs, hentry->vtbl_idx, hentry->proto));
   544 
   545 			if (hmcl_iter == m_HookManContainers.end() || !(*hmcl_iter))
   546 				return false;
   547 
   548 			CHookManager &hookman = hmcl_iter->GetActiveHookManager();
   549 
   550 			// find vfnptr
   551 			List<CVfnPtr>::iterator vfnptr_iter = hookman.GetVfnPtrList().find(hentry->vfnptr);
   552 			if (vfnptr_iter == hookman.GetVfnPtrList().end())
   553 				return false;
   554 
   555 			// find iface
   556 			List<CIface>::iterator iface_iter = vfnptr_iter->GetIfaceList().find(hentry->adjustediface);
   557 			if (iface_iter == vfnptr_iter->GetIfaceList().end())
   558 				return false;
   559 
   560 			// find hook
   561 			List<CHook> &hooks = hentry->post ? iface_iter->GetPostHookList() : iface_iter->GetPreHookList();
   562 			List<CHook>::iterator hook_iter = hooks.find(hookid);
   563 			if (hook_iter == hooks.end())
   564 				return false;
   565 
   566 			hook_iter->GetHandler()->DeleteThis();
   567 
   568 			// Iterator movage!
   569 			List<CHook>::iterator oldhookiter = hook_iter;
   570 			hook_iter = hooks.erase(hook_iter);
   571 
   572 			for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
   573 				ctx_iter != m_ContextStack.end(); ++ctx_iter)
   574 			{
   575 				ctx_iter->HookRemoved(oldhookiter, hook_iter);
   576 			}
   577 
   578 			if (iface_iter->GetPreHookList().empty() && iface_iter->GetPostHookList().empty())
   579 			{
   580 				// -> Kill all contexts that use it!
   581 				for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
   582 					ctx_iter != m_ContextStack.end(); ++ctx_iter)
   583 				{
   584 					ctx_iter->IfaceRemoved(&(*iface_iter));
   585 				}
   586 
   587 				// There are no hooks on this iface anymore...
   588 				iface_iter = vfnptr_iter->GetIfaceList().erase(iface_iter);
   589 
   590 				if (vfnptr_iter->GetIfaceList().empty())
   591 				{
   592 					// No ifaces at all -> Deactivate the hook
   593 
   594 					for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
   595 						ctx_iter != m_ContextStack.end(); ++ctx_iter)
   596 					{
   597 						ctx_iter->VfnPtrRemoved(&(*vfnptr_iter));
   598 					}
   599 
   600 					// Only patch the vfnptr back if the module is still in memory
   601 					// If it's not, do not remove stuff like we did before
   602 					// First off we did it wrong (shutdown the whole hookman, uh..) and secondly applications may be
   603 					// confused by RemoveHook returning false then (yeah, I know, I made this one up, no one checks for RemoveHook error)
   604 					if (ModuleInMemory(reinterpret_cast<char*>(vfnptr_iter->GetPtr()), SH_PTRSIZE))
   605 					{
   606 						vfnptr_iter->Revert();
   607 					}
   608 
   609 					hookman.GetVfnPtrList().erase(vfnptr_iter);
   610 
   611 					if (hookman.GetVfnPtrList().empty())
   612 					{
   613 						// Unregister the hook manager
   614 						hookman.Unregister();
   615 					}
   616 				}
   617 			}
   618 
   619 			m_HookIDMan.Remove(hookid);
   620 			return true;
   621 		}
   622 
   623 		void CSourceHookImpl::SetRes(META_RES res)
   624 		{
   625 			*m_ContextStack.front().pCurRes = res;
   626 		}
   627 
   628 		META_RES CSourceHookImpl::GetPrevRes()
   629 		{
   630 			return *m_ContextStack.front().pPrevRes;
   631 		}
   632 
   633 		META_RES CSourceHookImpl::GetStatus()
   634 		{
   635 			return *m_ContextStack.front().pStatus;
   636 
   637 		}
   638 
   639 		const void *CSourceHookImpl::GetOrigRet()
   640 		{
   641 			return m_ContextStack.front().pOrigRet;
   642 		}
   643 
   644 		const void *CSourceHookImpl::GetOverrideRet()
   645 		{
   646 			return (*m_ContextStack.front().pStatus < MRES_OVERRIDE) ?
   647 				NULL : m_ContextStack.front().pOverrideRet;
   648 		}
   649 
   650 		void *CSourceHookImpl::GetIfacePtr()
   651 		{
   652 			// If in recall: return last one
   653 			if (m_ContextStack.front().m_State >= CHookContext::State_Recall_Pre &&
   654 				m_ContextStack.front().m_State <= CHookContext::State_Recall_PostVP)
   655 			{
   656 				return m_ContextStack.second().pIfacePtr;
   657 			}
   658 			else
   659 			{
   660 				return m_ContextStack.front().pIfacePtr;
   661 			}
   662 		}
   663 
   664 		void *CSourceHookImpl::GetOverrideRetPtr()
   665 		{
   666 			return m_ContextStack.front().pOverrideRet;
   667 		}
   668 
   669 		void CSourceHookImpl::UnloadPlugin(Plugin plug)
   670 		{
   671 			// 1) Remove all hooks by this plugin
   672 
   673 			CVector<int> removehooks;
   674 			m_HookIDMan.FindAllHooks(removehooks, plug);
   675 
   676 			for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
   677 				RemoveHookByID(*iter);
   678 
   679 			// 2) Remove all hook managers
   680 			m_HookManContainers.RemoveHookMans(plug);
   681 		}
   682 
   683 		void CSourceHookImpl::RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc)
   684 		{
   685 			// 1) Remove all its hooks
   686 			CVector<int> removehooks;
   687 
   688 			// Get info about hook manager
   689 			CHookManager hookManager(plug, pubFunc);
   690 			if (!hookManager)
   691 				return;
   692 
   693 			// Make sure that the container exists
   694 			CHookManagerContainer &container = m_HookManContainers.GetContainer(hookManager.GetVtblOffs(),
   695 				hookManager.GetVtblIdx(), hookManager.GetProto());
   696 
   697 			CHookManagerContainer::iterator cont_iter = container.find(CHookManager::Descriptor(plug, pubFunc));
   698 
   699 			for (List<CVfnPtr>::iterator vfnptr_iter = cont_iter->GetVfnPtrList().begin();
   700 				vfnptr_iter != cont_iter->GetVfnPtrList().end(); ++vfnptr_iter)
   701 			{
   702 				for (List<CIface>::iterator iface_iter = vfnptr_iter->GetIfaceList().begin();
   703 					iface_iter != vfnptr_iter->GetIfaceList().end(); ++iface_iter)
   704 				{
   705 					List<CHook>::iterator hook_iter;
   706 					for (hook_iter = iface_iter->GetPreHookList().begin();
   707 						hook_iter != iface_iter->GetPreHookList().end(); ++hook_iter)
   708 						removehooks.push_back(hook_iter->GetID());
   709 
   710 					for (hook_iter = iface_iter->GetPostHookList().begin();
   711 						hook_iter != iface_iter->GetPostHookList().end(); ++hook_iter)
   712 						removehooks.push_back(hook_iter->GetID());
   713 				}
   714 			}
   715 
   716 			for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
   717 				RemoveHookByID(*iter);
   718 
   719 			// 2) Remove it
   720 			container.RemoveHookMans(plug, pubFunc);
   721 		}
   722 
   723 		void CSourceHookImpl::SetIgnoreHooks(void *vfnptr)
   724 		{
   725 			CHookContext ctx;
   726 			ctx.m_State = CHookContext::State_Ignore;
   727 			m_ContextStack.push(ctx);
   728 		}
   729 
   730 		void CSourceHookImpl::ResetIgnoreHooks(void *vfnptr)
   731 		{
   732 			if (!m_ContextStack.empty() && m_ContextStack.front().m_State == CHookContext::State_Ignore)
   733 				m_ContextStack.pop();
   734 		}
   735 
   736 		void CSourceHookImpl::DoRecall()
   737 		{
   738 			CHookContext newCtx;
   739 			CHookContext &curCtx = m_ContextStack.front();
   740 
   741 
   742 			newCtx.m_State = curCtx.m_State + (CHookContext::State_Recall_Pre - CHookContext::State_Pre);
   743 			if (newCtx.m_State == CHookContext::State_Recall_Post || newCtx.m_State == CHookContext::State_Recall_PostVP)
   744 			{
   745 				// Also save orig ret
   746 				newCtx.pOrigRet = curCtx.pOrigRet;
   747 			}
   748 
   749 			// The hookfunc usually does this, but it won't have a chance to see it, 
   750 			// so for recalls, we update status here if it's required
   751 			if (*curCtx.pCurRes > *curCtx.pStatus) 
   752 				*curCtx.pStatus = *curCtx.pCurRes;
   753 
   754 			newCtx.pStatus = curCtx.pStatus;
   755 			newCtx.pOverrideRet = curCtx.pOverrideRet;
   756 			newCtx.pPrevRes = curCtx.pPrevRes;
   757 			newCtx.m_Iter = curCtx.m_Iter;
   758 
   759 			// Take this with us!
   760 			newCtx.pCurRes = curCtx.pCurRes;
   761 
   762 			m_ContextStack.push(newCtx);
   763 			curCtx.m_State = CHookContext::State_Dead;
   764 		}
   765 
   766 		IHookContext *CSourceHookImpl::SetupHookLoop(IHookManagerInfo *hi, void *vfnptr, void *thisptr, void **origentry, META_RES *statusPtr,
   767 			META_RES *prevResPtr, META_RES *curResPtr, const void *origRetPtr, void *overrideRetPtr)
   768 		{
   769 			CHookContext *pCtx = NULL;
   770 			CHookContext *oldctx = m_ContextStack.empty() ? NULL : &m_ContextStack.front();
   771 			if (oldctx)
   772 			{
   773 				// SH_CALL
   774 				if (oldctx->m_State == CHookContext::State_Ignore)
   775 				{
   776 					*statusPtr = MRES_IGNORED;
   777 					oldctx->m_State = CHookContext::State_Dead;
   778 
   779 					List<CVfnPtr> &vfnptrList = static_cast<CHookManager*>(hi)->GetVfnPtrList();
   780 					List<CVfnPtr>::iterator vfnptr_iter = vfnptrList.find(vfnptr);
   781 					if (vfnptr_iter == vfnptrList.end())
   782 					{
   783 						// :TODO: what??
   784 					}
   785 					else
   786 					{
   787 						*origentry = vfnptr_iter->GetOrigEntry();
   788 					}
   789 
   790 					oldctx->pOrigRet = origRetPtr;
   791 					return oldctx;
   792 				}
   793 				// Recall
   794 				else if (oldctx->m_State >= CHookContext::State_Recall_Pre &&
   795 					oldctx->m_State <= CHookContext::State_Recall_PostVP)
   796 				{
   797 					pCtx = oldctx;
   798 
   799 					*statusPtr = *(oldctx->pStatus);
   800 					*prevResPtr = *(oldctx->pPrevRes);
   801 
   802 					pCtx->m_Iter = oldctx->m_Iter;
   803 
   804 					// Only have possibility of calling the orig func in pre recall mode
   805 					pCtx->m_CallOrig = (oldctx->m_State == CHookContext::State_Recall_Pre || 
   806 						oldctx->m_State == CHookContext::State_Recall_PreVP);
   807 
   808 					overrideRetPtr = pCtx->pOverrideRet;
   809 
   810 					// When the status is low so there's no override return value and we're in a post recall,
   811 					// give it the orig return value as override return value.
   812 					if (pCtx->m_State == CHookContext::State_Recall_Post ||
   813 						pCtx->m_State == CHookContext::State_Recall_PostVP)
   814 					{
   815 						origRetPtr = oldctx->pOrigRet;
   816 						if (*statusPtr < MRES_OVERRIDE)
   817 							overrideRetPtr = const_cast<void*>(pCtx->pOrigRet);
   818 					}
   819 				}
   820 			}
   821 			if (!pCtx)
   822 			{
   823 				pCtx = m_ContextStack.make_next();
   824 				pCtx->m_State = CHookContext::State_Born;
   825 				pCtx->m_CallOrig = true;
   826 			}
   827 
   828 			pCtx->pIface = NULL;
   829 
   830 			List<CVfnPtr> &vfnptrList = static_cast<CHookManager*>(hi)->GetVfnPtrList();
   831 			List<CVfnPtr>::iterator vfnptr_iter = vfnptrList.find(vfnptr);
   832 			if (vfnptr_iter == vfnptrList.end())
   833 			{
   834 				pCtx->m_State = CHookContext::State_Dead;
   835 			}
   836 			else
   837 			{
   838 				pCtx->pVfnPtr = &(*vfnptr_iter);
   839 				*origentry = vfnptr_iter->GetOrigEntry();
   840 				pCtx->pIface = vfnptr_iter->FindIface(thisptr);
   841 			}
   842 
   843 			pCtx->pStatus = statusPtr;
   844 			pCtx->pPrevRes = prevResPtr;
   845 			pCtx->pCurRes = curResPtr;
   846 			pCtx->pThisPtr = thisptr;
   847 			pCtx->pOverrideRet = overrideRetPtr;
   848 			pCtx->pOrigRet = origRetPtr;
   849 
   850 			return pCtx;
   851 		}
   852 
   853 		void CSourceHookImpl::EndContext(IHookContext *pCtx)
   854 		{
   855 			m_ContextStack.pop();
   856 		}
   857 
   858 		void CSourceHookImpl::CompleteShutdown()
   859 		{
   860 			CVector<int> removehooks;
   861 			m_HookIDMan.FindAllHooks(removehooks);
   862 
   863 			for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
   864 				RemoveHookByID(*iter);
   865 		}
   866 
   867 		void CSourceHookImpl::PausePlugin(Plugin plug)
   868 		{
   869 			CVector<int> pausehooks;
   870 			m_HookIDMan.FindAllHooks(pausehooks, plug);
   871 
   872 			for (CVector<int>::iterator iter = pausehooks.begin(); iter != pausehooks.end(); ++iter)
   873 				PauseHookByID(*iter);
   874 		}
   875 
   876 		void CSourceHookImpl::UnpausePlugin(Plugin plug)
   877 		{
   878 			CVector<int> unpausehooks;
   879 			m_HookIDMan.FindAllHooks(unpausehooks, plug);
   880 
   881 			for (CVector<int>::iterator iter = unpausehooks.begin(); iter != unpausehooks.end(); ++iter)
   882 				UnpauseHookByID(*iter);
   883 		}
   884 
   885 		bool CSourceHookImpl::PauseHookByID(int hookid)
   886 		{
   887 			return SetHookPaused(hookid, true);
   888 		}
   889 
   890 		bool CSourceHookImpl::UnpauseHookByID(int hookid)
   891 		{
   892 			return SetHookPaused(hookid, false);
   893 		}
   894 
   895 		bool CSourceHookImpl::SetHookPaused(int hookid, bool paused)
   896 		{
   897 			const CHookIDManager::Entry *hentry;
   898 
   899 			hentry = m_HookIDMan.QueryHook(hookid);
   900 			if (!hentry)
   901 			{
   902 				// hookid doesn't exist !
   903 				return false;
   904 			}
   905 
   906 			// find hookman
   907 			CHookManContainerList::iterator hmcl_iter = m_HookManContainers.find(
   908 				CHookManagerContainer::Descriptor(hentry->vtbl_offs, hentry->vtbl_idx, hentry->proto));
   909 
   910 			if (hmcl_iter == m_HookManContainers.end() || !(*hmcl_iter))
   911 				return false;
   912 
   913 			CHookManager &hookman = hmcl_iter->GetActiveHookManager();
   914 
   915 			// find vfnptr
   916 			List<CVfnPtr>::iterator vfnptr_iter = hookman.GetVfnPtrList().find(hentry->vfnptr);
   917 			if (vfnptr_iter == hookman.GetVfnPtrList().end())
   918 				return false;
   919 
   920 			// find iface
   921 			List<CIface>::iterator iface_iter = vfnptr_iter->GetIfaceList().find(hentry->adjustediface);
   922 			if (iface_iter == vfnptr_iter->GetIfaceList().end())
   923 				return false;
   924 
   925 			// find hook
   926 			List<CHook> &hooks = hentry->post ? iface_iter->GetPostHookList() : iface_iter->GetPreHookList();
   927 			List<CHook>::iterator hook_iter = hooks.find(hookid);
   928 			if (hook_iter == hooks.end())
   929 				return false;
   930 
   931 			hook_iter->SetPaused(paused);
   932 			return true;
   933 		}
   934 
   935 		//////////////////////////////////////////////////////////////////////////
   936 		// CHookContext
   937 		//////////////////////////////////////////////////////////////////////////
   938 		ISHDelegate *CHookContext::GetNext()
   939 		{
   940 			CIface *pVPIface;
   941 
   942 			switch (m_State)
   943 			{
   944 			case State_Dead:
   945 				return NULL;
   946 
   947 			case State_Born:
   948 				m_Iter = List<CHook>::iterator();
   949 				m_State = State_Pre;
   950 
   951 				// fall-through
   952 			case State_Recall_Pre:
   953 				m_State = State_Pre;
   954 			case State_Pre:
   955 				if (pIface)
   956 				{
   957 					if (!m_Iter)
   958 						m_Iter = pIface->GetPreHookList().begin();
   959 					else
   960 						++m_Iter;
   961 					SkipPaused(m_Iter, pIface->GetPreHookList());
   962 
   963 					if (m_Iter != pIface->GetPreHookList().end())
   964 					{
   965 						pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
   966 						return m_Iter->GetHandler();
   967 					}
   968 				}
   969 
   970 				// end of normal hooks -> VP
   971 				
   972 				m_State = State_PreVP;
   973 				m_Iter = List<CHook>::iterator();
   974 
   975 				// fall-through
   976 			case State_Recall_PreVP:
   977 				m_State = State_PreVP;
   978 			case State_PreVP:
   979 				pVPIface = pVfnPtr->FindIface(NULL);
   980 				if (pVPIface)
   981 				{
   982 					if (!m_Iter)
   983 						m_Iter = pVPIface->GetPreHookList().begin();
   984 					else
   985 						++m_Iter;
   986 					SkipPaused(m_Iter, pVPIface->GetPreHookList());
   987 
   988 					if (m_Iter != pVPIface->GetPreHookList())
   989 					{
   990 						pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
   991 						return m_Iter->GetHandler();
   992 					}
   993 				}
   994 
   995 				// end VP hooks -> orig call
   996 
   997 				m_State = State_OrigCall;
   998 				return NULL;
   999 				
  1000 			case State_OrigCall:
  1001 				m_Iter = List<CHook>::iterator();
  1002 				m_State = State_Post;
  1003 
  1004 				// fall-through
  1005 			case State_Post:
  1006 				if (pIface)
  1007 				{
  1008 					if (!m_Iter)
  1009 						m_Iter = pIface->GetPostHookList().begin();
  1010 					else
  1011 						++m_Iter;
  1012 					SkipPaused(m_Iter, pIface->GetPostHookList());
  1013 
  1014 					if (m_Iter != pIface->GetPostHookList().end())
  1015 					{
  1016 						pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
  1017 						return m_Iter->GetHandler();
  1018 					}
  1019 				}
  1020 				// end of normal hooks -> VP
  1021 
  1022 				m_State = State_PostVP;
  1023 				m_Iter = List<CHook>::iterator();
  1024 
  1025 				// fall-through
  1026 			case State_PostVP:
  1027 				pVPIface = pVfnPtr->FindIface(NULL);
  1028 				if (pVPIface)
  1029 				{
  1030 					if (!m_Iter)
  1031 						m_Iter = pVPIface->GetPostHookList().begin();
  1032 					else
  1033 						++m_Iter;
  1034 					SkipPaused(m_Iter, pVPIface->GetPostHookList());
  1035 
  1036 					if (m_Iter != pVPIface->GetPostHookList())
  1037 					{
  1038 						pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
  1039 						return m_Iter->GetHandler();
  1040 					}
  1041 				}
  1042 
  1043 				// end VP hooks -> done
  1044 
  1045 				m_State = State_Dead;
  1046 				return NULL;
  1047 
  1048 			case State_Recall_Post:
  1049 				// Skip pre hooks _and_ orig call
  1050 				m_State = State_Post;
  1051 				return NULL;
  1052 
  1053 			case State_Recall_PostVP:
  1054 				// Skip pre hooks _and_ orig call
  1055 				m_State = State_PostVP;
  1056 				return NULL;
  1057 			}
  1058 			return NULL;
  1059 		}
  1060 
  1061 		void *CHookContext::GetOverrideRetPtr()
  1062 		{
  1063 			return pOverrideRet;
  1064 		}
  1065 
  1066 		const void *CHookContext::GetOrigRetPtr()
  1067 		{
  1068 			return pOrigRet;
  1069 		}
  1070 
  1071 		bool CHookContext::ShouldCallOrig()
  1072 		{
  1073 			return m_CallOrig;
  1074 		}
  1075 
  1076 		void CHookContext::HookRemoved(List<CHook>::iterator oldhookiter, List<CHook>::iterator nexthookiter)
  1077 		{
  1078 			if (m_Iter == oldhookiter)
  1079 			{
  1080 				m_Iter = nexthookiter;
  1081 				--m_Iter;
  1082 			}
  1083 		}
  1084 
  1085 		void CHookContext::IfaceRemoved(CIface *iface)
  1086 		{
  1087 			if (pIface == iface)
  1088 				pIface = NULL;
  1089 		}
  1090 
  1091 		void CHookContext::VfnPtrRemoved(CVfnPtr *vfnptr)
  1092 		{
  1093 			if (pVfnPtr == vfnptr)
  1094 			{
  1095 				pVfnPtr = NULL;
  1096 				m_State = State_Dead;
  1097 			}
  1098 		}
  1099 	}
  1100 }