sourcehook/sourcehook.cpp
author Pavol Marko <pavolmarko@gmail.com>
Sun May 01 18:04:18 2005 +0000 (2005-05-01)
changeset 50 4b6bbaf375dc
parent 48 a52dba4f8ed9
child 58 71016f952503
permissions -rw-r--r--
Fixes
     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 
   213 			// Alter vtable entry
   214 			if (!SetMemAccess(cur_vtptr, sizeof(void*) * (tmp.vtbl_idx + 1), SH_MEM_READ | SH_MEM_WRITE))
   215 				return false;
   216 			
   217 			*reinterpret_cast<void**>(cur_vfnptr) = *reinterpret_cast<void**>(hookman->hookfunc_vfnptr);
   218 
   219 			hookman->vfnptrs.push_back(vfp);
   220 			
   221 			// Make vfnptr_iter point to the new element
   222 			vfnptr_iter = hookman->vfnptrs.end();
   223 			--vfnptr_iter;
   224 
   225 			// Now that it is done, check whether we have to update any callclasses
   226 			for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   227 				if (cciter->cc.ptr == iface)
   228 					ApplyCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx, vfnptr_iter->orig_entry);
   229 		}
   230 
   231 		HookManagerInfo::VfnPtr::IfaceListIter iface_iter = std::find(
   232 			vfnptr_iter->ifaces.begin(), vfnptr_iter->ifaces.end(), adjustediface);
   233 		if (iface_iter == vfnptr_iter->ifaces.end())
   234 		{
   235 			// Add a new one
   236 			HookManagerInfo::VfnPtr::Iface ifs;
   237 			ifs.ptr = adjustediface;
   238 			vfnptr_iter->ifaces.push_back(ifs);
   239 
   240 			// Make iface_iter point to the new element
   241 			iface_iter = vfnptr_iter->ifaces.end();
   242 			--iface_iter;
   243 		}
   244 
   245 		// Add the hook
   246 		HookManagerInfo::VfnPtr::Iface::Hook hookinfo;
   247 		hookinfo.handler = handler;
   248 		hookinfo.plug = plug;
   249 		hookinfo.paused = false;
   250 		if (post)
   251    			iface_iter->hooks_post.push_back(hookinfo);
   252 		else
   253 			iface_iter->hooks_pre.push_back(hookinfo);
   254 
   255 
   256 		return true;
   257 	}
   258 
   259 	bool CSourceHookImpl::RemoveHook(RemoveHookInfo info)
   260 	{
   261 		return RemoveHook(info.plug, info.iface, info.hookman, info.handler, info.post);
   262 	}
   263 
   264 	bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   265 	{
   266 		return RemoveHook(plug, reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs),
   267 			myHookMan, handler, post);
   268 	}
   269 
   270 	bool CSourceHookImpl::RemoveHook(Plugin plug, void *adjustediface, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   271 	{
   272 		HookManagerInfo tmp;
   273 		if (myHookMan(HA_GetInfo, &tmp) != 0)
   274 			return false;
   275 
   276 		// Find the hook manager and the hook
   277 		HookManInfoList::iterator hookman = FindHookMan(m_HookMans.begin(), m_HookMans.end(), 
   278 			tmp.proto, tmp.vtbl_offs, tmp.vtbl_idx);
   279 		if (hookman == m_HookMans.end())
   280 			return false;
   281 
   282 		void **cur_vtptr = *reinterpret_cast<void***>(
   283 			reinterpret_cast<char*>(adjustediface) + tmp.vtbl_offs);
   284 		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.vtbl_idx);
   285 
   286 		HookManagerInfo::VfnPtrListIter vfnptr_iter = std::find(hookman->vfnptrs.begin(), hookman->vfnptrs.end(), cur_vfnptr);
   287 		if (vfnptr_iter == hookman->vfnptrs.end())
   288 			return false;
   289 
   290 		for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   291 			iface_iter != vfnptr_iter->ifaces.end();)
   292 		{
   293 			std::list<HookManagerInfo::VfnPtr::Iface::Hook> &hooks =
   294 				post ? iface_iter->hooks_post : iface_iter->hooks_pre;
   295 
   296 			bool erase;
   297 			for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = hooks.begin();
   298 				hookiter != hooks.end(); erase ? hookiter = hooks.erase(hookiter) : ++hookiter)
   299 			{
   300 				erase = hookiter->plug == plug && hookiter->handler->IsEqual(handler);
   301 				if (erase)
   302 					hookiter->handler->DeleteThis();			// Make the _plugin_ delete the handler object
   303 			}
   304 			if (iface_iter->hooks_post.empty() && iface_iter->hooks_pre.empty())
   305 			{
   306 				iface_iter = vfnptr_iter->ifaces.erase(iface_iter);
   307 				if (vfnptr_iter->ifaces.empty())
   308 				{
   309 					// Deactivate the hook
   310 					*reinterpret_cast<void**>(vfnptr_iter->vfnptr) = vfnptr_iter->orig_entry;
   311 					
   312 					hookman->vfnptrs.erase(vfnptr_iter);
   313 
   314 					// Remove callclass patch
   315 					for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   316 						if (cciter->cc.ptr == adjustediface)
   317 							RemoveCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx);
   318 
   319 					if (hookman->vfnptrs.empty())
   320 					{
   321 						// Unregister the hook manager
   322 						hookman->func(HA_Unregister, NULL);
   323 					}
   324 
   325 					// Don't try to continue looping through ifaces
   326 					// - the list is already invalid
   327 					return true;
   328 				}
   329 			}
   330 			else
   331 				++iface_iter;
   332 		}
   333 		return true;
   334 	}
   335 
   336 	GenericCallClass *CSourceHookImpl::GetCallClass(void *iface)
   337 	{
   338 		for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   339 		{
   340 			if (cciter->cc.ptr == iface)
   341 			{
   342 				++cciter->refcounter;
   343 				return &cciter->cc;
   344 			}
   345 		}
   346 
   347 		CallClassInfo tmp;
   348 		tmp.refcounter = 1;
   349 		tmp.cc.ptr = iface;
   350 
   351 		for (HookManInfoList::iterator hookman = m_HookMans.begin(); hookman != m_HookMans.end(); ++hookman)
   352 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->vfnptrs.begin();
   353 				vfnptr_iter != hookman->vfnptrs.end(); ++vfnptr_iter)
   354 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   355 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
   356 					if (iface_iter->ptr == iface)
   357 						ApplyCallClassPatch(tmp, hookman->vtbl_offs, hookman->vtbl_idx,
   358 						vfnptr_iter->orig_entry);
   359 
   360 		m_CallClasses.push_back(tmp);
   361 		return &m_CallClasses.back().cc;
   362 	}
   363 
   364 	void CSourceHookImpl::ReleaseCallClass(GenericCallClass *ptr)
   365 	{
   366 		Impl_CallClassList::iterator iter = std::find(m_CallClasses.begin(), m_CallClasses.end(), ptr);
   367 		if (iter == m_CallClasses.end())
   368 			return;
   369 		--iter->refcounter;
   370 		if (iter->refcounter < 1)
   371 			m_CallClasses.erase(iter);
   372 	}
   373 
   374 	void CSourceHookImpl::ApplyCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx, void *orig_entry)
   375 	{
   376 		OrigFuncs &tmpvec = cc.cc.vt[vtbl_offs];
   377 		if (tmpvec.size() <= (size_t)vtbl_idx)
   378 			tmpvec.resize(vtbl_idx+1);
   379 		tmpvec[vtbl_idx] = orig_entry;
   380 	}
   381 
   382 	void CSourceHookImpl::RemoveCallClassPatch(CallClassInfo &cc, int vtbl_offs, int vtbl_idx)
   383 	{
   384 		OrigVTables::iterator iter = cc.cc.vt.find(vtbl_offs);
   385 		if (iter != cc.cc.vt.end())
   386 		{
   387 			if (iter->second.size() > (size_t)vtbl_idx)
   388 			{
   389 				iter->second[vtbl_idx] = 0;
   390 				// Free some memory if possible
   391 				OrigFuncs::reverse_iterator riter;
   392 				for (riter = iter->second.rbegin(); riter != iter->second.rend(); ++riter)
   393 				{
   394 					if (*riter != 0)
   395 						break;
   396 				}
   397 				iter->second.resize(iter->second.size() - (riter - iter->second.rbegin()));
   398 				if (!iter->second.size())
   399 					cc.cc.vt.erase(iter);
   400 			}
   401 		}
   402 	}
   403 
   404 	CSourceHookImpl::HookManInfoList::iterator CSourceHookImpl::FindHookMan(HookManInfoList::iterator begin,
   405 		HookManInfoList::iterator end, const char *proto, int vtblofs, int vtblidx)
   406 	{
   407 		HookManInfoList::iterator hookmaniter; 
   408 		for (hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   409 		{
   410 			if (strcmp(hookmaniter->proto, proto) == 0 && hookmaniter->vtbl_offs == vtblofs &&
   411 				hookmaniter->vtbl_idx == vtblidx)
   412 				break;
   413 		}
   414 		return hookmaniter;
   415 	}
   416 
   417 	void CSourceHookImpl::PausePlugin(Plugin plug)
   418 	{
   419 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   420 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   421 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   422 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   423 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   424 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   425 				{
   426 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   427 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   428 						if (plug == hookiter->plug)
   429 							hookiter->paused = true;
   430 
   431 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   432 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   433 						if (plug == hookiter->plug)
   434 							hookiter->paused = true;
   435 				}
   436 	}
   437 
   438 	void CSourceHookImpl::UnpausePlugin(Plugin plug)
   439 	{
   440 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   441 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   442 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   443 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   444 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   445 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   446 				{
   447 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   448 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   449 						if (plug == hookiter->plug)
   450 							hookiter->paused = false;
   451 
   452 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   453 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   454 						if (plug == hookiter->plug)
   455 							hookiter->paused = false;
   456 				}
   457 	}
   458 
   459 	void CSourceHookImpl::SetRes(META_RES res)
   460 	{
   461 		m_CurRes = res;
   462 	}
   463 
   464 	META_RES CSourceHookImpl::GetPrevRes()
   465 	{
   466 		return m_PrevRes;
   467 	}
   468 
   469 	META_RES CSourceHookImpl::GetStatus()
   470 	{
   471 		return m_Status;
   472 	}
   473 
   474 	const void *CSourceHookImpl::GetOrigRet()
   475 	{
   476 		return m_OrigRet;
   477 	}
   478 
   479 	const void *CSourceHookImpl::GetOverrideRet()
   480 	{
   481 		return m_OverrideRet;
   482 	}
   483 
   484 	META_RES &CSourceHookImpl::GetCurResRef()
   485 	{
   486 		return m_CurRes;
   487 	}
   488 
   489 	META_RES &CSourceHookImpl::GetPrevResRef()
   490 	{
   491 		return m_PrevRes;
   492 	}
   493 
   494 	META_RES &CSourceHookImpl::GetStatusRef()
   495 	{
   496 		return m_Status;
   497 	}
   498 
   499 	void CSourceHookImpl::SetOrigRet(const void *ptr)
   500 	{
   501 		m_OrigRet = ptr;
   502 	}
   503 
   504 	void CSourceHookImpl::SetOverrideRet(const void *ptr)
   505 	{
   506 		m_OverrideRet = ptr;
   507 	}
   508 
   509 	void CSourceHookImpl::SetIfacePtr(void *ptr)
   510 	{
   511 		m_IfacePtr = ptr;
   512 	}
   513 	void *CSourceHookImpl::GetIfacePtr()
   514 	{
   515 		return m_IfacePtr;
   516 	}
   517 }