pavolmarko@1: /* ======== SourceHook ======== ds@294: * Copyright (C) 2004-2007 Metamod:Source Development Team pavolmarko@1: * No warranties of any kind pavolmarko@1: * dvander@10: * License: zlib/libpng dvander@10: * dvander@10: * Author(s): Pavol "PM OnoTo" Marko pavolmarko@1: * ============================ pavolmarko@1: */ pavolmarko@1: pavolmarko@1: #ifndef __SOURCEHOOK_IMPL_H__ pavolmarko@1: #define __SOURCEHOOK_IMPL_H__ pavolmarko@1: pavolmarko@1: #include "sourcehook.h" pavolmarko@418: #include "sh_memory.h" pavolmarko@117: #include "sh_list.h" pavolmarko@117: #include "sh_vector.h" pavolmarko@117: #include "sh_tinyhash.h" pavolmarko@128: #include "sh_stack.h" ds@86: pavolmarko@163: /* pavolmarko@163: pavolmarko@163: IMPLEMENTATION INFO pavolmarko@163: pavolmarko@163: --------------------------------------- pavolmarko@380: :TODO: update ??? pavolmarko@380: pavolmarko@163: Protos ("Prototypes") pavolmarko@163: The purpose of protos is to provide the amount of type information about a function pavolmarko@163: which is required to be able to execute a function call without corrupting the stack. pavolmarko@233: Our protos do not fully do this, but they provide the size of the return value, the number of pavolmarko@233: parameters, and the size of each parameter, which is enough for most situations. pavolmarko@163: pavolmarko@163: There are two version of protos: pavolmarko@163: OLD: pavolmarko@163: C-Style strings. pavolmarko@163: pavolmarko@163: 0_void: pavolmarko@163: "attrib" pavolmarko@163: 1_void: pavolmarko@163: "attrib|param1_type" pavolmarko@163: 2_void: pavolmarko@163: "attrib|param1_type|param2_type pavolmarko@163: 0: pavolmarko@163: "attrib|ret_type" pavolmarko@163: 1: pavolmarko@163: "attrib|ret_type|param1_type" pavolmarko@163: 2: pavolmarko@163: "attrib|ret_type|param2_type" pavolmarko@163: pavolmarko@163: Old protos are deprecated. pavolmarko@163: pavolmarko@163: NEW: pavolmarko@163: New protos are in fact pointers to the ProtoInfo structure (see sourcehook.h) pavolmarko@163: pavolmarko@163: Old protos begin with a non-zero byte, new protos begin with a zero byte. pavolmarko@163: pavolmarko@163: Protos are usually stored in a CProto instance. pavolmarko@163: pavolmarko@163: --------------------------------------- pavolmarko@163: Hook managers and hook manager containers pavolmarko@163: Each hookman container is tied to _one_ proto/vtable index/vtable offset info. pavolmarko@163: Hookman containers then contain a list of hook managers provided by plugins, sorted by version. pavolmarko@163: (higher versions come first) pavolmarko@163: pavolmarko@163: Duplicate hook managers are ignored (ie. hook managers where proto, vtable index, vtable offset, pavolmarko@163: plugin, version are the same as in an already exisiting hook manager) pavolmarko@163: pavolmarko@163: A new hook manager is always added to the end of the version group in the corresponding pavolmarko@163: hook container. pavolmarko@163: pavolmarko@163: If the new hook manager was added to the beginning of the container (which only happens if pavolmarko@163: it is the first one or if it has a higher version than the previously first hook manager), pavolmarko@163: the now second hook manager is shut down and the new hook manager takes its job. pavolmarko@163: pavolmarko@163: A "hook manager container id" (HMCI) consits of three values: proto, vtbl index, vtbl offset. pavolmarko@163: --------------------------------------- pavolmarko@163: Hooks pavolmarko@163: When adding a hook, first the proposed hook manager is added to the corresponding pavolmarko@163: hook manager container as described above. pavolmarko@163: pavolmarko@163: Then the first hook manager in the the manhook container is chosen to handle the function. pavolmarko@163: pavolmarko@163: Removing a hook does not neccessarily unreigster the plugin's hook manager. In order to do this, pavolmarko@163: use RemoveHookManager or UnloadPlugin/ pavolmarko@163: pavolmarko@163: Hooks can be paused - they remain in memory but they are not called. In SH, the hook iterator pavolmarko@163: classes handle pausing transparently. pavolmarko@163: pavolmarko@163: The hook loop is supposed to call ShouldContinue before each iteration. This makes hook handlers pavolmarko@163: able to remove themselves. pavolmarko@163: pavolmarko@163: --------------------------------------- pavolmarko@163: Call classes pavolmarko@328: pavolmarko@328: !! deprecated !! - see below (new SH_CALL) pavolmarko@328: pavolmarko@163: Call classes are identified by a this pointer and an instance size pavolmarko@163: pavolmarko@163: We use the instance size because a derived class instance and a base class instance could pavolmarko@163: have the same this pointers, and we want to avoid that the derived class pavolmarko@163: (which could be bigger) gets the same callclass as the base class (mainly if the pavolmarko@163: base class' callclass was requested first). pavolmarko@163: pavolmarko@163: Call classes are reference counted. pavolmarko@163: pavolmarko@163: The original function pointers are stored in a vector (in order to allow fast random access). pavolmarko@163: These vectors are stored as the value type of a hash. The key type is int and represents the pavolmarko@163: vtable offset. pavolmarko@163: pavolmarko@163: If the hash key doesn't exist or the vtblidx is out of range or the corresponding element in the pavolmarko@163: vector is NULL, there is no hook on that function. pavolmarko@163: pavolmarko@163: --------------------------------------- pavolmarko@163: Recalls pavolmarko@163: Recalls are used for the META_RETURN_(VALUE_)NEWPARAMS macros, ie. to change the parameters pavolmarko@163: in the hook loop on the fly. pavolmarko@163: pavolmarko@163: First, the macro calls DoRecall(), then it calls the function the hook is attached to -> it pavolmarko@163: calls the hookfunc. SourceHook makes sure that the newly invoked hook loop starts where the last pavolmarko@163: one left off and that status variables like status, previous result, override return are kept. pavolmarko@163: When this recurisvely called hookfunc returns, the macro returns what it returned pavolmarko@163: (using MRES_SUPERCEDE). CSourceHookImpl returns false from ShouldContinue so the original hook loop pavolmarko@163: is abandonned. pavolmarko@179: pavolmarko@179: Post Recalls pavolmarko@179: People wanted to be able to use META_RETURN_(VALUE_)NEWPARAMS from post hooks as well. Crazy people! pavolmarko@179: Anyway, for this, we have to know where a hook handler is. Is it executing pre or post hooks at the moment? pavolmarko@179: The only way we can know this is watching when it calls CHookList::GetIter(). So CHookList gets a new variable: pavolmarko@179: m_RequestedFlag. It also gets two new functions: RQFlagReset() and RQFlagGet(). pavolmarko@179: HookLoopBegin() calls RQFlagReset on both hooklists of the iface; then DoRecall() checks whether the postlist's pavolmarko@179: RQ flag is set. if yes, the hook loop is in post mode. pavolmarko@179: pavolmarko@179: So, what a about a recall in post mode? The first ShouldContinue returns false and sets Status to supercede. pavolmarko@179: This way the pre hooks and the function call will be skipped. Then, then next ShouldContinue returns true, so we get pavolmarko@179: into the post hooks. HA! pavolmarko@179: pavolmarko@179: Return Values in Post Recalls pavolmarko@179: The easy case is when we already have an override return value. In this case, the status register gets transferred, pavolmarko@179: and so does the override return pointer. So, basically, everything is ok. pavolmarko@179: pavolmarko@179: However, what happens if we don't? ie. the status register is on MRES_IGNORED? In this case we'd have to transfer the pavolmarko@179: orig ret value. But we can't: There's no way to tell the hookfunc: "Use this as orig ret pointer". It uses its own. pavolmarko@179: So, we emulate it. GetOrigRet will return the orig ret pointer from the old hook loop. If still no one overrides it, pavolmarko@179: we'd have to return it. BUT! HOW TO DO THIS? Check out SH_RETURN(). First calls HookLoopEnd(), then decides whether pavolmarko@179: to return the override retval or the orig retval. But it doesn't ask for a new override return. So we give the function pavolmarko@179: the last orig return value as its new override return value; but leave status where it is so everything works, and in pavolmarko@179: HookLoopEnd we make sure that status is high enough so that the override return will be returned. crazy. pavolmarko@179: pavolmarko@179: All this stuff could be much less complicated if I didn't try to preserve binary compatibility :) pavolmarko@324: pavolmarko@324: VP Hooks pavolmarko@324: VP hooks are hooks which are called on a vfnptr, regardless of the this pointer with which it was called. They are pavolmarko@324: implemented as a special CIface instance with m_Ptr = NULL. All Hook Lists have a new "ListCatIterator" which pavolmarko@324: virtually concatenates the NULL-interface-hook-list with their normal hook list. pavolmarko@324: pavolmarko@324: pavolmarko@324: I'm afraid that with the addition of Recalls and VP Hooks, SourceHook is now a pretty complex and hacked-together pavolmarko@324: binary compatible beast which is pretty hard to maintain unless you've written it :) pavolmarko@328: pavolmarko@328: New SH_CALL pavolmarko@328: The addition of VP hooks messed up the Call Classes concept (see above) - call classes are bound to an pavolmarko@328: instance pointer; they only work on one of the hooked instances. But VP hooks are called on all instances. pavolmarko@328: pavolmarko@328: That's why now, SH_CALL takes an instance pointer instead of a callclass pointer. It basically does this: pavolmarko@328: 1) call SH_GLOB_PTR->SetIgnoreHooks(vfnptr) pavolmarko@328: 2) call this->*mfp pavolmarko@328: 3) call SH_GLOB_PTR->ResetIgnoreHooks(vfnptr) pavolmarko@328: pavolmarko@328: SourceHook stroes the "ignored vfnptr" and makes CVfnPtr::FindIface return NULL if the CVfnPtr instance pavolmarko@328: corresponds to the ignored vfnptr. This way the hook manager thinks that the instance isn't hooked, and calls pavolmarko@328: the original function. Everything works fine. This works even for VP hooks. pavolmarko@163: */ pavolmarko@163: pavolmarko@380: #include "sourcehook_impl_cproto.h" pavolmarko@418: #include "sourcehook_impl_chookmaninfo.h" pavolmarko@380: #include "sourcehook_impl_chook.h" pavolmarko@380: #include "sourcehook_impl_ciface.h" pavolmarko@380: #include "sourcehook_impl_cvfnptr.h" pavolmarko@380: #include "sourcehook_impl_chookidman.h" pavolmarko@380: pavolmarko@1: namespace SourceHook pavolmarko@1: { pavolmarko@1: /** pavolmarko@380: * @brief The SourceHook implementation pavolmarko@1: */ pavolmarko@163: pavolmarko@380: namespace Impl pavolmarko@380: { pavolmarko@380: struct CHookContext : IHookContext pavolmarko@117: { pavolmarko@380: enum State pavolmarko@117: { pavolmarko@380: State_Born, pavolmarko@380: State_Pre, pavolmarko@380: State_PreVP, pavolmarko@380: State_Post, pavolmarko@380: State_PostVP, pavolmarko@380: State_OrigCall, pavolmarko@380: State_Dead, pavolmarko@117: pavolmarko@380: // Special pavolmarko@380: State_Ignore, pavolmarko@380: State_Recall_Pre, pavolmarko@380: State_Recall_PreVP, pavolmarko@380: State_Recall_Post, pavolmarko@380: State_Recall_PostVP pavolmarko@117: }; pavolmarko@117: pavolmarko@380: int m_State; pavolmarko@380: List::iterator m_Iter; pavolmarko@163: pavolmarko@380: CVfnPtr *pVfnPtr; pavolmarko@380: CIface *pIface; pavolmarko@380: pavolmarko@128: META_RES *pStatus; pavolmarko@128: META_RES *pPrevRes; pavolmarko@128: META_RES *pCurRes; pavolmarko@128: pavolmarko@380: void *pThisPtr; pavolmarko@128: const void *pOrigRet; pavolmarko@162: void *pOverrideRet; pavolmarko@380: void *pIfacePtr; pavolmarko@1: pavolmarko@380: bool m_CallOrig; pavolmarko@1: pavolmarko@380: void SkipPaused(List::iterator &iter, List &list) pavolmarko@380: { pavolmarko@380: while (iter != list.end() && iter->IsPaused()) pavolmarko@380: ++iter; pavolmarko@380: } pavolmarko@380: public: pavolmarko@380: void HookRemoved(List::iterator oldhookiter, List::iterator nexthookiter); pavolmarko@380: void IfaceRemoved(CIface *iface); pavolmarko@380: void VfnPtrRemoved(CVfnPtr *vfnptr); pavolmarko@58: pavolmarko@380: ISHDelegate *GetNext(); pavolmarko@380: void *GetOverrideRetPtr(); pavolmarko@380: const void *GetOrigRetPtr(); pavolmarko@380: bool ShouldCallOrig(); pavolmarko@380: }; pavolmarko@1: pavolmarko@418: class CVfnPtrList : public List pavolmarko@418: { pavolmarko@418: public: pavolmarko@418: CVfnPtr &GetVfnPtr(void *p); pavolmarko@418: }; pavolmarko@418: pavolmarko@380: typedef CStack HookContextStack; pavolmarko@418: pavolmarko@1: pavolmarko@380: class CSourceHookImpl : public ISourceHook pavolmarko@380: { pavolmarko@380: private: pavolmarko@418: CHookManList m_HookManList; pavolmarko@418: CVfnPtrList m_VfnPtrs; pavolmarko@380: CHookIDManager m_HookIDMan; pavolmarko@380: HookContextStack m_ContextStack; pavolmarko@1: pavolmarko@380: bool SetHookPaused(int hookid, bool paused); pavolmarko@418: CHookManList::iterator RemoveHookManager(CHookManList::iterator iter); pavolmarko@380: public: pavolmarko@380: CSourceHookImpl(); pavolmarko@380: virtual ~CSourceHookImpl(); pavolmarko@41: pavolmarko@380: /** pavolmarko@380: * @brief Returns the interface version pavolmarko@380: */ pavolmarko@380: int GetIfaceVersion(); pavolmarko@41: pavolmarko@380: /** pavolmarko@380: * @brief Returns the implemnetation version pavolmarko@380: */ pavolmarko@380: int GetImplVersion(); pavolmarko@1: pavolmarko@380: int AddHook(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, pavolmarko@380: ISHDelegate *handler, bool post); pavolmarko@8: pavolmarko@380: bool RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, pavolmarko@380: ISHDelegate *handler, bool post); pavolmarko@380: pavolmarko@380: bool RemoveHookByID(int hookid); pavolmarko@8: pavolmarko@380: bool PauseHookByID(int hookid); pavolmarko@380: bool UnpauseHookByID(int hookid); pavolmarko@1: pavolmarko@380: void SetRes(META_RES res); //!< Sets the meta result pavolmarko@380: META_RES GetPrevRes(); //!< Gets the meta result of the pavolmarko@380: //!< previously calledhandler pavolmarko@380: META_RES GetStatus(); //!< Gets the highest meta result pavolmarko@380: const void *GetOrigRet(); //!< Gets the original result. pavolmarko@380: //!< If not in post function, undefined pavolmarko@380: const void *GetOverrideRet(); //!< Gets the override result. pavolmarko@380: //!< If none is specified, NULL pavolmarko@380: void *GetIfacePtr(); //!< Gets the interface pointer pavolmarko@157: pavolmarko@380: void *GetOverrideRetPtr(); //!< Used for setting the override return value pavolmarko@163: pavolmarko@380: /** pavolmarko@380: * @brief Make sure that a plugin is not used by any other plugins anymore, and unregister all its hook managers pavolmarko@380: */ pavolmarko@380: void UnloadPlugin(Plugin plug); pavolmarko@162: pavolmarko@380: void RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc); pavolmarko@380: pavolmarko@380: void SetIgnoreHooks(void *vfnptr); pavolmarko@380: void ResetIgnoreHooks(void *vfnptr); pavolmarko@324: pavolmarko@380: void DoRecall(); pavolmarko@380: pavolmarko@380: IHookContext *SetupHookLoop(IHookManagerInfo *hi, void *vfnptr, void *thisptr, void **origentry, META_RES *statusPtr, pavolmarko@380: META_RES *prevResPtr, META_RES *curResPtr, const void *origRetPtr, void *overrideRetPtr); pavolmarko@380: pavolmarko@380: void EndContext(IHookContext *pCtx); pavolmarko@380: pavolmarko@386: void *GetOrigVfnPtrEntry(void *vfnptr); pavolmarko@386: pavolmarko@380: /** pavolmarko@380: * @brief Shut down the whole system, unregister all hook managers pavolmarko@380: */ pavolmarko@380: void CompleteShutdown(); pavolmarko@324: pavolmarko@380: /** pavolmarko@380: * @brief Pauses all hooks of a plugin pavolmarko@380: * pavolmarko@380: * @param plug The unique identifier of the plugin pavolmarko@380: */ pavolmarko@380: void PausePlugin(Plugin plug); pavolmarko@328: pavolmarko@380: /** pavolmarko@380: * @brief Unpauses all hooks of a plugin pavolmarko@380: * pavolmarko@380: * @param plug The unique identifier of the plugin pavolmarko@380: */ pavolmarko@380: void UnpausePlugin(Plugin plug); pavolmarko@380: }; pavolmarko@380: } pavolmarko@1: } pavolmarko@1: dvander@34: #endif