sourcehook/sourcehook_impl.h
author Scott Ehlert <ds@alliedmods.net>
Fri Aug 10 23:43:16 2007 +0000 (2007-08-10)
changeset 346 d0868271663a
parent 333 3813f1ac0cfe
child 380 f9e21a2ac558
permissions -rw-r--r--
Reformatted output of meta list command
pavolmarko@1
     1
/* ======== SourceHook ========
ds@294
     2
* Copyright (C) 2004-2007 Metamod:Source Development Team
pavolmarko@1
     3
* No warranties of any kind
pavolmarko@1
     4
*
dvander@10
     5
* License: zlib/libpng
dvander@10
     6
*
dvander@10
     7
* Author(s): Pavol "PM OnoTo" Marko
pavolmarko@1
     8
* ============================
pavolmarko@1
     9
*/
pavolmarko@1
    10
pavolmarko@1
    11
#ifndef __SOURCEHOOK_IMPL_H__
pavolmarko@1
    12
#define __SOURCEHOOK_IMPL_H__
pavolmarko@1
    13
pavolmarko@1
    14
#include "sourcehook.h"
pavolmarko@117
    15
#include "sh_list.h"
pavolmarko@117
    16
#include "sh_vector.h"
pavolmarko@117
    17
#include "sh_tinyhash.h"
pavolmarko@128
    18
#include "sh_stack.h"
pavolmarko@324
    19
#include "sh_listcat.h"
ds@86
    20
pavolmarko@163
    21
