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@117: #include "sh_list.h" pavolmarko@117: #include "sh_vector.h" pavolmarko@117: #include "sh_tinyhash.h" pavolmarko@128: #include "sh_stack.h" pavolmarko@324: #include "sh_listcat.h" ds@86: pavolmarko@163: /* pavolmarko@163: pavolmarko@163: IMPLEMENTATION INFO pavolmarko@163: pavolmarko@163: --------------------------------------- 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@1: namespace SourceHook pavolmarko@1: { pavolmarko@1: /** pavolmarko@1: * @brief The SourceHook implementation class pavolmarko@1: */ pavolmarko@1: class CSourceHookImpl : public ISourceHook pavolmarko@1: { pavolmarko@117: private: pavolmarko@163: class CProto pavolmarko@163: { dvander@181: char *m_Proto; pavolmarko@163: pavolmarko@163: static bool Equal(const char *p1, const char *p2); dvander@181: char *DupProto(const char *src); dvander@181: void FreeProto(char *prot); pavolmarko@163: public: pavolmarko@324: CProto() : m_Proto(NULL) pavolmarko@324: { pavolmarko@324: } pavolmarko@324: dvander@181: CProto(const char *szProto) : m_Proto(DupProto(szProto)) pavolmarko@163: { pavolmarko@163: } pavolmarko@163: dvander@181: CProto(const CProto &other) : m_Proto(DupProto(other.m_Proto)) pavolmarko@163: { pavolmarko@163: } pavolmarko@163: dvander@181: ~CProto() dvander@181: { dvander@181: FreeProto(m_Proto); dvander@181: m_Proto = NULL; dvander@181: } dvander@181: pavolmarko@163: void operator = (const char *szProto) pavolmarko@163: { dvander@181: m_Proto = DupProto(szProto); pavolmarko@163: } dvander@181: pavolmarko@163: void operator = (const CProto &other) pavolmarko@163: { dvander@181: m_Proto = DupProto(other.m_Proto); pavolmarko@163: } pavolmarko@163: pavolmarko@163: bool operator == (const char *szProto) const pavolmarko@163: { pavolmarko@163: return Equal(szProto, m_Proto); pavolmarko@163: } pavolmarko@163: bool operator == (const CProto &other) const pavolmarko@163: { pavolmarko@163: return Equal(other.m_Proto, m_Proto); pavolmarko@163: } pavolmarko@324: pavolmarko@324: const char *GetProto() const pavolmarko@324: { pavolmarko@324: return m_Proto; pavolmarko@324: } pavolmarko@163: }; pavolmarko@163: pavolmarko@163: pavolmarko@1: /** pavolmarko@6: * @brief A hook can be removed if you have this information pavolmarko@1: */ pavolmarko@6: struct RemoveHookInfo pavolmarko@6: { pavolmarko@58: RemoveHookInfo(Plugin pplug, void *piface, int tpo, HookManagerPubFunc phookman, pavolmarko@41: ISHDelegate *phandler, bool ppost) pavolmarko@58: : plug(pplug), iface(piface), thisptr_offs(tpo), pavolmarko@58: hookman(phookman), handler(phandler), post(ppost) pavolmarko@6: { pavolmarko@6: } pavolmarko@6: pavolmarko@6: Plugin plug; pavolmarko@6: void *iface; pavolmarko@58: int thisptr_offs; pavolmarko@41: HookManagerPubFunc hookman; pavolmarko@6: ISHDelegate *handler; pavolmarko@6: bool post; pavolmarko@6: }; pavolmarko@6: pavolmarko@163: struct RemoveHookManInfo pavolmarko@163: { pavolmarko@163: RemoveHookManInfo(Plugin pplug, HookManagerPubFunc phookman) pavolmarko@163: : plug(pplug), hookman(phookman) pavolmarko@163: { pavolmarko@163: } pavolmarko@163: pavolmarko@163: Plugin plug; pavolmarko@163: HookManagerPubFunc hookman; pavolmarko@163: }; pavolmarko@163: pavolmarko@324: // Associates hook ids with info about the hooks pavolmarko@324: // Also used to keep track of used hook ids pavolmarko@324: class CHookIDManager pavolmarko@324: { pavolmarko@324: public: pavolmarko@324: struct Entry pavolmarko@324: { pavolmarko@324: bool isfree; pavolmarko@324: pavolmarko@324: // hookman info pavolmarko@324: CProto proto; pavolmarko@324: int vtbl_offs; pavolmarko@324: int vtbl_idx; pavolmarko@324: pavolmarko@324: // vfnptr pavolmarko@324: void *vfnptr; pavolmarko@324: pavolmarko@324: // iface pavolmarko@324: void* adjustediface; pavolmarko@324: pavolmarko@324: // hook pavolmarko@324: Plugin plug; pavolmarko@324: int thisptr_offs; pavolmarko@324: ISHDelegate *handler; pavolmarko@324: bool post; pavolmarko@324: pavolmarko@324: Entry(const CProto &pprt, int pvo, int pvi, void *pvp, void *pai, Plugin pplug, int pto, pavolmarko@324: ISHDelegate *ph, bool ppost) pavolmarko@324: : isfree(false), proto(pprt), vtbl_offs(pvo), vtbl_idx(pvi), vfnptr(pvp), pavolmarko@324: adjustediface(pai), plug(pplug), thisptr_offs(pto), handler(ph), post(ppost) pavolmarko@324: { pavolmarko@324: } pavolmarko@324: Entry() pavolmarko@324: { pavolmarko@324: } pavolmarko@324: }; pavolmarko@324: private: pavolmarko@324: // Internally, hookid 1 is stored as m_Entries[0] pavolmarko@324: pavolmarko@324: CVector m_Entries; pavolmarko@324: public: pavolmarko@324: CHookIDManager(); pavolmarko@324: int New(const CProto &proto, int vtbl_offs, int vtbl_idx, void *vfnptr, void *adjustediface, pavolmarko@324: Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post); pavolmarko@324: bool Remove(int hookid); pavolmarko@324: const Entry * QueryHook(int hookid); pavolmarko@324: pavolmarko@324: // Finds all hooks with the given info, and fills the hookids into output. pavolmarko@324: void FindAllHooks(CVector &output, const CProto &proto, int vtbl_offs, int vtbl_idx, pavolmarko@324: void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post); pavolmarko@324: pavolmarko@324: // Removes all hooks with a specified vfnptr pavolmarko@324: bool RemoveAll(void *vfnptr); pavolmarko@324: }; pavolmarko@324: pavolmarko@117: struct HookInfo pavolmarko@117: { pavolmarko@117: ISHDelegate *handler; //!< Pointer to the handler pavolmarko@117: bool paused; //!< If true, the hook should not be executed pavolmarko@117: Plugin plug; //!< The owner plugin pavolmarko@117: int thisptr_offs; //!< This pointer offset pavolmarko@324: int hookid; //!< Unique ID given by CHookIDManager pavolmarko@324: pavolmarko@324: bool operator==(int otherid) pavolmarko@324: { pavolmarko@324: return hookid == otherid; pavolmarko@324: } pavolmarko@117: }; pavolmarko@117: pavolmarko@117: class CHookList : public IHookList pavolmarko@117: { pavolmarko@117: public: pavolmarko@324: List *m_VPList; // left-hand list for ListCatIterator -> for VP hooks pavolmarko@117: List m_List; pavolmarko@117: pavolmarko@117: friend class CIter; pavolmarko@117: pavolmarko@117: class CIter : public IHookList::IIter pavolmarko@117: { pavolmarko@117: friend class CHookList; pavolmarko@117: pavolmarko@117: CHookList *m_pList; pavolmarko@117: pavolmarko@117: void SkipPaused(); pavolmarko@117: public: pavolmarko@121: pavolmarko@324: ListCatIterator m_Iter; pavolmarko@121: pavolmarko@117: CIter(CHookList *pList); pavolmarko@117: pavolmarko@117: virtual ~CIter(); pavolmarko@117: pavolmarko@117: void GoToBegin(); pavolmarko@162: void Set(CIter *pOther); pavolmarko@117: pavolmarko@117: bool End(); pavolmarko@117: void Next(); pavolmarko@117: ISHDelegate *Handler(); pavolmarko@117: int ThisPtrOffs(); pavolmarko@117: pavolmarko@121: void Clear(); pavolmarko@121: pavolmarko@121: CIter *m_pNext; // When stored in m_FreeIters and m_UsedIters pavolmarko@121: CIter *m_pPrev; // Only used when stored in m_UsedIters pavolmarko@117: }; pavolmarko@117: pavolmarko@117: CIter *m_FreeIters; pavolmarko@162: CIter *m_UsedIters; // The last returned and not-yet-released iter is always m_UsedIters pavolmarko@162: pavolmarko@162: // For recalls pavolmarko@162: bool m_Recall; pavolmarko@179: bool m_RQFlag; pavolmarko@162: pavolmarko@162: void SetRecallState(); // Sets the list into a state where the next returned pavolmarko@162: // iterator (from GetIter) will be a copy of the last pavolmarko@162: // returned iterator, incremented by one. This is used in Recalls. pavolmarko@162: // The hook resets this state automatically on: pavolmarko@162: // GetIter, ReleaseIter pavolmarko@117: pavolmarko@179: void RQFlagReset() { m_RQFlag = false; } pavolmarko@179: bool RQFlagGet() { return m_RQFlag; } pavolmarko@117: CHookList(); pavolmarko@117: CHookList(const CHookList &other); pavolmarko@117: virtual ~CHookList(); pavolmarko@117: pavolmarko@117: void operator=(const CHookList &other); pavolmarko@117: pavolmarko@117: IIter *GetIter(); pavolmarko@117: void ReleaseIter(IIter *pIter); pavolmarko@324: pavolmarko@324: void SetVPList(List *newList); pavolmarko@324: void ClearVPList(); pavolmarko@117: }; pavolmarko@117: pavolmarko@117: // I know, data hiding... But I'm a lazy bastard! pavolmarko@117: pavolmarko@117: class CIface : public IIface pavolmarko@117: { pavolmarko@117: public: pavolmarko@117: void *m_Ptr; pavolmarko@117: CHookList m_PreHooks; pavolmarko@117: CHookList m_PostHooks; pavolmarko@117: public: pavolmarko@117: CIface(void *ptr); pavolmarko@117: virtual ~CIface(); pavolmarko@117: pavolmarko@117: void *GetPtr(); pavolmarko@117: IHookList *GetPreHooks(); pavolmarko@117: IHookList *GetPostHooks(); pavolmarko@117: pavolmarko@117: bool operator==(void *ptr) pavolmarko@117: { pavolmarko@117: return m_Ptr == ptr; pavolmarko@117: } pavolmarko@324: bool operator!=(void *ptr) pavolmarko@324: { pavolmarko@324: return m_Ptr != ptr; pavolmarko@324: } pavolmarko@117: }; pavolmarko@1: pavolmarko@117: class CVfnPtr : public IVfnPtr pavolmarko@117: { pavolmarko@117: public: pavolmarko@117: typedef List IfaceList; pavolmarko@117: typedef IfaceList::iterator IfaceListIter; pavolmarko@117: pavolmarko@117: void *m_Ptr; pavolmarko@117: void *m_OrigEntry; pavolmarko@117: pavolmarko@117: IfaceList m_Ifaces; pavolmarko@117: pavolmarko@328: void **m_pOneIgnore; pavolmarko@117: public: pavolmarko@328: CVfnPtr(void *ptr, void **pOneIgnore); pavolmarko@117: virtual ~CVfnPtr(); pavolmarko@117: pavolmarko@117: void *GetVfnPtr(); pavolmarko@117: void *GetOrigEntry(); pavolmarko@117: pavolmarko@117: virtual IIface *FindIface(void *ptr); pavolmarko@117: pavolmarko@117: bool operator==(void *ptr) pavolmarko@117: { pavolmarko@117: return m_Ptr == ptr; pavolmarko@117: } pavolmarko@117: }; pavolmarko@117: pavolmarko@117: class CHookManagerInfo : public IHookManagerInfo pavolmarko@41: { pavolmarko@117: public: pavolmarko@117: typedef List VfnPtrList; pavolmarko@117: typedef VfnPtrList::iterator VfnPtrListIter; pavolmarko@117: pavolmarko@117: Plugin m_Plug; pavolmarko@117: HookManagerPubFunc m_Func; pavolmarko@117: pavolmarko@117: int m_VtblOffs; pavolmarko@117: int m_VtblIdx; pavolmarko@117: const char *m_Proto; pavolmarko@117: void *m_HookfuncVfnptr; pavolmarko@117: pavolmarko@117: VfnPtrList m_VfnPtrs; pavolmarko@117: pavolmarko@163: int m_HookManVersion; pavolmarko@117: public: pavolmarko@163: CHookManagerInfo(); pavolmarko@117: virtual ~CHookManagerInfo(); pavolmarko@117: pavolmarko@117: IVfnPtr *FindVfnPtr(void *vfnptr); pavolmarko@117: pavolmarko@117: void SetInfo(int vtbl_offs, int vtbl_idx, const char *proto); pavolmarko@117: void SetHookfuncVfnptr(void *hookfunc_vfnptr); pavolmarko@163: pavolmarko@163: void SetVersion(int version); pavolmarko@163: pavolmarko@163: bool operator < (const CHookManagerInfo &other) pavolmarko@163: { pavolmarko@163: return m_HookManVersion < other.m_HookManVersion; pavolmarko@163: } pavolmarko@163: pavolmarko@163: struct Descriptor pavolmarko@163: { pavolmarko@163: Descriptor(Plugin pplug, HookManagerPubFunc ppubFunc) : plug(pplug), pubFunc(ppubFunc) pavolmarko@163: { pavolmarko@163: } pavolmarko@163: pavolmarko@163: Plugin plug; pavolmarko@163: HookManagerPubFunc pubFunc; pavolmarko@163: }; pavolmarko@163: pavolmarko@163: bool operator == (const Descriptor desc) pavolmarko@163: { pavolmarko@163: return m_Func == desc.pubFunc && m_Plug == desc.plug; pavolmarko@163: } pavolmarko@117: }; pavolmarko@163: pavolmarko@117: typedef List HookManInfoList; pavolmarko@117: pavolmarko@163: class CHookManagerContainer : public HookManInfoList pavolmarko@163: { pavolmarko@163: public: pavolmarko@163: // HMCI (Hook Manager Container Identification) pavolmarko@163: class HMCI pavolmarko@163: { pavolmarko@163: CProto m_Proto; pavolmarko@163: int m_VtableOffset; pavolmarko@163: int m_VtableIndex; pavolmarko@163: public: pavolmarko@163: HMCI(const char *proto, int vtbloffs, int vtblidx) : pavolmarko@163: m_Proto(proto), m_VtableOffset(vtbloffs), m_VtableIndex(vtblidx) pavolmarko@163: { pavolmarko@163: } pavolmarko@163: ~HMCI() pavolmarko@163: { pavolmarko@163: } pavolmarko@163: pavolmarko@163: bool operator==(const HMCI &other) const pavolmarko@163: { pavolmarko@163: return pavolmarko@163: other.m_VtableIndex == m_VtableIndex && pavolmarko@163: other.m_Proto == m_Proto && pavolmarko@163: other.m_VtableOffset == m_VtableOffset; pavolmarko@163: } pavolmarko@163: pavolmarko@163: const CProto &GetProto() const pavolmarko@163: { pavolmarko@163: return m_Proto; pavolmarko@163: } pavolmarko@163: int GetVtableOffset() const pavolmarko@163: { pavolmarko@163: return m_VtableOffset; pavolmarko@163: } pavolmarko@163: int GetVtableIndex() const pavolmarko@163: { pavolmarko@163: return m_VtableIndex; pavolmarko@163: } pavolmarko@163: }; pavolmarko@163: HMCI m_HCMI; pavolmarko@163: pavolmarko@163: public: pavolmarko@163: CHookManagerContainer(const HMCI &hmci) : m_HCMI(hmci) pavolmarko@163: { pavolmarko@163: } pavolmarko@163: bool operator == (const HMCI &other) const pavolmarko@163: { pavolmarko@163: return m_HCMI == other; pavolmarko@163: } pavolmarko@163: void AddHookManager(Plugin plug, const CHookManagerInfo &hookman); pavolmarko@163: }; pavolmarko@163: pavolmarko@332: class CCallClassImpl : public DeprecatedCallClass pavolmarko@117: { pavolmarko@117: public: pavolmarko@117: pavolmarko@117: typedef SourceHook::CVector OrigFuncs; pavolmarko@117: typedef SourceHook::THash OrigVTables; pavolmarko@117: pavolmarko@117: void *m_Ptr; //!< Pointer to the actual object pavolmarko@117: size_t m_ObjSize; //!< Size of the instance pavolmarko@117: OrigVTables m_VT; //!< Info about vtables & functions pavolmarko@117: pavolmarko@117: int m_RefCounter; pavolmarko@117: pavolmarko@117: CCallClassImpl(void *ptr, size_t size); pavolmarko@117: virtual ~CCallClassImpl(); pavolmarko@117: pavolmarko@41: bool operator==(void *other) pavolmarko@41: { pavolmarko@117: return m_Ptr == other; pavolmarko@41: } pavolmarko@117: pavolmarko@117: void *GetThisPtr(); pavolmarko@117: void *GetOrigFunc(int vtbloffs, int vtblidx); pavolmarko@117: pavolmarko@117: void ApplyCallClassPatch(int vtbl_offs, int vtbl_idx, void *orig_entry); pavolmarko@117: void RemoveCallClassPatch(int vtbl_offs, int vtbl_idx); pavolmarko@41: }; pavolmarko@117: pavolmarko@1: /** pavolmarko@41: * @brief A list of CallClass structures pavolmarko@1: */ pavolmarko@117: typedef List Impl_CallClassList; pavolmarko@1: pavolmarko@1: Impl_CallClassList m_CallClasses; //!< A list of already generated callclasses pavolmarko@163: pavolmarko@163: /** pavolmarko@163: * @brief A list of CHookManagerContainers pavolmarko@163: */ pavolmarko@163: typedef List HookManContList; pavolmarko@163: pavolmarko@163: HookManContList m_HookMans; //!< A list of hook managers pavolmarko@1: pavolmarko@128: struct HookLoopInfo pavolmarko@128: { pavolmarko@179: enum RecallType pavolmarko@179: { pavolmarko@179: Recall_No=0, pavolmarko@179: Recall_Pre, pavolmarko@179: Recall_Post1, pavolmarko@179: Recall_Post2 pavolmarko@179: }; pavolmarko@179: pavolmarko@128: META_RES *pStatus; pavolmarko@128: META_RES *pPrevRes; pavolmarko@128: META_RES *pCurRes; pavolmarko@128: pavolmarko@179: META_RES temporaryStatus; //!< Stored during Post1 recall phase pavolmarko@128: bool shouldContinue; pavolmarko@179: RecallType recall; //!< Specifies which kind of recall we're in. pavolmarko@128: pavolmarko@128: IIface *pCurIface; pavolmarko@128: const void *pOrigRet; pavolmarko@162: void *pOverrideRet; pavolmarko@128: void **pIfacePtrPtr; pavolmarko@128: }; pavolmarko@128: typedef CStack HookLoopInfoStack; pavolmarko@128: pavolmarko@117: void ApplyCallClassPatches(CCallClassImpl &cc); pavolmarko@58: void ApplyCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx, void *orig_entry); pavolmarko@58: void RemoveCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx); pavolmarko@1: pavolmarko@117: void SetPluginPaused(Plugin plug, bool paused); pavolmarko@117: pavolmarko@128: HookLoopInfoStack m_HLIStack; pavolmarko@324: CHookIDManager m_HookIDMan; pavolmarko@328: pavolmarko@328: void *m_OneIgnore; //:TODO: pavolmarko@328: bool m_IgnoreActive; pavolmarko@1: public: pavolmarko@1: CSourceHookImpl(); pavolmarko@117: virtual ~CSourceHookImpl(); pavolmarko@1: pavolmarko@1: /** pavolmarko@58: * @brief Returns the interface version pavolmarko@58: */ pavolmarko@58: int GetIfaceVersion(); pavolmarko@58: pavolmarko@58: /** pavolmarko@58: * @brief Returns the implemnetation version pavolmarko@58: */ pavolmarko@58: int GetImplVersion(); pavolmarko@58: pavolmarko@58: /** pavolmarko@6: * @brief Make sure that a plugin is not used by any other plugins anymore, and unregister all its hook managers pavolmarko@1: */ pavolmarko@1: void UnloadPlugin(Plugin plug); pavolmarko@1: pavolmarko@1: /** pavolmarko@6: * @brief Shut down the whole system, unregister all hook managers pavolmarko@1: */ pavolmarko@1: void CompleteShutdown(); pavolmarko@1: pavolmarko@1: /** pavolmarko@1: * @brief Add a hook. pavolmarko@1: * pavolmarko@1: * @return True if the function succeeded, false otherwise pavolmarko@1: * pavolmarko@1: * @param plug The unique identifier of the plugin that calls this function pavolmarko@1: * @param iface The interface pointer pavolmarko@6: * @param ifacesize The size of the class iface points to pavolmarko@6: * @param myHookMan A hook manager function that should be capable of handling the function pavolmarko@1: * @param handler A pointer to a FastDelegate containing the hook handler pavolmarko@1: * @param post Set to true if you want a post handler pavolmarko@1: */ pavolmarko@41: bool AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post); pavolmarko@1: pavolmarko@1: /** pavolmarko@1: * @brief Removes a hook. pavolmarko@1: * pavolmarko@1: * @return True if the function succeeded, false otherwise pavolmarko@1: * pavolmarko@1: * @param plug The unique identifier of the plugin that calls this function pavolmarko@1: * @param iface The interface pointer pavolmarko@41: * @param thisptr_offs This pointer adjuster pavolmarko@41: * @param myHookMan A hook manager function that should be capable of handling the function pavolmarko@41: * @param handler A pointer to a FastDelegate containing the hook handler pavolmarko@41: * @param post Set to true if you want a post handler pavolmarko@41: */ pavolmarko@41: bool RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post); pavolmarko@41: pavolmarko@41: /** pavolmarko@41: * @brief Removes a hook. pavolmarko@41: * pavolmarko@41: * @ return True if the function succeeded, false otherwise pavolmarko@41: * pavolmarko@41: * @param info A RemoveHookInfo structure, describing the hook pavolmarko@41: */ pavolmarko@41: bool RemoveHook(RemoveHookInfo info); pavolmarko@41: pavolmarko@41: /** pavolmarko@6: * @brief Checks whether a plugin has (a) hook manager(s) that is/are currently used by other plugins pavolmarko@1: * pavolmarko@1: * @param plug The unique identifier of the plugin in question pavolmarko@1: */ pavolmarko@1: bool IsPluginInUse(Plugin plug); pavolmarko@1: pavolmarko@1: /** pavolmarko@8: * @brief Pauses all hooks of a plugin pavolmarko@8: * pavolmarko@8: * @param plug The unique identifier of the plugin pavolmarko@8: */ pavolmarko@8: void PausePlugin(Plugin plug); pavolmarko@8: pavolmarko@8: /** pavolmarko@8: * @brief Unpauses all hooks of a plugin pavolmarko@8: * pavolmarko@8: * @param plug The unique identifier of the plugin pavolmarko@8: */ pavolmarko@8: void UnpausePlugin(Plugin plug); pavolmarko@8: pavolmarko@8: /** pavolmarko@1: * @brief Return a pointer to a callclass. Generate a new one if required. pavolmarko@1: * pavolmarko@1: * @param iface The interface pointer pavolmarko@58: * @param size Size of the class instance pavolmarko@1: */ pavolmarko@332: DeprecatedCallClass *GetCallClass(void *iface, size_t size); pavolmarko@1: pavolmarko@1: /** pavolmarko@1: * @brief Release a callclass pavolmarko@1: * pavolmarko@1: * @param ptr Pointer to the callclass pavolmarko@1: */ pavolmarko@332: virtual void ReleaseCallClass(DeprecatedCallClass *ptr); pavolmarko@1: pavolmarko@1: virtual void SetRes(META_RES res); //!< Sets the meta result pavolmarko@1: virtual META_RES GetPrevRes(); //!< Gets the meta result of the previously called handler pavolmarko@1: virtual META_RES GetStatus(); //!< Gets the highest meta result pavolmarko@1: virtual const void *GetOrigRet(); //!< Gets the original result. If not in post function, undefined pavolmarko@1: virtual const void *GetOverrideRet(); //!< Gets the override result. If none is specified, NULL pavolmarko@1: virtual void *GetIfacePtr(); //!< Gets the interface pointer pavolmarko@1: pavolmarko@1: ////////////////////////////////////////////////////////////////////////// pavolmarko@6: // For hook managers pavolmarko@128: void HookLoopBegin(IIface *pIface); //!< Should be called when a hook loop begins pavolmarko@128: void HookLoopEnd(); //!< Should be called when a hook loop exits pavolmarko@128: void SetCurResPtr(META_RES *mres); //!< Sets pointer to the current meta result pavolmarko@128: void SetPrevResPtr(META_RES *mres); //!< Sets pointer to previous meta result pavolmarko@128: void SetStatusPtr(META_RES *mres); //!< Sets pointer to the status variable pavolmarko@128: void SetIfacePtrPtr(void **pp); //!< Sets pointer to the interface this pointer pavolmarko@128: void SetOrigRetPtr(const void *ptr); //!< Sets the original return pointer pavolmarko@162: void SetOverrideRetPtr(void *ptr); //!< Sets the override result pointer pavolmarko@128: bool ShouldContinue(); //!< Returns false if the hook loop should exit pavolmarko@157: pavolmarko@157: /** pavolmarko@157: * @brief Remove a hook manager. Auto-removes all hooks attached to it from plugin plug. pavolmarko@157: * pavolmarko@157: * @param plug The owner of the hook manager pavolmarko@157: * @param pubFunc The hook manager's info function pavolmarko@157: */ pavolmarko@157: virtual void RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc); pavolmarko@163: virtual void RemoveHookManager(RemoveHookManInfo info); pavolmarko@163: pavolmarko@162: virtual void DoRecall(); //!< Initiates a recall sequence pavolmarko@162: virtual void *GetOverrideRetPtr(); //!< Returns the pointer set by SetOverrideRetPtr pavolmarko@162: pavolmarko@162: virtual void *SetupHookLoop(META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr, pavolmarko@162: void **ifacePtrPtr, const void *origRetPtr, void *overrideRetPtr); pavolmarko@324: pavolmarko@324: /** pavolmarko@324: * @brief Add a (VP) hook. pavolmarko@324: * pavolmarko@324: * @return non-zero hook id on success, 0 otherwise pavolmarko@324: * pavolmarko@324: * @param plug The unique identifier of the plugin that calls this function pavolmarko@324: * @param mode Can be either Hook_Normal or Hook_VP (vtable-wide hook) pavolmarko@324: * @param iface The interface pointer pavolmarko@328: * The representative interface pointer for VP hooks pavolmarko@328: * The vtable pointer for direct VP hooks !!! pavolmarko@324: * @param ifacesize The size of the class iface points to pavolmarko@324: * @param myHookMan A hook manager function that should be capable of handling the function pavolmarko@324: * @param handler A pointer to a FastDelegate containing the hook handler pavolmarko@324: * @param post Set to true if you want a post handler pavolmarko@324: */ pavolmarko@324: virtual int AddHookNew(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, pavolmarko@324: ISHDelegate *handler, bool post); pavolmarko@324: pavolmarko@324: /** pavolmarko@324: * @brief Remove a VP hook by ID. pavolmarko@324: * pavolmarko@324: * @return true on success, false otherwise pavolmarko@324: * pavolmarko@324: * @param plug The unique identifier of the plugin that calls this function pavolmarko@324: * @param hookid The hook id (returned by AddHookNew) pavolmarko@324: */ pavolmarko@324: virtual bool RemoveHookByID(Plugin plug, int hookid); pavolmarko@328: pavolmarko@328: /** pavolmarko@328: * @brief Makes sure that hooks are going to be ignored on the next call of vfnptr pavolmarko@328: * pavolmarko@328: * @param plug The unique identifier of the plugin that calls this function pavolmarko@328: * @param vfnptr The virtual function pointer of the function in question pavolmarko@328: */ pavolmarko@328: virtual void SetIgnoreHooks(Plugin plug, void *vfnptr); pavolmarko@328: pavolmarko@328: /** pavolmarko@328: * @brief Reverses SetIgnoreHooks' effect pavolmarko@328: * pavolmarko@328: * @param plug The unique identifier of the plugin that calls this function pavolmarko@328: * @param vfnptr The virtual function pointer of the function in question pavolmarko@328: */ pavolmarko@328: virtual void ResetIgnoreHooks(Plugin plug, void *vfnptr); pavolmarko@333: pavolmarko@333: /** pavolmarko@333: * @brief Finds the original entry of a virtual function pointer pavolmarko@333: * pavolmarko@333: * @param vfnptr The virtual function pointer pavolmarko@333: * @return The original entry if the virtual function pointer has been patched; NULL otherwise. pavolmarko@333: */ pavolmarko@333: virtual void *GetOrigVfnPtrEntry(void *vfnptr); pavolmarko@1: }; pavolmarko@1: } pavolmarko@1: dvander@34: #endif