sourcehook/sourcehook.cpp
author Pavol Marko <pavolmarko@gmail.com>
Fri Apr 29 20:29:46 2005 +0000 (2005-04-29)
changeset 41 534eac4c53ef
parent 34 11e62a912700
child 42 390a2aec00e4
permissions -rw-r--r--
Completly redone templates, added "vfnptrs"
     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, 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 
   223 		HookManagerInfo::VfnPtr::IfaceListIter iface_iter = std::find(
   224 			vfnptr_iter->ifaces.begin(), vfnptr_iter->ifaces.end(), adjustediface);
   225 		if (iface_iter == vfnptr_iter->ifaces.end())
   226 		{
   227 			// Add a new one
   228 			HookManagerInfo::VfnPtr::Iface ifs;
   229 			ifs.ptr = adjustediface;
   230 			vfnptr_iter->ifaces.push_back(ifs);
   231 
   232 			// Make iface_iter point to the new element
   233 			iface_iter = vfnptr_iter->ifaces.end();
   234 			--iface_iter;
   235 		}
   236 
   237 		// Add the hook
   238 		HookManagerInfo::VfnPtr::Iface::Hook hookinfo;
   239 		hookinfo.handler = handler;
   240 		hookinfo.plug = plug;
   241 		hookinfo.paused = false;
   242 		if (post)
   243    			iface_iter->hooks_post.push_back(hookinfo);
   244 		else
   245 			iface_iter->hooks_pre.push_back(hookinfo);
   246 
   247 
   248 		// Now that it is done, check whether we have to update any callclasses
   249 		for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
   250 		{
   251 			if (cciter->cc.ptr == iface)
   252 			{
   253 				ApplyCallClassPatch(*cciter, tmp.vtbl_offs, tmp.vtbl_idx, vfnptr_iter->orig_entry);
   254 
   255 				// We can assume that there is no more callclass for the same iface
   256 				break;
   257 			}
   258 		}
   259 
   260 		return true;
   261 	}
   262 
   263 	bool CSourceHookImpl::RemoveHook(RemoveHookInfo info)
   264 	{
   265 		return RemoveHook(info.plug, info.iface, info.hookman, info.handler, info.post);
   266 	}
   267 
   268 	bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   269 	{
   270 		return RemoveHook(plug, reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs),
   271 			myHookMan, handler, post);
   272 	}
   273 
   274 	bool CSourceHookImpl::RemoveHook(Plugin plug, void *adjustediface, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
   275 	{
   276 		HookManagerInfo tmp;
   277 		if (myHookMan(HA_GetInfo, &tmp) != 0)
   278 			return false;
   279 
   280 		// Find the hook manager and the hook
   281 		HookManInfoList::iterator hookman = FindHookMan(m_HookMans.begin(), m_HookMans.end(), 
   282 			tmp.proto, tmp.vtbl_offs, tmp.vtbl_idx);
   283 		if (hookman == m_HookMans.end())
   284 			return false;
   285 
   286 		void **cur_vtptr = *reinterpret_cast<void***>(
   287 			reinterpret_cast<char*>(adjustediface) + tmp.vtbl_offs);
   288 		void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.vtbl_idx);
   289 
   290 		for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->vfnptrs.begin();
   291 			vfnptr_iter != hookman->vfnptrs.end(); ++vfnptr_iter)
   292 		{
   293 			if (vfnptr_iter->vfnptr == cur_vfnptr)
   294 			{
   295 				for (HookManagerInfo::VfnPtr::IfaceListIter iface_iter = vfnptr_iter->ifaces.begin();
   296 					iface_iter != vfnptr_iter->ifaces.end(); ++iface_iter)
   297 				{
   298 					std::list<HookManagerInfo::VfnPtr::Iface::Hook> &hooks =
   299 						post ? iface_iter->hooks_post : iface_iter->hooks_pre;
   300 
   301 					bool erase;
   302 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = hooks.begin();
   303 						hookiter != hooks.end(); erase ? hookiter = hooks.erase(hookiter) : ++hookiter)
   304 					{
   305 						erase = hookiter->plug == plug && hookiter->handler->IsEqual(handler);
   306 						if (erase)
   307 							hookiter->handler->DeleteThis();			// Make the _plugin_ delete the handler object
   308 					}
   309 					if (iface_iter->hooks_post.empty() && iface_iter->hooks_pre.empty())
   310 					{
   311 						vfnptr_iter->ifaces.erase(iface_iter);
   312 						if (vfnptr_iter->ifaces.empty())
   313 						{
   314 							// Deactivate the hook
   315 							*reinterpret_cast<void**>(vfnptr_iter->vfnptr) = vfnptr_iter->orig_entry;
   316 							
   317 							hookman->vfnptrs.erase(vfnptr_iter);
   318 
   319 							if (hookman->vfnptrs.empty())
   320 							{
   321 								// Unregister the hook manager
   322 								hookman->func(HA_Unregister, NULL);
   323 							}
   324 						}
   325 					}
   326 				}
   327 				return true;
   328 			}
   329 		}
   330 		return false;
   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 	CSourceHookImpl::HookManInfoList::iterator CSourceHookImpl::FindHookMan(HookManInfoList::iterator begin,
   380 		HookManInfoList::iterator end, const char *proto, int vtblofs, int vtblidx)
   381 	{
   382 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   383 		{
   384 			if (strcmp(hookmaniter->proto, proto) == 0 && hookmaniter->vtbl_offs == vtblofs &&
   385 				hookmaniter->vtbl_idx == vtblidx)
   386 				break;
   387 		}
   388 		return hookmaniter;
   389 	}
   390 
   391 	void CSourceHookImpl::PausePlugin(Plugin plug)
   392 	{
   393 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   394 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   395 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   396 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   397 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   398 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   399 				{
   400 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   401 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   402 						if (plug == hookiter->plug)
   403 							hookiter->paused = true;
   404 
   405 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   406 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   407 						if (plug == hookiter->plug)
   408 							hookiter->paused = true;
   409 				}
   410 	}
   411 
   412 	void CSourceHookImpl::UnpausePlugin(Plugin plug)
   413 	{
   414 		// Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
   415 		for (HookManInfoList::iterator hookmaniter = m_HookMans.begin(); hookmaniter != m_HookMans.end(); ++hookmaniter)
   416 			for (HookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->vfnptrs.begin();
   417 				vfnptr_iter != hookmaniter->vfnptrs.end(); ++vfnptr_iter)
   418 				for (HookManagerInfo::VfnPtr::IfaceListIter ifaceiter = vfnptr_iter->ifaces.begin();
   419 					ifaceiter != vfnptr_iter->ifaces.end(); ++ifaceiter)
   420 				{
   421 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_pre.begin();
   422 						hookiter != ifaceiter->hooks_pre.end(); ++hookiter)
   423 						if (plug == hookiter->plug)
   424 							hookiter->paused = false;
   425 
   426 					for (std::list<HookManagerInfo::VfnPtr::Iface::Hook>::iterator hookiter = ifaceiter->hooks_post.begin();
   427 						hookiter != ifaceiter->hooks_post.end(); ++hookiter)
   428 						if (plug == hookiter->plug)
   429 							hookiter->paused = false;
   430 				}
   431 	}
   432 
   433 	void CSourceHookImpl::SetRes(META_RES res)
   434 	{
   435 		m_CurRes = res;
   436 	}
   437 
   438 	META_RES CSourceHookImpl::GetPrevRes()
   439 	{
   440 		return m_PrevRes;
   441 	}
   442 
   443 	META_RES CSourceHookImpl::GetStatus()
   444 	{
   445 		return m_Status;
   446 	}
   447 
   448 	const void *CSourceHookImpl::GetOrigRet()
   449 	{
   450 		return m_OrigRet;
   451 	}
   452 
   453 	const void *CSourceHookImpl::GetOverrideRet()
   454 	{
   455 		return m_OverrideRet;
   456 	}
   457 
   458 	META_RES &CSourceHookImpl::GetCurResRef()
   459 	{
   460 		return m_CurRes;
   461 	}
   462 
   463 	META_RES &CSourceHookImpl::GetPrevResRef()
   464 	{
   465 		return m_PrevRes;
   466 	}
   467 
   468 	META_RES &CSourceHookImpl::GetStatusRef()
   469 	{
   470 		return m_Status;
   471 	}
   472 
   473 	void CSourceHookImpl::SetOrigRet(const void *ptr)
   474 	{
   475 		m_OrigRet = ptr;
   476 	}
   477 
   478 	void CSourceHookImpl::SetOverrideRet(const void *ptr)
   479 	{
   480 		m_OverrideRet = ptr;
   481 	}
   482 
   483 	void CSourceHookImpl::SetIfacePtr(void *ptr)
   484 	{
   485 		m_IfacePtr = ptr;
   486 	}
   487 	void *CSourceHookImpl::GetIfacePtr()
   488 	{
   489 		return m_IfacePtr;
   490 	}
   491 }