/*
pavolmarko@163
    22
pavolmarko@163
    23
IMPLEMENTATION INFO
pavolmarko@163
    24
pavolmarko@163
    25
---------------------------------------
pavolmarko@163
    26
Protos ("Prototypes")
pavolmarko@163
    27
	The purpose of protos is to provide the amount of type information about a function
pavolmarko@163
    28
	which is required to be able to execute a function call without corrupting the stack.
pavolmarko@233
    29
	Our protos do not fully do this, but they provide the size of the return value, the number of
pavolmarko@233
    30
	parameters, and the size of each parameter, which is enough for most situations.
pavolmarko@163
    31
pavolmarko@163
    32
	There are two version of protos:
pavolmarko@163
    33
	OLD:
pavolmarko@163
    34
		C-Style strings.
pavolmarko@163
    35
pavolmarko@163
    36
		0_void:
pavolmarko@163
    37
		"attrib"
pavolmarko@163
    38
		1_void:
pavolmarko@163
    39
		"attrib|param1_type"
pavolmarko@163
    40
		2_void:
pavolmarko@163
    41
		"attrib|param1_type|param2_type
pavolmarko@163
    42
		0:
pavolmarko@163
    43
		"attrib|ret_type"
pavolmarko@163
    44
		1:
pavolmarko@163
    45
		"attrib|ret_type|param1_type"
pavolmarko@163
    46
		2:
pavolmarko@163
    47
		"attrib|ret_type|param2_type"
pavolmarko@163
    48
pavolmarko@163
    49
		Old protos are deprecated.
pavolmarko@163
    50
pavolmarko@163
    51
	NEW:
pavolmarko@163
    52
		New protos are in fact pointers to the ProtoInfo structure (see sourcehook.h)
pavolmarko@163
    53
pavolmarko@163
    54
	Old protos begin with a non-zero byte, new protos begin with a zero byte.
pavolmarko@163
    55
pavolmarko@163
    56
	Protos are usually stored in a CProto instance.
pavolmarko@163
    57
pavolmarko@163
    58
---------------------------------------
pavolmarko@163
    59
Hook managers and hook manager containers
pavolmarko@163
    60
	Each hookman container is tied to _one_ proto/vtable index/vtable offset info.
pavolmarko@163
    61
	Hookman containers then contain a list of hook managers provided by plugins, sorted by version.
pavolmarko@163
    62
	(higher versions come first)
pavolmarko@163
    63
pavolmarko@163
    64
	Duplicate hook managers are ignored (ie. hook managers where proto, vtable index, vtable offset,
pavolmarko@163
    65
	plugin, version are the same as in an already exisiting hook manager)
pavolmarko@163
    66
pavolmarko@163
    67
	A new hook manager is always added to the end of the version group in the corresponding
pavolmarko@163
    68
	hook container. 
pavolmarko@163
    69
pavolmarko@163
    70
	If the new hook manager was added to the beginning of the container (which only happens if
pavolmarko@163
    71
	it is the first one or if it has a higher version than the previously first hook manager),
pavolmarko@163
    72
	the now second hook manager is shut down and the new hook manager takes its job.
pavolmarko@163
    73
pavolmarko@163
    74
	A "hook manager container id" (HMCI) consits of three values: proto, vtbl index, vtbl offset.
pavolmarko@163
    75
---------------------------------------
pavolmarko@163
    76
Hooks 
pavolmarko@163
    77
	When adding a hook, first the proposed hook manager is added to the corresponding
pavolmarko@163
    78
	hook manager container as described above.
pavolmarko@163
    79
pavolmarko@163
    80
	Then the first hook manager in the the manhook container is chosen to handle the function.
pavolmarko@163
    81
pavolmarko@163
    82
	Removing a hook does not neccessarily unreigster the plugin's hook manager. In order to do this,
pavolmarko@163
    83
	use RemoveHookManager or UnloadPlugin/
pavolmarko@163
    84
pavolmarko@163
    85
	Hooks can be paused - they remain in memory but they are not called. In SH, the hook iterator
pavolmarko@163
    86
	classes handle pausing transparently.
pavolmarko@163
    87
pavolmarko@163
    88
	The hook loop is supposed to call ShouldContinue before each iteration. This makes hook handlers
pavolmarko@163
    89
	able to remove themselves.
pavolmarko@163
    90
pavolmarko@163
    91
---------------------------------------
pavolmarko@163
    92
Call classes
pavolmarko@328
    93
pavolmarko@328
    94
	!! deprecated !!   - see below (new SH_CALL)
pavolmarko@328
    95
pavolmarko@163
    96
	Call classes are identified by a this pointer and an instance size
pavolmarko@163
    97
pavolmarko@163
    98
	We use the instance size because a derived class instance and a base class instance could
pavolmarko@163
    99
	have the same this pointers, and we want to avoid that the derived class
pavolmarko@163
   100
	(which could be bigger) gets the same callclass as the base class (mainly if the
pavolmarko@163
   101
	base class' callclass was requested first).
pavolmarko@163
   102
pavolmarko@163
   103
	Call classes are reference counted.
pavolmarko@163
   104
pavolmarko@163
   105
	The original function pointers are stored in a vector (in order to allow fast random access).
pavolmarko@163
   106
	These vectors are stored as the value type of a hash. The key type is int and represents the
pavolmarko@163
   107
	vtable offset.
pavolmarko@163
   108
pavolmarko@163
   109
	If the hash key doesn't exist or the vtblidx is out of range or the corresponding element in the
pavolmarko@163
   110
	vector is NULL, there is no hook on that function.
pavolmarko@163
   111
pavolmarko@163
   112
---------------------------------------
pavolmarko@163
   113
Recalls
pavolmarko@163
   114
	Recalls are used for the META_RETURN_(VALUE_)NEWPARAMS macros, ie. to change the parameters
pavolmarko@163
   115
	in the hook loop on the fly.
pavolmarko@163
   116
	
pavolmarko@163
   117
	First, the macro calls DoRecall(), then it calls the function the hook is attached to -> it 
pavolmarko@163
   118
	calls the hookfunc. SourceHook makes sure that the newly invoked hook loop starts where the last
pavolmarko@163
   119
	one left off and that status variables like status, previous result, override return are kept.
pavolmarko@163
   120
	When this recurisvely called hookfunc returns, the macro returns what it returned
pavolmarko@163
   121
	(using MRES_SUPERCEDE). CSourceHookImpl returns false from ShouldContinue so the original hook loop
pavolmarko@163
   122
	is abandonned.
pavolmarko@179
   123
pavolmarko@179
   124
Post Recalls
pavolmarko@179
   125
	People wanted to be able to use META_RETURN_(VALUE_)NEWPARAMS from post hooks as well. Crazy people!
pavolmarko@179
   126
	Anyway, for this, we have to know where a hook handler is. Is it executing pre or post hooks at the moment?
pavolmarko@179
   127
	The only way we can know this is watching when it calls CHookList::GetIter(). So CHookList gets a new variable:
pavolmarko@179
   128
	m_RequestedFlag. It also gets two new functions: RQFlagReset() and RQFlagGet().
pavolmarko@179
   129
	HookLoopBegin() calls RQFlagReset on both hooklists of the iface; then DoRecall() checks whether the postlist's 
pavolmarko@179
   130
	RQ flag is set. if yes, the hook loop is in post mode.
pavolmarko@179
   131
pavolmarko@179
   132
	So, what a about a recall in post mode? The first ShouldContinue returns false and sets Status to supercede. 
pavolmarko@179
   133
	This way the pre hooks and the function call will be skipped. Then, then next ShouldContinue returns true, so we get
pavolmarko@179
   134
	into the post hooks. HA!
pavolmarko@179
   135
pavolmarko@179
   136
Return Values in Post Recalls
pavolmarko@179
   137
	The easy case is when we already have an override return value. In this case, the status register gets transferred,
pavolmarko@179
   138
	and so does the override return pointer. So, basically, everything is ok.
pavolmarko@179
   139
pavolmarko@179
   140
	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
   141
	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
   142
	So, we emulate it. GetOrigRet will return the orig ret pointer from the old hook loop. If still no one overrides it,
pavolmarko@179
   143
	we'd have to return it. BUT! HOW TO DO THIS? Check out SH_RETURN(). First calls HookLoopEnd(), then decides whether
pavolmarko@179
   144
	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
   145
	the last orig return value as its new override return value; but leave status where it is so everything works, and in
pavolmarko@179
   146
	HookLoopEnd we make sure that status is high enough so that the override return will be returned. crazy.
pavolmarko@179
   147
pavolmarko@179
   148
	All this stuff could be much less complicated if I didn't try to preserve binary compatibility :)
pavolmarko@324
   149
pavolmarko@324
   150
VP Hooks
pavolmarko@324
   151
	VP hooks are hooks which are called on a vfnptr, regardless of the this pointer with which it was called. They are
pavolmarko@324
   152
	implemented as a special CIface instance with m_Ptr = NULL. All Hook Lists have a new "ListCatIterator" which
pavolmarko@324
   153
	virtually concatenates the NULL-interface-hook-list with their normal hook list.
pavolmarko@324
   154
pavolmarko@324
   155
pavolmarko@324
   156
	I'm afraid that with the addition of Recalls and VP Hooks, SourceHook is now a pretty complex and hacked-together
pavolmarko@324
   157
	binary compatible beast which is pretty hard to maintain unless you've written it :)
pavolmarko@328
   158
pavolmarko@328
   159
New SH_CALL
pavolmarko@328
   160
	The addition of VP hooks messed up the Call Classes concept (see above) - call classes are bound to an
pavolmarko@328
   161
	instance pointer; they only work on one of the hooked instances. But VP hooks are called on all instances.
pavolmarko@328
   162
	
pavolmarko@328
   163
	That's why now, SH_CALL takes an instance pointer instead of a callclass pointer. It basically does this:
pavolmarko@328
   164
	1) call SH_GLOB_PTR->SetIgnoreHooks(vfnptr)
pavolmarko@328
   165
	2) call this->*mfp
pavolmarko@328
   166
	3) call SH_GLOB_PTR->ResetIgnoreHooks(vfnptr)
pavolmarko@328
   167
pavolmarko@328
   168
	SourceHook stroes the "ignored vfnptr" and makes CVfnPtr::FindIface return NULL if the CVfnPtr instance
pavolmarko@328
   169
	corresponds to the ignored vfnptr. This way the hook manager thinks that the instance isn't hooked, and calls
pavolmarko@328
   170
	the original function. Everything works fine. This works even for VP hooks.
pavolmarko@163
   171
*/
pavolmarko@163
   172
pavolmarko@1
   173
