sourcehook/sourcehook.cpp
author Pavol Marko <pavolmarko@gmail.com>
Sun May 01 12:36:48 2005 +0000 (2005-05-01)
changeset 48 a52dba4f8ed9
parent 47 0d8950ea695b
child 50 4b6bbaf375dc
permissions -rw-r--r--
linux/gcc/32bit compatibility
     1 /* ======== SourceHook ========
     2 * Copyright (C) 2004-2005 Metamod:Source Development Team
     3 * No warranties of any kind
     4 *
     5 * License: zlib/libpng
     6 *
     7 * Author(s): Pavol "PM OnoTo" Marko
     8 * ============================
     9 */
    10 
    11 /**
    12  * @file sourcehook.cpp
    13  * @brief Contains the implementation of the SourceHook API
    14 */
    15 
    16 #include <algorithm>
    17 #include "sourcehook_impl.h"
    18 
    19 namespace SourceHook
    20 {
    21 	CSourceHookImpl::CSourceHookImpl()
    22 	{
    23 	}
    24 
    25 	CSourceHookImpl::~CSourceHookImpl()
    26 	{
    27 	}
    28 
    29 	bool CSourceHookImpl::IsPluginInUse(Plugin plug)
    30 	{
    31 		// Iterate through all hook managers which are in this plugin
    32 		// Iterate through their vfnptrs, ifaces, hooks
    33 		// If a hook from an other plugin is found, return true
    34 		// Return false otherwise
    35 #define TMP_CHECK_LIST(name) \
    36 	for (hook_iter = iface_iter->name.begin(); hook_iter != iface_iter->name.end(); ++hook_iter) \
    37 		if (hook_iter->plug == plug) \
    38 			return true;
    39 
    40 		for (HookManInfoList::iterator hmil_iter = m_HookMans.begin(); hmil_iter != m_HookMans.end(); ++hmil_iter)
    41 		{
    42 			if (hmil_iter->plug != plug)
    43 				continue;
    44 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->vfnptrs.begin();
    45 				vfnptr_iter != hmil_iter->vfnptrs.end(); ++vfnptr_iter)
    46 			{
    47 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
    48 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
    49 				{
    50 					std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hook_iter;
    51 					TMP_CHECK_LIST(hooks_pre);
    52 					TMP_CHECK_LIST(hooks_post);
    53 				}
    54 			}
    55 		}
    56 #undef TMP_CHECK_LIST
    57 		return false;
    58 	}
    59 
    60 	void CSourceHookImpl::UnloadPlugin(Plugin plug)
    61 	{
    62 		// 1) Manually remove all hooks by this plugin
    63 		std::list<RemoveHookInfo> hookstoremove;
    64 #define TMP_CHECK_LIST(name, ispost) \
    65 	for (hook_iter = iface_iter->name.begin(); hook_iter != iface_iter->name.end(); ++hook_iter) \
    66 		if (hook_iter->plug == plug) \
    67 			hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->ptr, \
    68 			hmil_iter->func, hook_iter->handler, ispost))
    69 		for (HookManInfoList::iterator hmil_iter = m_HookMans.begin(); hmil_iter != m_HookMans.end(); ++hmil_iter)
    70 		{
    71 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->vfnptrs.begin();
    72 				vfnptr_iter != hmil_iter->vfnptrs.end(); ++vfnptr_iter)
    73 			{
    74 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
    75 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
    76 				{
    77 					std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hook_iter;
    78 					TMP_CHECK_LIST(hooks_pre, false);
    79 					TMP_CHECK_LIST(hooks_post, true);
    80 				}
    81 			}
    82 		}
    83 #undef TMP_CHECK_LIST
    84 
    85 		for (std::list<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
    86 			RemoveHook(*rmiter);
    87 
    88 		// 2) Other plugins may use hook managers in this plugin.
    89 		// Get a list of hook managers that are in this plugin and are used by other plugins
    90 		// Delete all hook managers that are in this plugin
    91 
    92 		HookManInfoList tmphookmans;
    93 		bool erase = false;
    94 		for (HookManInfoList::iterator hmil_iter = m_HookMans.begin(); hmil_iter != m_HookMans.end();
    95 			erase ? hmil_iter=m_HookMans.erase(hmil_iter) : ++hmil_iter)
    96 		{
    97 			if (hmil_iter->plug == plug)
    98 			{
    99 				if (!hmil_iter->vfnptrs.empty())
   100 				{
   101 					// All hooks by this plugin are already removed
   102 					// So if there is a vfnptr, it has to be used by an other plugin
   103 					tmphookmans.push_back(*hmil_iter);
   104 				}
   105 				erase = true;
   106 			}
   107 			else
   108 				erase = false;
   109 		}
   110 		
   111 		// For each hook manager:
   112 		for (HookManInfoList::iterator hmil_iter = tmphookmans.begin(); hmil_iter != tmphookmans.end(); ++hmil_iter)
   113 		{
   114 			// Find a suitable hook manager in an other plugin
   115 			HookManInfoList::iterator newHookMan = FindHookMan(m_HookMans.begin(), m_HookMans.end(),
   116 				hmil_iter->proto, hmil_iter->vtbl_offs, hmil_iter->vtbl_idx);
   117 
   118 			// This should _never_ happen.
   119 			// If there is a hook from an other plugin, the plugin must have provided a hook manager as well.
   120 			SH_ASSERT(newHookMan != m_HookMans.end(),
   121 				"Could not find a suitable hook manager in an other plugin!");
   122 
   123 			// AddHook should make sure that every plugin only has _one_ hook manager for _one_ proto/vi/vo
   124 			SH_ASSERT(newHookMan->plug != plug, "New hook manager from same plugin!");
   125 
   126 			// The first hook manager should be always used - so the new hook manager has to be empty
   127 			SH_ASSERT(newHookMan->vfnptrs.empty(), "New hook manager not empty!");
   128 
   129 			// Move the vfnptrs from the old hook manager to the new one
   130 			newHookMan->vfnptrs = hmil_iter->vfnptrs;
   131 
   132 			// Unregister the old one, register the new one
   133 			hmil_iter->func(HA_Unregister, NULL);
   134 			newHookMan->func(HA_Register, &(*newHookMan));
   135 		}
   136 	}
   137 
   138 	void CSourceHookImpl::CompleteShutdown()
   139 	{
   140 		std::list<RemoveHookInfo> hookstoremove;
   141 #define TMP_CHECK_LIST(name, ispost) \
   142 	for (hook_iter = iface_iter->name.begin(); hook_iter != iface_iter->name.end(); ++hook_iter) \
   143 		hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->ptr, \
   144 		hmil_iter->func, hook_iter->handler, ispost))
   145 		for (HookManInfoList::iterator hmil_iter = m_HookMans.begin(); hmil_iter != m_HookMans.end(); ++hmil_iter)
   146 		{
   147 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->vfnptrs.begin();
   148 				vfnptr_iter != hmil_iter->vfnptrs.end(); ++vfnptr_iter)
   149 			{
   150 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   151 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
   152 				{
   153 					std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hook_iter;
   154 					TMP_CHECK_LIST(hooks_pre, false);
   155 					TMP_CHECK_LIST(hooks_post, true);
   156 				}
   157 			}
   158 		}
   159 #undef TMP_CHECK_LIST
   160 
   161 		for (std::list<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
   162 			RemoveHook(*rmiter);
   163 
   164 		m_HookMans.clear();
   165 	}
   166 
   167 	bool CSourceHookImpl::AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   168 	{
   169 		void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
   170 		// 1) Get info about the hook manager
   171 		HookManagerInfo tmp;
   172 		if (myHookMan(HA_GetInfo, &tmp) != 0)
   173 			return false;
   174 
   175 		// Add the proposed hook manager to the _end_ of the list if the plugin doesn't have a hook manager with this proto/vo/vi registered
   176 		HookManInfoList::iterator hkmi_iter;
   177 		for (hkmi_iter = m_HookMans.begin(); hkmi_iter != m_HookMans.end(); ++hkmi_iter)
   178 		{
   179 			if (hkmi_iter->plug == plug && strcmp(hkmi_iter->proto, tmp.proto) == 0 &&
   180 				hkmi_iter->vtbl_offs == tmp.vtbl_offs && hkmi_iter->vtbl_idx == tmp.vtbl_idx)
   181 				break;
   182 		}
   183 		if (hkmi_iter == m_HookMans.end())
   184 		{
   185 			// No such hook manager from this plugin yet, add it!
   186 			tmp.func = myHookMan;
   187 			tmp.plug = plug;
   188 			m_HookMans.push_back(tmp);
   189 		}
   190 
   191 		// Then, search for a suitable hook manager (from the beginning)
   192 		HookManInfoList::iterator hookman = FindHookMan(m_HookMans.begin(), m_HookMans.end(), tmp.proto, tmp.vtbl_offs, tmp.vtbl_idx);
   193 		SH_ASSERT(hookman != m_HookMans.end(), "No hookman found - but if there was none, we've just added one!");
   194 
   195 		// Tell it to store the pointer if it's not already active
   196 		if (hookman->vfnptrs.empty())
   197 			hookman->func(HA_Register, &(*hookman));
   198 
   199 		void **cur_vtptr = *reinterpret_cast<void***>(
   200 			reinterpret_cast<char*>(adjustediface) + tmp.vtbl_offs);
   201 		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.vtbl_idx);
   202 
   203 		HookManagerInfo::VfnPtrListIter vfnptr_iter = std::find(
   204 			hookman->vfnptrs.begin(), hookman->vfnptrs.end(), cur_vfnptr);
   205 
   206 		if (vfnptr_iter == hookman->vfnptrs.end())
   207 		{
   208 			// Add a new one
   209 			HookManagerInfo::VfnPtr vfp;
   210 			vfp.vfnptr = cur_vfnptr;
   211 			vfp.orig_entry = *reinterpret_cast<void**>(cur_vfnptr);
   212 			hookman->vfnptrs.push_back(vfp);
   213 
   214 			// Alter vtable entry
   215 			SetMemAccess(cur_vtptr, sizeof(void*) * (tmp.vtbl_idx + 1), SH_MEM_READ | SH_MEM_WRITE);
   216 			*reinterpret_cast<void**>(cur_vfnptr) = *reinterpret_cast<void**>(hookman->hookfunc_vfnptr);
   217 
   218 			// Make vfnptr_iter point to the new element
   219 			vfnptr_iter = hookman->vfnptrs.end();
   220 			--vfnptr_iter;
   221 
   222 			// Now that it is done, check whether we have to update any callclasses
   223 			for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   224 				if (cciter->cc.ptr == iface)
   225 					ApplyCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx, vfnptr_iter->orig_entry);
   226 		}
   227 
   228 		HookManagerInfo::VfnPtr::IfaceListIter iface_iter = std::find(
   229 			vfnptr_iter->ifaces.begin(), vfnptr_iter->ifaces.end(), adjustediface);
   230 		if (iface_iter == vfnptr_iter->ifaces.end())
   231 		{
   232 			// Add a new one
   233 			HookManagerInfo::VfnPtr::Iface ifs;
   234 			ifs.ptr = adjustediface;
   235 			vfnptr_iter->ifaces.push_back(ifs);
   236 
   237 			// Make iface_iter point to the new element
   238 			iface_iter = vfnptr_iter->ifaces.end();
   239 			--iface_iter;
   240 		}
   241 
   242 		// Add the hook
   243 		HookManagerInfo::VfnPtr::Iface::Hook hookinfo;
   244 		hookinfo.handler = handler;
   245 		hookinfo.plug = plug;
   246 		hookinfo.paused = false;
   247 		if (post)
   248    			iface_iter->hooks_post.push_back(hookinfo);
   249 		else
   250 			iface_iter->hooks_pre.push_back(hookinfo);
   251 
   252 
   253 		return true;
   254 	}
   255 
   256 	bool CSourceHookImpl::RemoveHook(RemoveHookInfo info)
   257 	{
   258 		return RemoveHook(info.plug, info.iface, info.hookman, info.handler, info.post);
   259 	}
   260 
   261 	bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   262 	{
   263 		return RemoveHook(plug, reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs),
   264 			myHookMan, handler, post);
   265 	}
   266 
   267 	bool CSourceHookImpl::RemoveHook(Plugin plug, void *adjustediface, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   268 	{
   269 		HookManagerInfo tmp;
   270 		if (myHookMan(HA_GetInfo, &tmp) != 0)
   271 			return false;
   272 
   273 		// Find the hook manager and the hook
   274 		HookManInfoList::iterator hookman = FindHookMan(m_HookMans.begin(), m_HookMans.end(), 
   275 			tmp.proto, tmp.vtbl_offs, tmp.vtbl_idx);
   276 		if (hookman == m_HookMans.end())
   277 			return false;
   278 
   279 		void **cur_vtptr = *reinterpret_cast<void***>(
   280 			reinterpret_cast<char*>(adjustediface) + tmp.vtbl_offs);
   281 		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.vtbl_idx);
   282 
   283 		HookManagerInfo::VfnPtrListIter vfnptr_iter = std::find(hookman->vfnptrs.begin(), hookman->vfnptrs.end(), cur_vfnptr);
   284 		if (vfnptr_iter == hookman->vfnptrs.end())
   285 			return false;
   286 
   287 		for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   288 			iface_iter != vfnptr_iter->ifaces.end();)
   289 		{
   290 			std::list<HookManagerInfo::VfnPtr::Iface::Hook> &hooks =
   291 				post ? iface_iter->hooks_post : iface_iter->hooks_pre;
   292 
   293 			bool erase;
   294 			for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = hooks.begin();
   295 				hookiter != hooks.end(); erase ? hookiter = hooks.erase(hookiter) : ++hookiter)
   296 			{
   297 				erase = hookiter->plug == plug && hookiter->handler->IsEqual(handler);
   298 				if (erase)
   299 					hookiter->handler->DeleteThis();			// Make the _plugin_ delete the handler object
   300 			}
   301 			if (iface_iter->hooks_post.empty() && iface_iter->hooks_pre.empty())
   302 			{
   303 				iface_iter = vfnptr_iter->ifaces.erase(iface_iter);
   304 				if (vfnptr_iter->ifaces.empty())
   305 				{
   306 					// Deactivate the hook
   307 					*reinterpret_cast<void**>(vfnptr_iter->vfnptr) = vfnptr_iter->orig_entry;
   308 					
   309 					hookman->vfnptrs.erase(vfnptr_iter);
   310 
   311 					// Remove callclass patch
   312 					for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   313 						if (cciter->cc.ptr == adjustediface)
   314 							RemoveCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx);
   315 
   316 					if (hookman->vfnptrs.empty())
   317 					{
   318 						// Unregister the hook manager
   319 						hookman->func(HA_Unregister, NULL);
   320 					}
   321 
   322 					// Don't try to continue looping through ifaces
   323 					// - the list is already invalid
   324 					return true;
   325 				}
   326 			}
   327 			else
   328 				++iface_iter;
   329 		}
   330 		return true;
   331 	}
   332 
   333 	GenericCallClass *CSourceHookImpl::GetCallClass(void *iface)
   334 	{
   335 		for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   336 		{
   337 			if (cciter->cc.ptr == iface)
   338 			{
   339 				++cciter->refcounter;
   340 				return &cciter->cc;
   341 			}
   342 		}
   343 
   344 		CallClassInfo tmp;
   345 		tmp.refcounter = 1;
   346 		tmp.cc.ptr = iface;
   347 
   348 		for (HookManInfoList::iterator hookman = m_HookMans.begin(); hookman != m_HookMans.end(); ++hookman)
   349 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->vfnptrs.begin();
   350 				vfnptr_iter != hookman->vfnptrs.end(); ++vfnptr_iter)
   351 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   352 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
   353 					if (iface_iter->ptr == iface)
   354 						ApplyCallClassPatch(tmp, hookman->vtbl_offs, hookman->vtbl_idx,
   355 						vfnptr_iter->orig_entry);
   356 
   357 		m_CallClasses.push_back(tmp);
   358 		return &m_CallClasses.back().cc;
   359 	}
   360 
   361 	void CSourceHookImpl::ReleaseCallClass(GenericCallClass *ptr)
   362 	{
   363 		Impl_CallClassList::iterator iter = std::find(m_CallClasses.begin(), m_CallClasses.end(), ptr);
   364 		if (iter == m_CallClasses.end())
   365 			return;
   366 		--iter->refcounter;
   367 		if (iter->refcounter < 1)
   368 			m_CallClasses.erase(iter);
   369 	}
   370 
   371 	void CSourceHookImpl::ApplyCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx, void *orig_entry)
   372 	{
   373 		OrigFuncs &tmpvec = cc.cc.vt[vtbl_offs];
   374 		if (tmpvec.size() <= (size_t)vtbl_idx)
   375 			tmpvec.resize(vtbl_idx+1);
   376 		tmpvec[vtbl_idx] = orig_entry;
   377 	}
   378 
   379 	void CSourceHookImpl::RemoveCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx)
   380 	{
   381 		OrigVTables::iterator iter = cc.cc.vt.find(vtbl_offs);
   382 		if (iter != cc.cc.vt.end())
   383 		{
   384 			if (iter->second.size() > (size_t)vtbl_idx)
   385 			{
   386 				iter->second[vtbl_idx] = 0;
   387 				// Free some memory if possible
   388 				OrigFuncs::reverse_iterator riter;
   389 				for (riter = iter->second.rbegin(); riter != iter->second.rend(); ++riter)
   390 				{
   391 					if (*riter != 0)
   392 						break;
   393 				}
   394 				iter->second.resize(iter->second.size() - (riter - iter->second.rbegin()));
   395 				if (!iter->second.size())
   396 					cc.cc.vt.erase(iter);
   397 			}
   398 		}
   399 	}
   400 
   401 	CSourceHookImpl::HookManInfoList::iterator CSourceHookImpl::FindHookMan(HookManInfoList::iterator begin,
   402 		HookManInfoList::iterator end, const char *proto, int vtblofs, int vtblidx)
   403 	{
   404 		HookManInfoList::iterator hookmaniter; 
   405 		for (hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   406 		{
   407 			if (strcmp(hookmaniter->proto, proto) == 0 && hookmaniter->vtbl_offs == vtblofs &&
   408 				hookmaniter->vtbl_idx == vtblidx)
   409 				break;
   410 		}
   411 		return hookmaniter;
   412 	}
   413 
   414 	void CSourceHookImpl::PausePlugin(Plugin plug)
   415 	{
   416 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   417 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   418 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   419 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   420 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   421 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   422 				{
   423 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   424 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   425 						if (plug == hookiter->plug)
   426 							hookiter->paused = true;
   427 
   428 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   429 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   430 						if (plug == hookiter->plug)
   431 							hookiter->paused = true;
   432 				}
   433 	}
   434 
   435 	void CSourceHookImpl::UnpausePlugin(Plugin plug)
   436 	{
   437 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   438 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   439 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   440 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   441 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   442 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   443 				{
   444 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   445 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   446 						if (plug == hookiter->plug)
   447 							hookiter->paused = false;
   448 
   449 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   450 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   451 						if (plug == hookiter->plug)
   452 							hookiter->paused = false;
   453 				}
   454 	}
   455 
   456 	void CSourceHookImpl::SetRes(META_RES res)
   457 	{
   458 		m_CurRes = res;
   459 	}
   460 
   461 	META_RES CSourceHookImpl::GetPrevRes()
   462 	{
   463 		return m_PrevRes;
   464 	}
   465 
   466 	META_RES CSourceHookImpl::GetStatus()
   467 	{
   468 		return m_Status;
   469 	}
   470 
   471 	const void *CSourceHookImpl::GetOrigRet()
   472 	{
   473 		return m_OrigRet;
   474 	}
   475 
   476 	const void *CSourceHookImpl::GetOverrideRet()
   477 	{
   478 		return m_OverrideRet;
   479 	}
   480 
   481 	META_RES &CSourceHookImpl::GetCurResRef()
   482 	{
   483 		return m_CurRes;
   484 	}
   485 
   486 	META_RES &CSourceHookImpl::GetPrevResRef()
   487 	{
   488 		return m_PrevRes;
   489 	}
   490 
   491 	META_RES &CSourceHookImpl::GetStatusRef()
   492 	{
   493 		return m_Status;
   494 	}
   495 
   496 	void CSourceHookImpl::SetOrigRet(const void *ptr)
   497 	{
   498 		m_OrigRet = ptr;
   499 	}
   500 
   501 	void CSourceHookImpl::SetOverrideRet(const void *ptr)
   502 	{
   503 		m_OverrideRet = ptr;
   504 	}
   505 
   506 	void CSourceHookImpl::SetIfacePtr(void *ptr)
   507 	{
   508 		m_IfacePtr = ptr;
   509 	}
   510 	void *CSourceHookImpl::GetIfacePtr()
   511 	{
   512 		return m_IfacePtr;
   513 	}
   514 }