1 /* ======== SourceHook ========
2 * Copyright (C) 2004-2007 Metamod:Source Development Team
3 * No warranties of any kind
7 * Author(s): Pavol "PM OnoTo" Marko
8 * Contributors: Scott "Damaged Soul" Ehlert
9 * ============================
13 * @file sourcehook.cpp
14 * @brief Contains the implementation of the SourceHook API
21 #include "sourcehook_impl.h"
26 int HashFunction<int>(const int & k)
31 int Compare<int>(const int & k1, const int & k2)
44 //////////////////////////////////////////////////////////////////////////
46 //////////////////////////////////////////////////////////////////////////
47 void CProto::Fill(const ProtoInfo *pProto)
52 m_ParamsPassInfo.clear();
54 if (pProto->paramsPassInfo[0].size == 0)
58 m_Convention = pProto->convention;
59 m_NumOfParams = pProto->numOfParams;
61 m_RetPassInfo.size = pProto->retPassInfo.size;
62 m_RetPassInfo.type = pProto->retPassInfo.type;
63 m_RetPassInfo.flags = GetRealFlags(pProto->retPassInfo);
65 m_RetPassInfo.pNormalCtor = NULL;
66 m_RetPassInfo.pCopyCtor = NULL;
67 m_RetPassInfo.pDtor = NULL;
68 m_RetPassInfo.pAssignOperator = NULL;
71 m_ParamsPassInfo.resize(pProto->numOfParams);
73 for (int i = 1; i <= pProto->numOfParams; ++i)
75 m_ParamsPassInfo[i-1].size = pProto->paramsPassInfo[i].size;
76 m_ParamsPassInfo[i-1].type = pProto->paramsPassInfo[i].type;
77 m_ParamsPassInfo[i-1].flags = GetRealFlags(pProto->paramsPassInfo[i]);
79 m_ParamsPassInfo[i-1].pNormalCtor = NULL;
80 m_ParamsPassInfo[i-1].pCopyCtor = NULL;
81 m_ParamsPassInfo[i-1].pDtor = NULL;
82 m_ParamsPassInfo[i-1].pAssignOperator = NULL;
85 else if (pProto->paramsPassInfo[0].size == 1)
89 m_Convention = pProto->convention;
90 m_NumOfParams = pProto->numOfParams;
92 m_RetPassInfo.size = pProto->retPassInfo.size;
93 m_RetPassInfo.type = pProto->retPassInfo.type;
94 m_RetPassInfo.flags = pProto->retPassInfo.flags;
96 m_RetPassInfo.pNormalCtor = pProto->retPassInfo2.pNormalCtor;
97 m_RetPassInfo.pCopyCtor = pProto->retPassInfo2.pCopyCtor;
98 m_RetPassInfo.pDtor = pProto->retPassInfo2.pDtor;
99 m_RetPassInfo.pAssignOperator = pProto->retPassInfo2.pAssignOperator;
101 m_ParamsPassInfo.resize(pProto->numOfParams);
103 for (int i = 1; i <= pProto->numOfParams; ++i)
105 m_ParamsPassInfo[i-1].size = pProto->paramsPassInfo[i].size;
106 m_ParamsPassInfo[i-1].type = pProto->paramsPassInfo[i].type;
107 m_ParamsPassInfo[i-1].flags = pProto->paramsPassInfo[i].flags;
109 m_ParamsPassInfo[i-1].pNormalCtor = pProto->paramsPassInfo2[i].pNormalCtor;
110 m_ParamsPassInfo[i-1].pCopyCtor = pProto->paramsPassInfo2[i].pCopyCtor;
111 m_ParamsPassInfo[i-1].pDtor = pProto->paramsPassInfo2[i].pDtor;
112 m_ParamsPassInfo[i-1].pAssignOperator = pProto->paramsPassInfo2[i].pAssignOperator;
123 // Other than this, we assume that the plugins know what they're doing
124 bool CProto::operator == (const CProto &other) const
126 if (m_Version < 0 || other.GetVersion() < 0)
129 if (m_NumOfParams != other.GetNumOfParams())
132 if (m_Convention != ProtoInfo::CallConv_Unknown && other.GetConvention() != ProtoInfo::CallConv_Unknown &&
133 m_Convention != other.GetConvention())
136 if (GetRealSize(GetRet()) != GetRealSize(other.GetRet()))
139 for (int i = 0; i < m_NumOfParams; ++i)
141 if (GetRealSize(GetParam(i)) != GetRealSize(other.GetParam(i)))
143 if (GetParam(i).type != PassInfo::PassType_Unknown && other.GetParam(i).type != PassInfo::PassType_Unknown)
145 if (GetParam(i).type != other.GetParam(i).type)
147 if (GetParam(i).flags != other.GetParam(i).flags)
155 bool CProto::ExactlyEqual(const CProto &other) const
157 if (m_Version != other.m_Version ||
158 m_NumOfParams != other.m_NumOfParams ||
159 m_Convention != other.m_Convention ||
160 GetRet() != other.GetRet())
165 for (int i = 0; i < m_NumOfParams; ++i)
167 if(GetParam(i) != other.GetParam(i))
174 //////////////////////////////////////////////////////////////////////////
176 //////////////////////////////////////////////////////////////////////////
177 void CHookManager::SetInfo(int hookman_version, int vtbloffs, int vtblidx,
178 ProtoInfo *proto, void *hookfunc_vfnptr)
180 m_Version = hookman_version;
181 m_VtblOffs = vtbloffs;
184 m_HookfuncVfnptr = hookfunc_vfnptr;
187 //////////////////////////////////////////////////////////////////////////
189 //////////////////////////////////////////////////////////////////////////
191 CVfnPtr &CVfnPtrList::GetVfnPtr(void *vfnptr)
193 iterator iter = find(vfnptr);
196 CVfnPtr newVfnPtr(vfnptr);
197 push_back(newVfnPtr);
206 //////////////////////////////////////////////////////////////////////////
208 //////////////////////////////////////////////////////////////////////////
210 void CVfnPtr::AddHookMan(CHookManager *pHookMan)
212 List<CHookManager*>::iterator iter;
214 // Don't accept invalid hook managers
218 // Check whether this hook manager already exists; if yes, ignore.
219 iter = m_HookMans.find(pHookMan);
220 if (iter != m_HookMans.end())
223 // It doesn't -> add it. Add it to the end of its version group.
224 for (iter = m_HookMans.begin(); iter != m_HookMans.end(); ++iter)
226 if ((*iter)->GetVersion() < pHookMan->GetVersion())
230 bool isBeginning = iter == m_HookMans.begin();
232 m_HookMans.insert(iter, pHookMan);
236 pHookMan->IncrRef(this);
237 if (m_HookMans.size() > 1)
239 // If another hookman was used until now but this one is better
240 // (which it is because it's the first -> it has a higher version)
243 List<CHookManager*>::iterator second = m_HookMans.begin();
246 (*second)->DecrRef(this);
249 // Make sure that this vfnptr points at it
250 Patch(pHookMan->GetHookFunc());
254 bool CVfnPtr::HookManRemoved(CHookManager *pHookMan)
256 // Don't accept invalid hook managers
260 List<CHookManager*>::iterator iter = m_HookMans.find(pHookMan);
261 if (iter == m_HookMans.end())
262 return true; // Didn't exist here anyway
264 if (iter == m_HookMans.begin())
266 // It is the first one!
267 pHookMan->DecrRef(this);
268 m_HookMans.erase(iter);
270 if (m_HookMans.empty())
271 return false; // No more hookmans -> let SH delete us
273 // Activate second -> now first hookman
274 m_HookMans.front()->IncrRef(this);
275 Patch(m_HookMans.front()->GetHookFunc());
279 m_HookMans.erase(iter);
284 bool CVfnPtr::Patch(void *newValue)
286 if (!SetMemAccess(m_Ptr, sizeof(void*), SH_MEM_READ | SH_MEM_WRITE))
291 *reinterpret_cast<void**>(m_Ptr) = newValue;
296 CIface &CVfnPtr::GetIface(void *iface)
298 List<CIface>::iterator iter = m_IfaceList.find(iface);
299 if (iter == m_IfaceList.end())
301 CIface newIface(iface);
304 m_IfaceList.push_front(newIface);
305 return m_IfaceList.front();
309 m_IfaceList.push_back(newIface);
310 return m_IfaceList.back();
319 //////////////////////////////////////////////////////////////////////////
321 //////////////////////////////////////////////////////////////////////////
322 CHookIDManager::CHookIDManager()
326 int CHookIDManager::New(const CProto &proto, int vtbl_offs, int vtbl_idx, void *vfnptr,
327 void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
329 Entry tmp(proto, vtbl_offs, vtbl_idx, vfnptr, adjustediface, plug, thisptr_offs, handler, post);
331 size_t cursize = m_Entries.size();
332 for (size_t i = 0; i < cursize; ++i)
334 if (m_Entries[i].isfree)
337 return static_cast<int>(i) + 1;
341 m_Entries.push_back(tmp);
342 return static_cast<int>(m_Entries.size()); // return size() because hookid = id+1 anyway
345 bool CHookIDManager::Remove(int hookid)
347 int realid = hookid - 1;
348 if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
351 m_Entries[realid].isfree = true;
353 // :TODO: remove free ids from back sometimes ??
358 const CHookIDManager::Entry * CHookIDManager::QueryHook(int hookid)
360 int realid = hookid - 1;
361 if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
364 return &m_Entries[realid];
367 void CHookIDManager::FindAllHooks(CVector<int> &output, const CProto &proto, int vtbl_offs,
368 int vtbl_idx, void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
370 // oh my god, a lot of parameters...
371 size_t cursize = m_Entries.size();
372 for (size_t i = 0; i < cursize; ++i)
374 if (!m_Entries[i].isfree && m_Entries[i].proto == proto && m_Entries[i].vtbl_offs == vtbl_offs &&
375 m_Entries[i].vtbl_idx == vtbl_idx && m_Entries[i].adjustediface == adjustediface && m_Entries[i].plug == plug &&
376 m_Entries[i].thisptr_offs == thisptr_offs && m_Entries[i].handler->IsEqual(handler) && m_Entries[i].post == post)
378 output.push_back(static_cast<int>(i) + 1);
383 void CHookIDManager::FindAllHooks(CVector<int> &output)
385 size_t cursize = m_Entries.size();
386 for (size_t i = 0; i < cursize; ++i)
388 if (!m_Entries[i].isfree)
389 output.push_back(static_cast<int>(i) + 1);
393 void CHookIDManager::FindAllHooks(CVector<int> &output, Plugin plug)
395 size_t cursize = m_Entries.size();
396 for (size_t i = 0; i < cursize; ++i)
398 if (!m_Entries[i].isfree && m_Entries[i].plug == plug)
399 output.push_back(static_cast<int>(i) + 1);
404 void CHookIDManager::RemoveAll(void *vfnptr)
406 size_t cursize = m_Entries.size();
407 for (size_t i = 0; i < cursize; ++i)
409 if (!m_Entries[i].isfree && m_Entries[i].vfnptr == vfnptr)
410 m_Entries[i].isfree = true;
414 //////////////////////////////////////////////////////////////////////////
416 //////////////////////////////////////////////////////////////////////////
419 CSourceHookImpl::CSourceHookImpl()
422 CSourceHookImpl::~CSourceHookImpl()
427 int CSourceHookImpl::GetIfaceVersion()
429 return SH_IFACE_VERSION;
432 int CSourceHookImpl::GetImplVersion()
434 return SH_IMPL_VERSION;
437 int CSourceHookImpl::AddHook(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
438 ISHDelegate *handler, bool post)
440 if (mode != Hook_Normal && mode != Hook_VP && mode != Hook_DVP)
443 // Get info about hook manager
444 CHookManager hookManager(plug, myHookMan);
448 void *adjustediface = NULL;
449 void **cur_vtptr = NULL;
450 void *cur_vfnptr = NULL;
456 adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
458 cur_vtptr = *reinterpret_cast<void***>(
459 reinterpret_cast<char*>(adjustediface) + hookManager.GetVtblOffs());
460 cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + hookManager.GetVtblIdx());
465 adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
467 cur_vtptr = *reinterpret_cast<void***>(
468 reinterpret_cast<char*>(adjustediface) + hookManager.GetVtblOffs());
469 cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + hookManager.GetVtblIdx());
471 adjustediface = NULL;
475 adjustediface = NULL;
477 cur_vtptr = reinterpret_cast<void**>(iface);
478 cur_vfnptr = cur_vtptr + hookManager.GetVtblIdx();
483 CVfnPtr &vfnPtr = m_VfnPtrs.GetVfnPtr(cur_vfnptr);
484 vfnPtr.AddHookMan(m_HookManList.GetHookMan(hookManager));
485 CIface &ifaceinst = vfnPtr.GetIface(adjustediface);
488 CHook hook(plug, thisptr_offs, handler,
490 m_HookIDMan.New(hookManager.GetProto(), hookManager.GetVtblOffs(), hookManager.GetVtblIdx(),
491 cur_vfnptr, adjustediface, plug, thisptr_offs, handler, post)
496 ifaceinst.GetPostHookList().push_back(hook);
498 ifaceinst.GetPreHookList().push_back(hook);
503 bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
504 ISHDelegate *handler, bool post)
506 // Get info about hook manager and compute adjustediface
507 CHookManager tmpHookMan(plug, myHookMan);
509 void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
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);
517 if (removehooks.empty())
522 for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
524 if (RemoveHookByID(*iter))
530 bool CSourceHookImpl::RemoveHookByID(int hookid)
532 const CHookIDManager::Entry *hentry;
534 hentry = m_HookIDMan.QueryHook(hookid);
537 // hookid doesn't exist !
542 List<CVfnPtr>::iterator vfnptr_iter = m_VfnPtrs.find(hentry->vfnptr);
543 if (vfnptr_iter == m_VfnPtrs.end())
547 List<CIface>::iterator iface_iter = vfnptr_iter->GetIfaceList().find(hentry->adjustediface);
548 if (iface_iter == vfnptr_iter->GetIfaceList().end())
552 List<CHook> &hooks = hentry->post ? iface_iter->GetPostHookList() : iface_iter->GetPreHookList();
553 List<CHook>::iterator hook_iter = hooks.find(hookid);
554 if (hook_iter == hooks.end())
557 hook_iter->GetHandler()->DeleteThis();
560 List<CHook>::iterator oldhookiter = hook_iter;
561 hook_iter = hooks.erase(hook_iter);
563 for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
564 ctx_iter != m_ContextStack.end(); ++ctx_iter)
566 ctx_iter->HookRemoved(oldhookiter, hook_iter);
569 if (iface_iter->GetPreHookList().empty() && iface_iter->GetPostHookList().empty())
571 // -> Kill all contexts that use it!
572 for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
573 ctx_iter != m_ContextStack.end(); ++ctx_iter)
575 ctx_iter->IfaceRemoved(&(*iface_iter));
578 // There are no hooks on this iface anymore...
579 iface_iter = vfnptr_iter->GetIfaceList().erase(iface_iter);
581 if (vfnptr_iter->GetIfaceList().empty())
583 // No ifaces at all -> Deactivate the hook
585 for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
586 ctx_iter != m_ContextStack.end(); ++ctx_iter)
588 ctx_iter->VfnPtrRemoved(&(*vfnptr_iter));
591 vfnptr_iter->Revert();
593 m_VfnPtrs.erase(vfnptr_iter);
597 m_HookIDMan.Remove(hookid);
601 void CSourceHookImpl::SetRes(META_RES res)
603 *m_ContextStack.front().pCurRes = res;
606 META_RES CSourceHookImpl::GetPrevRes()
608 return *m_ContextStack.front().pPrevRes;
611 META_RES CSourceHookImpl::GetStatus()
613 return *m_ContextStack.front().pStatus;
617 const void *CSourceHookImpl::GetOrigRet()
619 return m_ContextStack.front().pOrigRet;
622 const void *CSourceHookImpl::GetOverrideRet()
624 return (*m_ContextStack.front().pStatus < MRES_OVERRIDE) ?
625 NULL : m_ContextStack.front().pOverrideRet;
628 void *CSourceHookImpl::GetIfacePtr()
630 // If in recall: return last one
631 if (m_ContextStack.front().m_State >= CHookContext::State_Recall_Pre &&
632 m_ContextStack.front().m_State <= CHookContext::State_Recall_PostVP)
634 return m_ContextStack.second().pIfacePtr;
638 return m_ContextStack.front().pIfacePtr;
642 void *CSourceHookImpl::GetOverrideRetPtr()
644 return m_ContextStack.front().pOverrideRet;
647 void CSourceHookImpl::UnloadPlugin(Plugin plug)
649 // 1) Remove all hooks by this plugin
651 CVector<int> removehooks;
652 m_HookIDMan.FindAllHooks(removehooks, plug);
654 for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
655 RemoveHookByID(*iter);
657 // 2) Remove all hook managers
658 for (CHookManList::iterator iter = m_HookManList.begin(); iter != m_HookManList.end(); )
660 if (iter->GetOwnerPlugin() == plug)
661 iter = RemoveHookManager(iter);
667 CHookManList::iterator CSourceHookImpl::RemoveHookManager(CHookManList::iterator hookman_iter)
670 for (CVfnPtrList::iterator vfnptr_iter = m_VfnPtrs.begin();
671 vfnptr_iter != m_VfnPtrs.end();)
673 if (!vfnptr_iter->HookManRemoved(&(*hookman_iter)))
675 // This vfnptr has no more hook managers
676 // and asks to be removed.
678 vfnptr_iter->Revert();
680 m_HookIDMan.RemoveAll(vfnptr_iter->GetPtr());
681 vfnptr_iter = m_VfnPtrs.erase(vfnptr_iter);
689 return m_HookManList.erase(hookman_iter);
692 void CSourceHookImpl::RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc)
694 // Find the hook manager
695 CHookManList::iterator hookman_iter = m_HookManList.find(CHookManager::Descriptor(plug, pubFunc));
697 if (hookman_iter != m_HookManList.end())
699 RemoveHookManager(hookman_iter);
703 void CSourceHookImpl::SetIgnoreHooks(void *vfnptr)
706 ctx.m_State = CHookContext::State_Ignore;
707 m_ContextStack.push(ctx);
710 void CSourceHookImpl::ResetIgnoreHooks(void *vfnptr)
712 if (!m_ContextStack.empty() && m_ContextStack.front().m_State == CHookContext::State_Ignore)
713 m_ContextStack.pop();
716 void *CSourceHookImpl::GetOrigVfnPtrEntry(void *vfnptr)
718 for (CVfnPtrList::iterator vfnptr_iter = m_VfnPtrs.begin(); vfnptr_iter != m_VfnPtrs.end(); ++vfnptr_iter)
720 if (vfnptr_iter->GetPtr() == vfnptr)
721 return vfnptr_iter->GetOrigEntry();
726 void CSourceHookImpl::DoRecall()
729 CHookContext &curCtx = m_ContextStack.front();
732 newCtx.m_State = curCtx.m_State + (CHookContext::State_Recall_Pre - CHookContext::State_Pre);
733 if (newCtx.m_State == CHookContext::State_Recall_Post || newCtx.m_State == CHookContext::State_Recall_PostVP)
735 // Also save orig ret
736 newCtx.pOrigRet = curCtx.pOrigRet;
739 // The hookfunc usually does this, but it won't have a chance to see it,
740 // so for recalls, we update status here if it's required
741 if (*curCtx.pCurRes > *curCtx.pStatus)
742 *curCtx.pStatus = *curCtx.pCurRes;
744 newCtx.pStatus = curCtx.pStatus;
745 newCtx.pOverrideRet = curCtx.pOverrideRet;
746 newCtx.pPrevRes = curCtx.pPrevRes;
747 newCtx.m_Iter = curCtx.m_Iter;
749 // Take this with us!
750 newCtx.pCurRes = curCtx.pCurRes;
752 m_ContextStack.push(newCtx);
753 curCtx.m_State = CHookContext::State_Dead;
756 IHookContext *CSourceHookImpl::SetupHookLoop(IHookManagerInfo *hi, void *vfnptr, void *thisptr, void **origentry, META_RES *statusPtr,
757 META_RES *prevResPtr, META_RES *curResPtr, const void *origRetPtr, void *overrideRetPtr)
759 CHookContext *pCtx = NULL;
760 CHookContext *oldctx = m_ContextStack.empty() ? NULL : &m_ContextStack.front();
764 if (oldctx->m_State == CHookContext::State_Ignore)
766 *statusPtr = MRES_IGNORED;
767 oldctx->m_CallOrig = true;
768 oldctx->m_State = CHookContext::State_Dead;
770 List<CVfnPtr*> &vfnptr_list = static_cast<CHookManager*>(hi)->GetVfnPtrList();
771 List<CVfnPtr*>::iterator vfnptr_iter;
772 for (vfnptr_iter = vfnptr_list.begin();
773 vfnptr_iter != vfnptr_list.end(); ++vfnptr_iter)
775 if (**vfnptr_iter == vfnptr)
778 if (vfnptr_iter == vfnptr_list.end())
780 SH_ASSERT(false, ("How can a hook exist on a vfnptr which we don't have in our db?!"));
784 *origentry = (*vfnptr_iter)->GetOrigEntry();
787 oldctx->pOrigRet = origRetPtr;
791 else if (oldctx->m_State >= CHookContext::State_Recall_Pre &&
792 oldctx->m_State <= CHookContext::State_Recall_PostVP)
796 *statusPtr = *(oldctx->pStatus);
797 *prevResPtr = *(oldctx->pPrevRes);
799 pCtx->m_Iter = oldctx->m_Iter;
801 // Only have possibility of calling the orig func in pre recall mode
802 pCtx->m_CallOrig = (oldctx->m_State == CHookContext::State_Recall_Pre ||
803 oldctx->m_State == CHookContext::State_Recall_PreVP);
805 overrideRetPtr = pCtx->pOverrideRet;
807 // When the status is low so there's no override return value and we're in a post recall,
808 // give it the orig return value as override return value.
809 if (pCtx->m_State == CHookContext::State_Recall_Post ||
810 pCtx->m_State == CHookContext::State_Recall_PostVP)
812 origRetPtr = oldctx->pOrigRet;
813 if (*statusPtr < MRES_OVERRIDE)
814 overrideRetPtr = const_cast<void*>(pCtx->pOrigRet);
820 pCtx = m_ContextStack.make_next();
821 pCtx->m_State = CHookContext::State_Born;
822 pCtx->m_CallOrig = true;
827 List<CVfnPtr*> &vfnptr_list = static_cast<CHookManager*>(hi)->GetVfnPtrList();
828 List<CVfnPtr*>::iterator vfnptr_iter;
829 for (vfnptr_iter = vfnptr_list.begin();
830 vfnptr_iter != vfnptr_list.end(); ++vfnptr_iter)
832 if (**vfnptr_iter == vfnptr)
835 if (vfnptr_iter == vfnptr_list.end())
837 pCtx->m_State = CHookContext::State_Dead;
841 pCtx->pVfnPtr = *vfnptr_iter;
842 *origentry = pCtx->pVfnPtr->GetOrigEntry();
843 pCtx->pIface = pCtx->pVfnPtr->FindIface(thisptr);
846 pCtx->pStatus = statusPtr;
847 pCtx->pPrevRes = prevResPtr;
848 pCtx->pCurRes = curResPtr;
849 pCtx->pThisPtr = thisptr;
850 pCtx->pOverrideRet = overrideRetPtr;
851 pCtx->pOrigRet = origRetPtr;
856 void CSourceHookImpl::EndContext(IHookContext *pCtx)
858 m_ContextStack.pop();
861 void CSourceHookImpl::CompleteShutdown()
863 CVector<int> removehooks;
864 m_HookIDMan.FindAllHooks(removehooks);
866 for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
867 RemoveHookByID(*iter);
870 void CSourceHookImpl::PausePlugin(Plugin plug)
872 CVector<int> pausehooks;
873 m_HookIDMan.FindAllHooks(pausehooks, plug);
875 for (CVector<int>::iterator iter = pausehooks.begin(); iter != pausehooks.end(); ++iter)
876 PauseHookByID(*iter);
879 void CSourceHookImpl::UnpausePlugin(Plugin plug)
881 CVector<int> unpausehooks;
882 m_HookIDMan.FindAllHooks(unpausehooks, plug);
884 for (CVector<int>::iterator iter = unpausehooks.begin(); iter != unpausehooks.end(); ++iter)
885 UnpauseHookByID(*iter);
888 bool CSourceHookImpl::PauseHookByID(int hookid)
890 return SetHookPaused(hookid, true);
893 bool CSourceHookImpl::UnpauseHookByID(int hookid)
895 return SetHookPaused(hookid, false);
898 bool CSourceHookImpl::SetHookPaused(int hookid, bool paused)
900 const CHookIDManager::Entry *hentry;
902 hentry = m_HookIDMan.QueryHook(hookid);
905 // hookid doesn't exist !
910 List<CVfnPtr>::iterator vfnptr_iter = m_VfnPtrs.find(hentry->vfnptr);
911 if (vfnptr_iter == m_VfnPtrs.end())
915 List<CIface>::iterator iface_iter = vfnptr_iter->GetIfaceList().find(hentry->adjustediface);
916 if (iface_iter == vfnptr_iter->GetIfaceList().end())
920 List<CHook> &hooks = hentry->post ? iface_iter->GetPostHookList() : iface_iter->GetPreHookList();
921 List<CHook>::iterator hook_iter = hooks.find(hookid);
922 if (hook_iter == hooks.end())
925 hook_iter->SetPaused(paused);
929 //////////////////////////////////////////////////////////////////////////
931 //////////////////////////////////////////////////////////////////////////
932 ISHDelegate *CHookContext::GetNext()
941 m_Iter = List<CHook>::iterator();
945 case State_Recall_Pre:
951 m_Iter = pIface->GetPreHookList().begin();
954 SkipPaused(m_Iter, pIface->GetPreHookList());
956 if (m_Iter != pIface->GetPreHookList().end())
958 pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
959 return m_Iter->GetHandler();
963 // end of normal hooks -> VP
965 m_State = State_PreVP;
966 m_Iter = List<CHook>::iterator();
969 case State_Recall_PreVP:
970 m_State = State_PreVP;
972 pVPIface = pVfnPtr->FindIface(NULL);
976 m_Iter = pVPIface->GetPreHookList().begin();
979 SkipPaused(m_Iter, pVPIface->GetPreHookList());
981 if (m_Iter != pVPIface->GetPreHookList())
983 pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
984 return m_Iter->GetHandler();
988 // end VP hooks -> orig call
990 m_State = State_OrigCall;
994 m_Iter = List<CHook>::iterator();
995 m_State = State_Post;
1002 m_Iter = pIface->GetPostHookList().begin();
1005 SkipPaused(m_Iter, pIface->GetPostHookList());
1007 if (m_Iter != pIface->GetPostHookList().end())
1009 pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
1010 return m_Iter->GetHandler();
1013 // end of normal hooks -> VP
1015 m_State = State_PostVP;
1016 m_Iter = List<CHook>::iterator();
1020 pVPIface = pVfnPtr->FindIface(NULL);
1024 m_Iter = pVPIface->GetPostHookList().begin();
1027 SkipPaused(m_Iter, pVPIface->GetPostHookList());
1029 if (m_Iter != pVPIface->GetPostHookList())
1031 pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
1032 return m_Iter->GetHandler();
1036 // end VP hooks -> done
1038 m_State = State_Dead;
1041 case State_Recall_Post:
1042 // Skip pre hooks _and_ orig call
1043 m_State = State_Post;
1046 case State_Recall_PostVP:
1047 // Skip pre hooks _and_ orig call
1048 m_State = State_PostVP;
1054 void *CHookContext::GetOverrideRetPtr()
1056 return pOverrideRet;
1059 const void *CHookContext::GetOrigRetPtr()
1064 bool CHookContext::ShouldCallOrig()
1069 void CHookContext::HookRemoved(List<CHook>::iterator oldhookiter, List<CHook>::iterator nexthookiter)
1071 if (m_Iter == oldhookiter)
1073 m_Iter = nexthookiter;
1078 void CHookContext::IfaceRemoved(CIface *iface)
1080 if (pIface == iface)
1084 void CHookContext::VfnPtrRemoved(CVfnPtr *vfnptr)
1086 if (pVfnPtr == vfnptr)
1089 m_State = State_Dead;