namespace SourceHook
pavolmarko@1
   174
{
pavolmarko@1
   175
	/**
pavolmarko@1
   176
	*	@brief The SourceHook implementation class
pavolmarko@1
   177
	*/
pavolmarko@1
   178
	class CSourceHookImpl : public ISourceHook
pavolmarko@1
   179
	{
pavolmarko@117
   180
	private:
pavolmarko@163
   181
		class CProto
pavolmarko@163
   182
		{
dvander@181
   183
			char *m_Proto;
pavolmarko@163
   184
pavolmarko@163
   185
			static bool Equal(const char *p1, const char *p2);
dvander@181
   186
			char *DupProto(const char *src);
dvander@181
   187
			void FreeProto(char *prot);
pavolmarko@163
   188
		public:
pavolmarko@324
   189
			CProto() : m_Proto(NULL)
pavolmarko@324
   190
			{
pavolmarko@324
   191
			}
pavolmarko@324
   192
dvander@181
   193
			CProto(const char *szProto) : m_Proto(DupProto(szProto))
pavolmarko@163
   194
			{
pavolmarko@163
   195
			}
pavolmarko@163
   196
dvander@181
   197
			CProto(const CProto &other) : m_Proto(DupProto(other.m_Proto))
pavolmarko@163
   198
			{
pavolmarko@163
   199
			}
pavolmarko@163
   200
dvander@181
   201
			~CProto()
dvander@181
   202
			{
dvander@181
   203
				FreeProto(m_Proto);
dvander@181
   204
				m_Proto = NULL;
dvander@181
   205
			}
dvander@181
   206
pavolmarko@163
   207
			void operator = (const char *szProto)
pavolmarko@163
   208
			{
dvander@181
   209
				m_Proto = DupProto(szProto);
pavolmarko@163
   210
			}
dvander@181
   211
pavolmarko@163
   212
			void operator = (const CProto &other)
pavolmarko@163
   213
			{
dvander@181
   214
				m_Proto = DupProto(other.m_Proto);
pavolmarko@163
   215
			}
pavolmarko@163
   216
pavolmarko@163
   217
			bool operator == (const char *szProto) const
pavolmarko@163
   218
			{
pavolmarko@163
   219
				return Equal(szProto, m_Proto);
pavolmarko@163
   220
			}
pavolmarko@163
   221
			bool operator == (const CProto &other) const
pavolmarko@163
   222
			{
pavolmarko@163
   223
				return Equal(other.m_Proto, m_Proto);
pavolmarko@163
   224
			}
pavolmarko@324
   225
pavolmarko@324
   226
			const char *GetProto() const
pavolmarko@324
   227
			{
pavolmarko@324
   228
				return m_Proto;
pavolmarko@324
   229
			}
pavolmarko@163
   230
		};
pavolmarko@163
   231
pavolmarko@163
   232
pavolmarko@1
   233
		/**
pavolmarko@6
   234
		*	@brief A hook can be removed if you have this information
pavolmarko@1
   235
		*/
pavolmarko@6
   236
		struct RemoveHookInfo
pavolmarko@6
   237
		{
pavolmarko@58
   238
			RemoveHookInfo(Plugin pplug, void *piface, int tpo, HookManagerPubFunc phookman,
pavolmarko@41
   239
				ISHDelegate *phandler, bool ppost)
pavolmarko@58
   240
				: plug(pplug), iface(piface), thisptr_offs(tpo),
pavolmarko@58
   241
				hookman(phookman), handler(phandler), post(ppost)
pavolmarko@6
   242
			{
pavolmarko@6
   243
			}
pavolmarko@6
   244
pavolmarko@6
   245
			Plugin plug;
pavolmarko@6
   246
			void *iface;
pavolmarko@58
   247
			int thisptr_offs;
pavolmarko@41
   248
			HookManagerPubFunc hookman;
pavolmarko@6
   249
			ISHDelegate *handler;
pavolmarko@6
   250
			bool post;
pavolmarko@6
   251
		};
pavolmarko@6
   252
pavolmarko@163
   253
		struct RemoveHookManInfo
pavolmarko@163
   254
		{
pavolmarko@163
   255
			RemoveHookManInfo(Plugin pplug, HookManagerPubFunc phookman)
pavolmarko@163
   256
				: plug(pplug), hookman(phookman)
pavolmarko@163
   257
			{
pavolmarko@163
   258
			}
pavolmarko@163
   259
pavolmarko@163
   260
			Plugin plug;
pavolmarko@163
   261
			HookManagerPubFunc hookman;
pavolmarko@163
   262
		};
pavolmarko@163
   263
pavolmarko@324
   264
		// Associates hook ids with info about the hooks
pavolmarko@324
   265
		// Also used to keep track of used hook ids
pavolmarko@324
   266
		class CHookIDManager
pavolmarko@324
   267
		{
pavolmarko@324
   268
		public:
pavolmarko@324
   269
			struct Entry
pavolmarko@324
   270
			{
pavolmarko@324
   271
				bool isfree;
pavolmarko@324
   272
pavolmarko@324
   273
				// hookman info
pavolmarko@324
   274
				CProto proto;
pavolmarko@324
   275
				int vtbl_offs;
pavolmarko@324
   276
				int vtbl_idx;
pavolmarko@324
   277
pavolmarko@324
   278
				// vfnptr
pavolmarko@324
   279
				void *vfnptr;
pavolmarko@324
   280
pavolmarko@324
   281
				// iface
pavolmarko@324
   282
				void* adjustediface;
pavolmarko@324
   283
pavolmarko@324
   284
				// hook
pavolmarko@324
   285
				Plugin plug;
pavolmarko@324
   286
				int thisptr_offs;
pavolmarko@324
   287
				ISHDelegate *handler;
pavolmarko@324
   288
				bool post;
pavolmarko@324
   289
pavolmarko@324
   290
				Entry(const CProto &pprt, int pvo, int pvi, void *pvp, void *pai, Plugin pplug, int pto,
pavolmarko@324
   291
					ISHDelegate *ph, bool ppost)
pavolmarko@324
   292
					: isfree(false), proto(pprt), vtbl_offs(pvo), vtbl_idx(pvi), vfnptr(pvp), 
pavolmarko@324
   293
					adjustediface(pai), plug(pplug), thisptr_offs(pto), handler(ph), post(ppost)
pavolmarko@324
   294
				{
pavolmarko@324
   295
				}
pavolmarko@324
   296
				Entry()
pavolmarko@324
   297
				{
pavolmarko@324
   298
				}
pavolmarko@324
   299
			};
pavolmarko@324
   300
		private:
pavolmarko@324
   301
			// Internally, hookid 1 is stored as m_Entries[0]
pavolmarko@324
   302
pavolmarko@324
   303
			CVector<Entry> m_Entries;
pavolmarko@324
   304
		public:
pavolmarko@324
   305
			CHookIDManager();
pavolmarko@324
   306
			int New(const CProto &proto, int vtbl_offs, int vtbl_idx, void *vfnptr, void *adjustediface,
pavolmarko@324
   307
				Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post);
pavolmarko@324
   308
			bool Remove(int hookid);
pavolmarko@324
   309
			const Entry * QueryHook(int hookid);
pavolmarko@324
   310
pavolmarko@324
   311
			// Finds all hooks with the given info, and fills the hookids into output.
pavolmarko@324
   312
			void FindAllHooks(CVector<int> &output, const CProto &proto, int vtbl_offs, int vtbl_idx,
pavolmarko@324
   313
				void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post);
pavolmarko@324
   314
pavolmarko@324
   315
			// Removes all hooks with a specified vfnptr
pavolmarko@324
   316
			bool RemoveAll(void *vfnptr);
pavolmarko@324
   317
		};
pavolmarko@324
   318
pavolmarko@117
   319
		struct HookInfo
pavolmarko@117
   320
		{
pavolmarko@117
   321
			ISHDelegate *handler;			//!< Pointer to the handler
pavolmarko@117
   322
			bool paused;					//!< If true, the hook should not be executed
pavolmarko@117
   323
			Plugin plug;					//!< The owner plugin
pavolmarko@117
   324
			int thisptr_offs;				//!< This pointer offset
pavolmarko@324
   325
			int hookid;						//!< Unique ID given by CHookIDManager
pavolmarko@324
   326
pavolmarko@324
   327
			bool operator==(int otherid)
pavolmarko@324
   328
			{
pavolmarko@324
   329
				return hookid == otherid;
pavolmarko@324
   330
			}
pavolmarko@117
   331
		};
pavolmarko@117
   332
pavolmarko@117
   333
		class CHookList : public IHookList
pavolmarko@117
   334
		{
pavolmarko@117
   335
		public:
pavolmarko@324
   336
			List<HookInfo> *m_VPList;			// left-hand list for ListCatIterator -> for VP hooks
pavolmarko@117
   337
			List<HookInfo> m_List;
pavolmarko@117
   338
pavolmarko@117
   339
			friend class CIter;
pavolmarko@117
   340
pavolmarko@117
   341
			class CIter : public IHookList::IIter
pavolmarko@117
   342
			{
pavolmarko@117
   343
				friend class CHookList;
pavolmarko@117
   344
pavolmarko@117
   345
				CHookList *m_pList;
pavolmarko@117
   346
pavolmarko@117
   347
				void SkipPaused();
pavolmarko@117
   348
			public:
pavolmarko@121
   349
pavolmarko@324
   350
				ListCatIterator<HookInfo> m_Iter;
pavolmarko@121
   351
pavolmarko@117
   352
				CIter(CHookList *pList);
pavolmarko@117
   353
pavolmarko@117
   354
				virtual ~CIter();
pavolmarko@117
   355
pavolmarko@117
   356
				void GoToBegin();
pavolmarko@162
   357
				void Set(CIter *pOther);
pavolmarko@117
   358
pavolmarko@117
   359
				bool End();
pavolmarko@117
   360
				void Next();
pavolmarko@117
   361
				ISHDelegate *Handler();
pavolmarko@117
   362
				int ThisPtrOffs();
pavolmarko@117
   363
pavolmarko@121
   364
				void Clear();
pavolmarko@121
   365
pavolmarko@121
   366
				CIter *m_pNext;		// When stored in m_FreeIters and m_UsedIters
pavolmarko@121
   367
				CIter *m_pPrev;		// Only used when stored in m_UsedIters
pavolmarko@117
   368
			};
pavolmarko@117
   369
pavolmarko@117
   370
			CIter *m_FreeIters;
pavolmarko@162
   371
			CIter *m_UsedIters;		// The last returned and not-yet-released iter is always m_UsedIters
pavolmarko@162
   372
pavolmarko@162
   373
			// For recalls
pavolmarko@162
   374
			bool m_Recall;
pavolmarko@179
   375
			bool m_RQFlag;
pavolmarko@162
   376
pavolmarko@162
   377
			void SetRecallState();	// Sets the list into a state where the next returned
pavolmarko@162
   378
									// iterator (from GetIter) will be a copy of the last
pavolmarko@162
   379
									// returned iterator, incremented by one. This is used in Recalls.
pavolmarko@162
   380
									// The hook resets this state automatically on:
pavolmarko@162
   381
									// GetIter, ReleaseIter
pavolmarko@117
   382
pavolmarko@179
   383
			void RQFlagReset() { m_RQFlag = false; }
pavolmarko@179
   384
			bool RQFlagGet() { return m_RQFlag; }
pavolmarko@117
   385
			CHookList();
pavolmarko@117
   386
			CHookList(const CHookList &other);
pavolmarko@117
   387
			virtual ~CHookList();
pavolmarko@117
   388
pavolmarko@117
   389
			void operator=(const CHookList &other);
pavolmarko@117
   390
pavolmarko@117
   391
			IIter *GetIter();
pavolmarko@117
   392
			void ReleaseIter(IIter *pIter);
pavolmarko@324
   393
pavolmarko@324
   394
			void SetVPList(List<HookInfo> *newList);
pavolmarko@324
   395
			void ClearVPList();
pavolmarko@117
   396
		};
pavolmarko@117
   397
pavolmarko@117
   398
		// I know, data hiding... But I'm a lazy bastard!
pavolmarko@117
   399
pavolmarko@117
   400
		class CIface : public IIface
pavolmarko@117
   401
		{
pavolmarko@117
   402
		public:
pavolmarko@117
   403
			void *m_Ptr;
pavolmarko@117
   404
			CHookList m_PreHooks;
pavolmarko@117
   405
			CHookList m_PostHooks;
pavolmarko@117
   406
		public:
pavolmarko@117
   407
			CIface(void *ptr);
pavolmarko@117
   408
			virtual ~CIface();
pavolmarko@117
   409
pavolmarko@117
   410
			void *GetPtr();
pavolmarko@117
   411
			IHookList *GetPreHooks();
pavolmarko@117
   412
			IHookList *GetPostHooks();
pavolmarko@117
   413
pavolmarko@117
   414
			bool operator==(void *ptr)
pavolmarko@117
   415
			{
pavolmarko@117
   416
				return m_Ptr == ptr;
pavolmarko@117
   417
			}
pavolmarko@324
   418
			bool operator!=(void *ptr)
pavolmarko@324
   419
			{
pavolmarko@324
   420
				return m_Ptr != ptr;
pavolmarko@324
   421
			}
pavolmarko@117
   422
		};
pavolmarko@1
   423
pavolmarko@117
   424
		class CVfnPtr : public IVfnPtr
pavolmarko@117
   425
		{
pavolmarko@117
   426
		public:
pavolmarko@117
   427
			typedef List<CIface> IfaceList;
pavolmarko@117
   428
			typedef IfaceList::iterator IfaceListIter;
pavolmarko@117
   429
pavolmarko@117
   430
			void *m_Ptr;
pavolmarko@117
   431
			void *m_OrigEntry;
pavolmarko@117
   432
pavolmarko@117
   433
			IfaceList m_Ifaces;
pavolmarko@117
   434
pavolmarko@328
   435
			void **m_pOneIgnore;
pavolmarko@117
   436
		public:
pavolmarko@328
   437
			CVfnPtr(void *ptr, void **pOneIgnore);
pavolmarko@117
   438
			virtual ~CVfnPtr();
pavolmarko@117
   439
pavolmarko@117
   440
			void *GetVfnPtr();
pavolmarko@117
   441
			void *GetOrigEntry();
pavolmarko@117
   442
pavolmarko@117
   443
			virtual IIface *FindIface(void *ptr);
pavolmarko@117
   444
pavolmarko@117
   445
			bool operator==(void *ptr)
pavolmarko@117
   446
			{
pavolmarko@117
   447
				return m_Ptr == ptr;
pavolmarko@117
   448
			}
pavolmarko@117
   449
		};
pavolmarko@117
   450
pavolmarko@117
   451
		class CHookManagerInfo : public IHookManagerInfo
pavolmarko@41
   452
		{
pavolmarko@117
   453
		public:
pavolmarko@117
   454
			typedef List<CVfnPtr> VfnPtrList;
pavolmarko@117
   455
			typedef VfnPtrList::iterator VfnPtrListIter;
pavolmarko@117
   456
pavolmarko@117
   457
			Plugin m_Plug;
pavolmarko@117
   458
			HookManagerPubFunc m_Func;
pavolmarko@117
   459
pavolmarko@117
   460
			int m_VtblOffs;
pavolmarko@117
   461
			int m_VtblIdx;
pavolmarko@117
   462
			const char *m_Proto;
pavolmarko@117
   463
			void *m_HookfuncVfnptr;
pavolmarko@117
   464
pavolmarko@117
   465
			VfnPtrList m_VfnPtrs;
pavolmarko@117
   466
pavolmarko@163
   467
			int m_HookManVersion;
pavolmarko@117
   468
		public:
pavolmarko@163
   469
			CHookManagerInfo();
pavolmarko@117
   470
			virtual ~CHookManagerInfo();
pavolmarko@117
   471
pavolmarko@117
   472
			IVfnPtr *FindVfnPtr(void *vfnptr);
pavolmarko@117
   473
pavolmarko@117
   474
			void SetInfo(int vtbl_offs, int vtbl_idx, const char *proto);
pavolmarko@117
   475
			void SetHookfuncVfnptr(void *hookfunc_vfnptr);
pavolmarko@163
   476
pavolmarko@163
   477
			void SetVersion(int version);
pavolmarko@163
   478
pavolmarko@163
   479
			bool operator < (const CHookManagerInfo &other)
pavolmarko@163
   480
			{
pavolmarko@163
   481
				return m_HookManVersion < other.m_HookManVersion;
pavolmarko@163
   482
			}
pavolmarko@163
   483
pavolmarko@163
   484
			struct Descriptor
pavolmarko@163
   485
			{
pavolmarko@163
   486
				Descriptor(Plugin pplug, HookManagerPubFunc ppubFunc) : plug(pplug), pubFunc(ppubFunc)
pavolmarko@163
   487
				{
pavolmarko@163
   488
				}
pavolmarko@163
   489
pavolmarko@163
   490
				Plugin plug;
pavolmarko@163
   491
				HookManagerPubFunc pubFunc;
pavolmarko@163
   492
			};
pavolmarko@163
   493
pavolmarko@163
   494
			bool operator == (const Descriptor desc)
pavolmarko@163
   495
			{
pavolmarko@163
   496
				return m_Func == desc.pubFunc && m_Plug == desc.plug;
pavolmarko@163
   497
			}
pavolmarko@117
   498
		};
pavolmarko@163
   499
pavolmarko@117
   500
		typedef List<CHookManagerInfo> HookManInfoList;
pavolmarko@117
   501
pavolmarko@163
   502
		class CHookManagerContainer : public HookManInfoList
pavolmarko@163
   503
		{
pavolmarko@163
   504
		public:
pavolmarko@163
   505
			// HMCI (Hook Manager Container Identification)
pavolmarko@163
   506
			class HMCI
pavolmarko@163
   507
			{
pavolmarko@163
   508
				CProto m_Proto;
pavolmarko@163
   509
				int m_VtableOffset;
pavolmarko@163
   510
				int m_VtableIndex;
pavolmarko@163
   511
			public:
pavolmarko@163
   512
				HMCI(const char *proto, int vtbloffs, int vtblidx) :
pavolmarko@163
   513
				  m_Proto(proto), m_VtableOffset(vtbloffs), m_VtableIndex(vtblidx)
pavolmarko@163
   514
				  {
pavolmarko@163
   515
				  }
pavolmarko@163
   516
				  ~HMCI()
pavolmarko@163
   517
				  {
pavolmarko@163
   518
				  }
pavolmarko@163
   519
pavolmarko@163
   520
				  bool operator==(const HMCI &other) const
pavolmarko@163
   521
				  {
pavolmarko@163
   522
					  return
pavolmarko@163
   523
						  other.m_VtableIndex == m_VtableIndex &&
pavolmarko@163
   524
						  other.m_Proto == m_Proto &&
pavolmarko@163
   525
						  other.m_VtableOffset == m_VtableOffset;
pavolmarko@163
   526
				  }
pavolmarko@163
   527
pavolmarko@163
   528
				  const CProto &GetProto() const
pavolmarko@163
   529
				  {
pavolmarko@163
   530
					  return m_Proto;
pavolmarko@163
   531
				  }
pavolmarko@163
   532
				  int GetVtableOffset() const
pavolmarko@163
   533
				  {
pavolmarko@163
   534
					  return m_VtableOffset;
pavolmarko@163
   535
				  }
pavolmarko@163
   536
				  int GetVtableIndex() const
pavolmarko@163
   537
				  {
pavolmarko@163
   538
					  return m_VtableIndex;
pavolmarko@163
   539
				  }
pavolmarko@163
   540
			};
pavolmarko@163
   541
			HMCI m_HCMI;
pavolmarko@163
   542
pavolmarko@163
   543
		public:
pavolmarko@163
   544
			CHookManagerContainer(const HMCI &hmci) : m_HCMI(hmci)
pavolmarko@163
   545
			{
pavolmarko@163
   546
			}
pavolmarko@163
   547
			bool operator == (const HMCI &other) const
pavolmarko@163
   548
			{
pavolmarko@163
   549
				return m_HCMI == other;
pavolmarko@163
   550
			}
pavolmarko@163
   551
			void AddHookManager(Plugin plug, const CHookManagerInfo &hookman);
pavolmarko@163
   552
		};
pavolmarko@163
   553
pavolmarko@332
   554
		class CCallClassImpl : public DeprecatedCallClass<void>
pavolmarko@117
   555
		{
pavolmarko@117
   556
		public:
pavolmarko@117
   557
pavolmarko@117
   558
			typedef SourceHook::CVector<void*> OrigFuncs;
pavolmarko@117
   559
			typedef SourceHook::THash<int, OrigFuncs> OrigVTables;
pavolmarko@117
   560
pavolmarko@117
   561
			void *m_Ptr;			//!< Pointer to the actual object
pavolmarko@117
   562
			size_t m_ObjSize;		//!< Size of the instance
pavolmarko@117
   563
			OrigVTables m_VT;		//!< Info about vtables & functions
pavolmarko@117
   564
pavolmarko@117
   565
			int m_RefCounter;
pavolmarko@117
   566
pavolmarko@117
   567
			CCallClassImpl(void *ptr, size_t size);
pavolmarko@117
   568
			virtual ~CCallClassImpl();
pavolmarko@117
   569
pavolmarko@41
   570
			bool operator==(void *other)
pavolmarko@41
   571
			{
pavolmarko@117
   572
				return m_Ptr == other;
pavolmarko@41
   573
			}
pavolmarko@117
   574
pavolmarko@117
   575
			void *GetThisPtr();
pavolmarko@117
   576
			void *GetOrigFunc(int vtbloffs, int vtblidx);
pavolmarko@117
   577
pavolmarko@117
   578
			void ApplyCallClassPatch(int vtbl_offs, int vtbl_idx, void *orig_entry);
pavolmarko@117
   579
			void RemoveCallClassPatch(int vtbl_offs, int vtbl_idx);
pavolmarko@41
   580
		};
pavolmarko@117
   581
pavolmarko@1
   582
		/**
pavolmarko@41
   583
		*	@brief A list of CallClass structures
pavolmarko@1
   584
		*/
pavolmarko@117
   585
		typedef List<CCallClassImpl> Impl_CallClassList;
pavolmarko@1
   586
pavolmarko@1
   587
		Impl_CallClassList m_CallClasses;			//!< A list of already generated callclasses
pavolmarko@163
   588
pavolmarko@163
   589
		/**
pavolmarko@163
   590
		*	@brief A list of CHookManagerContainers
pavolmarko@163
   591
		*/
pavolmarko@163
   592
		typedef List<CHookManagerContainer> HookManContList;
pavolmarko@163
   593
pavolmarko@163
   594
		HookManContList m_HookMans;					//!< A list of hook managers
pavolmarko@1
   595
pavolmarko@128
   596
		struct HookLoopInfo
pavolmarko@128
   597
		{
pavolmarko@179
   598
			enum RecallType
pavolmarko@179
   599
			{
pavolmarko@179
   600
				Recall_No=0,
pavolmarko@179
   601
				Recall_Pre,
pavolmarko@179
   602
				Recall_Post1,
pavolmarko@179
   603
				Recall_Post2
pavolmarko@179
   604
			};
pavolmarko@179
   605
pavolmarko@128
   606
			META_RES *pStatus;
pavolmarko@128
   607
			META_RES *pPrevRes;
pavolmarko@128
   608
			META_RES *pCurRes;
pavolmarko@128
   609
pavolmarko@179
   610
			META_RES temporaryStatus;				//!< Stored during Post1 recall phase
pavolmarko@128
   611
			bool shouldContinue;
pavolmarko@179
   612
			RecallType recall;						//!< Specifies which kind of recall we're in.
pavolmarko@128
   613
pavolmarko@128
   614
			IIface *pCurIface;
pavolmarko@128
   615
			const void *pOrigRet;
pavolmarko@162
   616
			void *pOverrideRet;
pavolmarko@128
   617
			void **pIfacePtrPtr;
pavolmarko@128
   618
		};
pavolmarko@128
   619
		typedef CStack<HookLoopInfo> HookLoopInfoStack;
pavolmarko@128
   620
pavolmarko@117
   621
		void ApplyCallClassPatches(CCallClassImpl &cc);
pavolmarko@58
   622
		void ApplyCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx, void *orig_entry);
pavolmarko@58
   623
		void RemoveCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx);
