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