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