pavolmarko@1
   624
pavolmarko@117
   625
		void SetPluginPaused(Plugin plug, bool paused);
pavolmarko@117
   626
pavolmarko@128
   627
		HookLoopInfoStack m_HLIStack;
pavolmarko@324
   628
		CHookIDManager m_HookIDMan;
pavolmarko@328
   629
pavolmarko@328
   630
		void *m_OneIgnore; //:TODO:
pavolmarko@328
   631
		bool m_IgnoreActive;
pavolmarko@1
   632
	public:
pavolmarko@1
   633
		CSourceHookImpl();
pavolmarko@117
   634
		virtual ~CSourceHookImpl();
pavolmarko@1
   635
pavolmarko@1
   636
		/**
pavolmarko@58
   637
		*	@brief Returns the interface version
pavolmarko@58
   638
		*/
pavolmarko@58
   639
		int GetIfaceVersion();
pavolmarko@58
   640
pavolmarko@58
   641
		/**
pavolmarko@58
   642
		*	@brief Returns the implemnetation version
pavolmarko@58
   643
		*/
pavolmarko@58
   644
		int GetImplVersion();
pavolmarko@58
   645
pavolmarko@58
   646
		/**
pavolmarko@6
   647
		*	@brief Make sure that a plugin is not used by any other plugins anymore, and unregister all its hook managers
pavolmarko@1
   648
		*/
pavolmarko@1
   649
		void UnloadPlugin(Plugin plug);
pavolmarko@1
   650
pavolmarko@1
   651
		/**
pavolmarko@6
   652
		*	@brief Shut down the whole system, unregister all hook managers
pavolmarko@1
   653
		*/
pavolmarko@1
   654
		void CompleteShutdown();
pavolmarko@1
   655
pavolmarko@1
   656
		/**
pavolmarko@1
   657
		*	@brief Add a hook.
pavolmarko@1
   658
		*
pavolmarko@1
   659
		*	@return True if the function succeeded, false otherwise
pavolmarko@1
   660
		*
pavolmarko@1
   661
		*	@param plug The unique identifier of the plugin that calls this function
pavolmarko@1
   662
		*	@param iface The interface pointer
pavolmarko@6
   663
		*	@param ifacesize The size of the class iface points to
pavolmarko@6
   664
		*	@param myHookMan A hook manager function that should be capable of handling the function
pavolmarko@1
   665
		*	@param handler A pointer to a FastDelegate containing the hook handler
pavolmarko@1
   666
		*	@param post Set to true if you want a post handler
pavolmarko@1
   667
		*/
pavolmarko@41
   668
		bool AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post);
pavolmarko@1
   669
pavolmarko@1
   670
		/**
pavolmarko@1
   671
		*	@brief Removes a hook.
pavolmarko@1
   672
		*
pavolmarko@1
   673
		*	@return True if the function succeeded, false otherwise
pavolmarko@1
   674
		*
pavolmarko@1
   675
		*	@param plug The unique identifier of the plugin that calls this function
pavolmarko@1
   676
		*	@param iface The interface pointer
pavolmarko@41
   677
		*	@param thisptr_offs This pointer adjuster
pavolmarko@41
   678
		*	@param myHookMan A hook manager function that should be capable of handling the function
pavolmarko@41
   679
		*	@param handler A pointer to a FastDelegate containing the hook handler
pavolmarko@41
   680
		*	@param post Set to true if you want a post handler
pavolmarko@41
   681
		*/
pavolmarko@41
   682
		bool RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post);
pavolmarko@41
   683
pavolmarko@41
   684
		/**
pavolmarko@41
   685
		*	@brief Removes a hook.
pavolmarko@41
   686
		*
pavolmarko@41
   687
		*	@ return True if the function succeeded, false otherwise
pavolmarko@41
   688
		*
pavolmarko@41
   689
		*	@param info A RemoveHookInfo structure, describing the hook
pavolmarko@41
   690
		*/
pavolmarko@41
   691
		bool RemoveHook(RemoveHookInfo info);
pavolmarko@41
   692
pavolmarko@41
   693
		/**
pavolmarko@6
   694
		*	@brief Checks whether a plugin has (a) hook manager(s) that is/are currently used by other plugins
pavolmarko@1
   695
		*
pavolmarko@1
   696
		*	@param plug The unique identifier of the plugin in question
pavolmarko@1
   697
		*/
pavolmarko@1
   698
		bool IsPluginInUse(Plugin plug);
pavolmarko@1
   699
pavolmarko@1
   700
		/**
pavolmarko@8
   701
		*	@brief Pauses all hooks of a plugin
pavolmarko@8
   702
		*
pavolmarko@8
   703
		*	@param plug The unique identifier of the plugin
pavolmarko@8
   704
		*/
pavolmarko@8
   705
		void PausePlugin(Plugin plug);
pavolmarko@8
   706
pavolmarko@8
   707
		/**
pavolmarko@8
   708
		*	@brief Unpauses all hooks of a plugin
pavolmarko@8
   709
		*
pavolmarko@8
   710
		*	@param plug The unique identifier of the plugin
pavolmarko@8
   711
		*/
pavolmarko@8
   712
		void UnpausePlugin(Plugin plug);
pavolmarko@8
   713
pavolmarko@8
   714
		/**
pavolmarko@1
   715
		*	@brief Return a pointer to a callclass. Generate a new one if required.
pavolmarko@1
   716
		*
pavolmarko@1
   717
		*	@param iface The interface pointer
pavolmarko@58
   718
		*	@param size Size of the class instance
pavolmarko@1
   719
		*/
pavolmarko@332
   720
		DeprecatedCallClass<void> *GetCallClass(void *iface, size_t size);
pavolmarko@1
   721
pavolmarko@1
   722
		/**
pavolmarko@1
   723
		*	@brief Release a callclass
pavolmarko@1
   724
		*
pavolmarko@1
   725
		*	@param ptr Pointer to the callclass
pavolmarko@1
   726
		*/
pavolmarko@332
   727
		virtual void ReleaseCallClass(DeprecatedCallClass<void> *ptr);
pavolmarko@1
   728
pavolmarko@1
   729
		virtual void SetRes(META_RES res);				//!< Sets the meta result
pavolmarko@1
   730
		virtual META_RES GetPrevRes();					//!< Gets the meta result of the previously called handler
pavolmarko@1
   731
		virtual META_RES GetStatus();					//!< Gets the highest meta result
pavolmarko@1
   732
		virtual const void *GetOrigRet();				//!< Gets the original result. If not in post function, undefined
pavolmarko@1
   733
		virtual const void *GetOverrideRet();			//!< Gets the override result. If none is specified, NULL
pavolmarko@1
   734
		virtual void *GetIfacePtr();					//!< Gets the interface pointer
pavolmarko@1
   735
pavolmarko@1
   736
		//////////////////////////////////////////////////////////////////////////
pavolmarko@6
   737
		// For hook managers
pavolmarko@128
   738
		void HookLoopBegin(IIface *pIface);			//!< Should be called when a hook loop begins
pavolmarko@128
   739
		void HookLoopEnd();							//!< Should be called when a hook loop exits
pavolmarko@128
   740
		void SetCurResPtr(META_RES *mres);			//!< Sets pointer to the current meta result
pavolmarko@128
   741
		void SetPrevResPtr(META_RES *mres);			//!< Sets pointer to previous meta result
pavolmarko@128
   742
		void SetStatusPtr(META_RES *mres);			//!< Sets pointer to the status variable
pavolmarko@128
   743
		void SetIfacePtrPtr(void **pp);				//!< Sets pointer to the interface this pointer
pavolmarko@128
   744
		void SetOrigRetPtr(const void *ptr);		//!< Sets the original return pointer
pavolmarko@162
   745
		void SetOverrideRetPtr(void *ptr);			//!< Sets the override result pointer
pavolmarko@128
   746
		bool ShouldContinue();						//!< Returns false if the hook loop should exit
pavolmarko@157
   747
pavolmarko@157
   748
		/**
pavolmarko@157
   749
		*	@brief Remove a hook manager. Auto-removes all hooks attached to it from plugin plug.
pavolmarko@157
   750
		*
pavolmarko@157
   751
		*	@param plug The owner of the hook manager
pavolmarko@157
   752
		*   @param pubFunc The hook manager's info function
pavolmarko@157
   753
		*/
pavolmarko@157
   754
		virtual void RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc);
pavolmarko@163
   755
		virtual void RemoveHookManager(RemoveHookManInfo info);
pavolmarko@163
   756
pavolmarko@162
   757
		virtual void DoRecall();					//!< Initiates a recall sequence
pavolmarko@162
   758
		virtual void *GetOverrideRetPtr();			//!< Returns the pointer set by SetOverrideRetPtr
pavolmarko@162
   759
pavolmarko@162
   760
		virtual void *SetupHookLoop(META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr,
pavolmarko@162
   761
			void **ifacePtrPtr, const void *origRetPtr, void *overrideRetPtr);
pavolmarko@324
   762
pavolmarko@324
   763
		/**
pavolmarko@324
   764
		*	@brief Add a (VP) hook.
pavolmarko@324
   765
		*
pavolmarko@324
   766
		*	@return non-zero hook id on success, 0 otherwise
pavolmarko@324
   767
		*
pavolmarko@324
   768
		*	@param plug The unique identifier of the plugin that calls this function
pavolmarko@324
   769
		*	@param mode	Can be either Hook_Normal or Hook_VP (vtable-wide hook)
pavolmarko@324
   770
		*	@param iface The interface pointer
pavolmarko@328
   771
		*				 The representative interface pointer for VP hooks
pavolmarko@328
   772
		*				 The vtable pointer for direct VP hooks !!!
pavolmarko@324
   773
		*	@param ifacesize The size of the class iface points to
pavolmarko@324
   774
		*	@param myHookMan A hook manager function that should be capable of handling the function
pavolmarko@324
   775
		*	@param handler A pointer to a FastDelegate containing the hook handler
pavolmarko@324
   776
		*	@param post Set to true if you want a post handler
pavolmarko@324
   777
		*/
pavolmarko@324
   778
		virtual int AddHookNew(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
pavolmarko@324
   779
			ISHDelegate *handler, bool post);
pavolmarko@324
   780
pavolmarko@324
   781
		/**
pavolmarko@324
   782
		*	@brief Remove a VP hook by ID.
pavolmarko@324
   783
		*
pavolmarko@324
   784
		*	@return true on success, false otherwise
pavolmarko@324
   785
		*
pavolmarko@324
   786
		*	@param plug The unique identifier of the plugin that calls this function
pavolmarko@324
   787
		*	@param hookid The hook id (returned by AddHookNew)
pavolmarko@324
   788
		*/
pavolmarko@324
   789
		virtual bool RemoveHookByID(Plugin plug, int hookid);
pavolmarko@328
   790
pavolmarko@328
   791
		/**
pavolmarko@328
   792
		*	@brief Makes sure that hooks are going to be ignored on the next call of vfnptr
pavolmarko@328
   793
		*
pavolmarko@328
   794
		*	@param plug The unique identifier of the plugin that calls this function
pavolmarko@328
   795
		*	@param vfnptr The virtual function pointer of the function in question
pavolmarko@328
   796
		*/
pavolmarko@328
   797
		virtual void SetIgnoreHooks(Plugin plug, void *vfnptr);
pavolmarko@328
   798
pavolmarko@328
   799
		/**
pavolmarko@328
   800
		*	@brief Reverses SetIgnoreHooks' effect
pavolmarko@328
   801
		*
pavolmarko@328
   802
		*	@param plug The unique identifier of the plugin that calls this function
pavolmarko@328
   803
		*	@param vfnptr The virtual function pointer of the function in question
pavolmarko@328
   804
		*/
pavolmarko@328
   805
		virtual void ResetIgnoreHooks(Plugin plug, void *vfnptr);
pavolmarko@333
   806
pavolmarko@333
   807
		/**
pavolmarko@333
   808
		*	@brief Finds the original entry of a virtual function pointer
pavolmarko@333
   809
		*
pavolmarko@333
   810
		*	@param vfnptr The virtual function pointer
pavolmarko@333
   811
		*	@return The original entry if the virtual function pointer has been patched; NULL otherwise.
pavolmarko@333
   812
		*/
pavolmarko@333
   813
		virtual void *GetOrigVfnPtrEntry(void *vfnptr);
pavolmarko@1
   814
	};
pavolmarko@1
   815
}
pavolmarko@1
   816
dvander@34
   817
#endif