1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/sourcehook/sourcehook.cpp Tue Sep 18 20:03:47 2007 +0000
1.3 @@ -0,0 +1,1212 @@
1.4 +/* ======== SourceHook ========
1.5 +* Copyright (C) 2004-2007 Metamod:Source Development Team
1.6 +* No warranties of any kind
1.7 +*
1.8 +* License: zlib/libpng
1.9 +*
1.10 +* Author(s): Pavol "PM OnoTo" Marko
1.11 +* Contributors: Scott "Damaged Soul" Ehlert
1.12 +* ============================
1.13 +*/
1.14 +
1.15 +/**
1.16 + * @file sourcehook.cpp
1.17 + * @brief Contains the implementation of the SourceHook API
1.18 +*/
1.19 +
1.20 +#if defined __GNUC__
1.21 +#include <stdint.h>
1.22 +#endif
1.23 +
1.24 +#include "sourcehook_impl.h"
1.25 +#include "sh_memory.h"
1.26 +
1.27 +namespace SourceHook
1.28 +{
1.29 + template<>
1.30 + int HashFunction<int>(const int & k)
1.31 + {
1.32 + return k;
1.33 + }
1.34 + template<>
1.35 + int Compare<int>(const int & k1, const int & k2)
1.36 + {
1.37 + if (k1 == k2)
1.38 + return 0;
1.39 + if (k1 > k2)
1.40 + return 1;
1.41 + if (k1 < k2)
1.42 + return -1;
1.43 + return 0;
1.44 + }
1.45 + CSourceHookImpl::CSourceHookImpl()
1.46 + {
1.47 + }
1.48 + CSourceHookImpl::~CSourceHookImpl()
1.49 + {
1.50 + }
1.51 +
1.52 + int CSourceHookImpl::GetIfaceVersion()
1.53 + {
1.54 + return SH_IFACE_VERSION;
1.55 + }
1.56 +
1.57 + int CSourceHookImpl::GetImplVersion()
1.58 + {
1.59 + return SH_IMPL_VERSION;
1.60 + }
1.61 +
1.62 + bool CSourceHookImpl::IsPluginInUse(Plugin plug)
1.63 + {
1.64 + // Iterate through all hook managers which are in this plugin
1.65 + // Iterate through their vfnptrs, ifaces, hooks
1.66 + // If a hook from an other plugin is found, return true
1.67 + // Return false otherwise
1.68 +#define TMP_CHECK_LIST(name) \
1.69 + for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
1.70 + if (hook_iter->plug == plug) \
1.71 + return true;
1.72 +
1.73 + for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
1.74 + hmcl_iter != m_HookMans.end(); ++hmcl_iter)
1.75 + {
1.76 + for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
1.77 + hmil_iter != hmcl_iter->end(); ++hmil_iter)
1.78 + {
1.79 + if (hmil_iter->m_Plug != plug)
1.80 + continue;
1.81 + for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
1.82 + vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.83 + {
1.84 + for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
1.85 + iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
1.86 + {
1.87 + List<HookInfo>::iterator hook_iter;
1.88 + TMP_CHECK_LIST(m_PreHooks);
1.89 + TMP_CHECK_LIST(m_PostHooks);
1.90 + }
1.91 + }
1.92 + }
1.93 + }
1.94 +
1.95 +#undef TMP_CHECK_LIST
1.96 + return false;
1.97 + }
1.98 +
1.99 + void CSourceHookImpl::UnloadPlugin(Plugin plug)
1.100 + {
1.101 + // 1) Manually remove all hooks by this plugin
1.102 + // 2) Manually remove all hook mans by this plugin
1.103 +
1.104 + List<RemoveHookInfo> hookstoremove;
1.105 + List<RemoveHookManInfo> hookmanstoremove;
1.106 + HookManInfoList::iterator hmil_iter;
1.107 +
1.108 +#define TMP_CHECK_LIST(name, ispost) \
1.109 + for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
1.110 + if (hook_iter->plug == plug) \
1.111 + hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
1.112 + hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost)); \
1.113 +
1.114 + for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
1.115 + hmcl_iter != m_HookMans.end(); ++hmcl_iter)
1.116 + {
1.117 + for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
1.118 + hmil_iter != hmcl_iter->end(); ++hmil_iter)
1.119 + {
1.120 + if (hmil_iter->m_Plug == plug)
1.121 + hookmanstoremove.push_back(RemoveHookManInfo(plug, hmil_iter->m_Func));
1.122 +
1.123 + for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
1.124 + vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.125 + {
1.126 + for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
1.127 + iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
1.128 + {
1.129 + List<HookInfo>::iterator hook_iter;
1.130 + TMP_CHECK_LIST(m_PreHooks, false);
1.131 + TMP_CHECK_LIST(m_PostHooks, true);
1.132 + }
1.133 + }
1.134 + }
1.135 + }
1.136 +#undef TMP_CHECK_LIST
1.137 +
1.138 + for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
1.139 + RemoveHook(*rmiter);
1.140 +
1.141 + for (List<RemoveHookManInfo>::iterator rmiter = hookmanstoremove.begin(); rmiter != hookmanstoremove.end(); ++rmiter)
1.142 + RemoveHookManager(*rmiter);
1.143 + }
1.144 +
1.145 + void CSourceHookImpl::RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc)
1.146 + {
1.147 + // Moo!
1.148 +
1.149 + CHookManagerInfo tmp;
1.150 + if (pubFunc(HA_GetInfo, &tmp) != 0)
1.151 + return;
1.152 +
1.153 +
1.154 + HookManContList::iterator hmcl_iter = m_HookMans.find(
1.155 + CHookManagerContainer::HMCI(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx));
1.156 +
1.157 + if (hmcl_iter == m_HookMans.end())
1.158 + {
1.159 + // Moo?
1.160 + return;
1.161 + }
1.162 +
1.163 + CHookManagerContainer::iterator hmil_iter = hmcl_iter->find(
1.164 + CHookManagerInfo::Descriptor(plug, pubFunc));
1.165 +
1.166 + if (hmil_iter == hmcl_iter->end())
1.167 + {
1.168 + // Moo?
1.169 + return;
1.170 + }
1.171 +
1.172 + bool stillInUse = false;
1.173 + List<RemoveHookInfo> hookstoremove;
1.174 +
1.175 + // Iterate through all of the hook manager's hooks. Remove all hooks from the hookman's plugin.
1.176 +#define TMP_CHECK_LIST(name, ispost) \
1.177 + for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
1.178 + if (hook_iter->plug == plug) \
1.179 + hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
1.180 + hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost)); \
1.181 + else \
1.182 + stillInUse = true; \
1.183 +
1.184 + for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
1.185 + vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.186 + {
1.187 + for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
1.188 + iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
1.189 + {
1.190 + List<HookInfo>::iterator hook_iter;
1.191 + TMP_CHECK_LIST(m_PreHooks, false);
1.192 + TMP_CHECK_LIST(m_PostHooks, true);
1.193 + }
1.194 + }
1.195 +#undef TMP_CHECK_LIST
1.196 +
1.197 + for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
1.198 + RemoveHook(*rmiter);
1.199 +
1.200 + CHookManagerInfo info = *hmil_iter;
1.201 +
1.202 + // Unlink the hook manager from the list
1.203 + hmcl_iter->erase(hmil_iter);
1.204 +
1.205 + // If there were any hooks from other plugins, find a new suitable hook manager.
1.206 + if (stillInUse)
1.207 + {
1.208 + // Find a suitable hook manager in an other plugin
1.209 + hmil_iter = hmcl_iter->begin();
1.210 +
1.211 + // This should _never_ happen.
1.212 + // If there is a hook from an other plugin, the plugin must have provided a hook manager as well.
1.213 + SH_ASSERT(hmil_iter != hmcl_iter->end(),
1.214 + ("Could not find a suitable hook manager in an other plugin!"));
1.215 +
1.216 + // AddHook should make sure that every plugin only has _one_ hook manager for _one_ proto/vi/vo
1.217 + SH_ASSERT(hmil_iter->m_Plug != plug, ("New hook manager from same plugin!"));
1.218 +
1.219 + // The first hook manager should be always used - so the new hook manager has to be empty
1.220 + SH_ASSERT(hmil_iter->m_VfnPtrs.empty(), ("New hook manager not empty!"));
1.221 +
1.222 + // Move the vfnptrs from the old hook manager to the new one
1.223 + hmil_iter->m_VfnPtrs = info.m_VfnPtrs;
1.224 +
1.225 + // Unregister the old one, register the new one
1.226 + info.m_Func(HA_Unregister, NULL);
1.227 + hmil_iter->m_Func(HA_Register, &(*hmil_iter));
1.228 +
1.229 + // Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
1.230 + // or whatever
1.231 + for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
1.232 + vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.233 + {
1.234 + // And DEREFERENCE newHookMan->m_HookfuncVfnptr!
1.235 + // otherwise it will be executing the vtable... had to find out the hard way
1.236 + *reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = *reinterpret_cast<void**>(hmil_iter->m_HookfuncVfnptr);
1.237 + }
1.238 + }
1.239 + }
1.240 +
1.241 + void CSourceHookImpl::RemoveHookManager(RemoveHookManInfo info)
1.242 + {
1.243 + RemoveHookManager(info.plug, info.hookman);
1.244 + }
1.245 +
1.246 + void CSourceHookImpl::CompleteShutdown()
1.247 + {
1.248 + // Remove all hooks
1.249 +
1.250 + List<RemoveHookInfo> hookstoremove;
1.251 +
1.252 +#define TMP_CHECK_LIST(name, ispost) \
1.253 + for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
1.254 + hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
1.255 + hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost))
1.256 + for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
1.257 + hmcl_iter != m_HookMans.end(); ++hmcl_iter)
1.258 + {
1.259 + for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
1.260 + hmil_iter != hmcl_iter->end(); ++hmil_iter)
1.261 + {
1.262 + for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
1.263 + vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.264 + {
1.265 + for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
1.266 + iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
1.267 + {
1.268 + List<HookInfo>::iterator hook_iter;
1.269 + TMP_CHECK_LIST(m_PreHooks, false);
1.270 + TMP_CHECK_LIST(m_PostHooks, true);
1.271 + }
1.272 + }
1.273 + }
1.274 + }
1.275 +#undef TMP_CHECK_LIST
1.276 +
1.277 + for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
1.278 + RemoveHook(*rmiter);
1.279 +
1.280 + m_HookMans.clear();
1.281 + }
1.282 +
1.283 + bool CSourceHookImpl::AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
1.284 + {
1.285 + void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
1.286 +
1.287 + // 1) Get info about the hook manager
1.288 + CHookManagerInfo tmp;
1.289 + if (myHookMan(HA_GetInfo, &tmp) != 0)
1.290 + return false;
1.291 +
1.292 + tmp.m_Func = myHookMan;
1.293 + tmp.m_Plug = plug;
1.294 +
1.295 + CHookManagerContainer::HMCI hmci(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx);
1.296 +
1.297 + void **cur_vtptr = *reinterpret_cast<void***>(
1.298 + reinterpret_cast<char*>(adjustediface) + tmp.m_VtblOffs);
1.299 + void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.m_VtblIdx);
1.300 +
1.301 + // Add the container if not already added
1.302 + HookManContList::iterator hmcl_iter = m_HookMans.find(hmci);
1.303 + if (hmcl_iter == m_HookMans.end())
1.304 + {
1.305 + m_HookMans.push_back(CHookManagerContainer(hmci));
1.306 + hmcl_iter = m_HookMans.end();
1.307 + --hmcl_iter;
1.308 + }
1.309 +
1.310 + hmcl_iter->AddHookManager(plug, tmp);
1.311 +
1.312 + CHookManagerContainer::iterator hookman = hmcl_iter->begin();
1.313 + SH_ASSERT(hookman != hmcl_iter->end(), ("No hookman found - but we've just added one!"));
1.314 +
1.315 + // Check whether any other container holds a hook manager which holds this vfnptr
1.316 + // If yes, it means that the two are incompatible, so return false.
1.317 + for (HookManContList::iterator hmcl_iter2 = m_HookMans.begin();
1.318 + hmcl_iter2 != m_HookMans.end(); ++hmcl_iter2)
1.319 + {
1.320 + if (hmcl_iter2 != hmcl_iter)
1.321 + {
1.322 + for (CHookManagerContainer::iterator hmil_iter = hmcl_iter2->begin();
1.323 + hmil_iter != hmcl_iter2->end(); ++hmil_iter)
1.324 + {
1.325 + if (hmil_iter->m_VfnPtrs.find(cur_vfnptr) != hmil_iter->m_VfnPtrs.end())
1.326 + return false;
1.327 + }
1.328 + }
1.329 + }
1.330 +
1.331 + // Tell it to store the pointer if it's not already active
1.332 + if (hookman->m_VfnPtrs.empty())
1.333 + hookman->m_Func(HA_Register, &(*hookman));
1.334 +
1.335 + CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.find(cur_vfnptr);
1.336 +
1.337 + if (vfnptr_iter == hookman->m_VfnPtrs.end())
1.338 + {
1.339 + // Add a new one
1.340 + CVfnPtr vfp(cur_vfnptr);
1.341 +
1.342 + // Alter vtable entry
1.343 + if (!SetMemAccess(cur_vtptr, sizeof(void*) * (tmp.m_VtblIdx + 1), SH_MEM_READ | SH_MEM_WRITE))
1.344 + return false;
1.345 +
1.346 + *reinterpret_cast<void**>(cur_vfnptr) = *reinterpret_cast<void**>(hookman->m_HookfuncVfnptr);
1.347 +
1.348 + hookman->m_VfnPtrs.push_back(vfp);
1.349 +
1.350 + // Make vfnptr_iter point to the new element
1.351 + vfnptr_iter = hookman->m_VfnPtrs.end();
1.352 + --vfnptr_iter;
1.353 +
1.354 + // Now that it is done, check whether we have to update any callclasses
1.355 + ApplyCallClassPatches(adjustediface, tmp.m_VtblOffs, tmp.m_VtblIdx, vfp.m_OrigEntry);
1.356 + }
1.357 +
1.358 + CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.find(adjustediface);
1.359 + if (iface_iter == vfnptr_iter->m_Ifaces.end())
1.360 + {
1.361 + // Add a new one
1.362 + vfnptr_iter->m_Ifaces.push_back(CIface(adjustediface));
1.363 +
1.364 + // Make iface_iter point to the new element
1.365 + iface_iter = vfnptr_iter->m_Ifaces.end();
1.366 + --iface_iter;
1.367 + }
1.368 +
1.369 + // Add the hook
1.370 + HookInfo hookinfo;
1.371 + hookinfo.handler = handler;
1.372 + hookinfo.plug = plug;
1.373 + hookinfo.paused = false;
1.374 + hookinfo.thisptr_offs = thisptr_offs;
1.375 + if (post)
1.376 + iface_iter->m_PostHooks.m_List.push_back(hookinfo);
1.377 + else
1.378 + iface_iter->m_PreHooks.m_List.push_back(hookinfo);
1.379 +
1.380 + return true;
1.381 + }
1.382 +
1.383 + bool CSourceHookImpl::RemoveHook(RemoveHookInfo info)
1.384 + {
1.385 + return RemoveHook(info.plug, info.iface, info.thisptr_offs, info.hookman, info.handler, info.post);
1.386 + }
1.387 +
1.388 + bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
1.389 + {
1.390 + void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
1.391 + CHookManagerInfo tmp;
1.392 + if (myHookMan(HA_GetInfo, &tmp) != 0)
1.393 + return false;
1.394 +
1.395 + // Find the hook manager and the hook
1.396 +
1.397 + HookManContList::iterator hmcl_iter = m_HookMans.find(
1.398 + CHookManagerContainer::HMCI(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx));
1.399 + if (hmcl_iter == m_HookMans.end() || hmcl_iter->empty())
1.400 + return false;
1.401 +
1.402 + CHookManagerContainer::iterator hookman = hmcl_iter->begin();
1.403 +
1.404 + if (!ModuleInMemory(reinterpret_cast<char*>(adjustediface) + tmp.m_VtblOffs,
1.405 + sizeof(void*) * (tmp.m_VtblIdx + 1)))
1.406 + {
1.407 + // The module the vtable was in is already unloaded.
1.408 + hookman->m_VfnPtrs.clear();
1.409 + hookman->m_Func(HA_Unregister, NULL);
1.410 + return true;
1.411 + }
1.412 +
1.413 + void **cur_vtptr = *reinterpret_cast<void***>(
1.414 + reinterpret_cast<char*>(adjustediface) + tmp.m_VtblOffs);
1.415 + void *cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.m_VtblIdx);
1.416 +
1.417 + CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.find(cur_vfnptr);
1.418 +
1.419 + if (vfnptr_iter == hookman->m_VfnPtrs.end())
1.420 + return false;
1.421 +
1.422 + for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
1.423 + iface_iter != vfnptr_iter->m_Ifaces.end();)
1.424 + {
1.425 + if (iface_iter->m_Ptr != adjustediface)
1.426 + {
1.427 + iface_iter++;
1.428 + continue;
1.429 + }
1.430 + List<HookInfo> &hooks =
1.431 + post ? iface_iter->m_PostHooks.m_List : iface_iter->m_PreHooks.m_List;
1.432 +
1.433 + bool erase;
1.434 + for (List<HookInfo>::iterator hookiter = hooks.begin();
1.435 + hookiter != hooks.end(); )
1.436 + {
1.437 + erase = hookiter->plug == plug && hookiter->handler->IsEqual(handler) &&
1.438 + hookiter->thisptr_offs == thisptr_offs;
1.439 + if (erase)
1.440 + {
1.441 + hookiter->handler->DeleteThis(); // Make the _plugin_ delete the handler object
1.442 +
1.443 + // Move all iterators pointing at this
1.444 + List<HookInfo>::iterator oldhookiter = hookiter;
1.445 + hookiter = hooks.erase(hookiter);
1.446 + List<HookInfo>::iterator newhookiter = hookiter;
1.447 + --newhookiter; // The hook loop will ++ it then
1.448 + CHookList::CIter *pItIter;
1.449 + for (pItIter = iface_iter->m_PreHooks.m_UsedIters; pItIter; pItIter = pItIter->m_pNext)
1.450 + if (pItIter->m_Iter == oldhookiter)
1.451 + pItIter->m_Iter = newhookiter;
1.452 + }
1.453 + else
1.454 + ++hookiter;
1.455 + }
1.456 + if (iface_iter->m_PostHooks.m_List.empty() && iface_iter->m_PreHooks.m_List.empty())
1.457 + {
1.458 + // There are no hooks on this iface anymore...
1.459 + for (HookLoopInfoStack::iterator hli_iter = m_HLIStack.begin();
1.460 + hli_iter != m_HLIStack.end(); ++hli_iter)
1.461 + {
1.462 + if (hli_iter->pCurIface == static_cast<IIface*>(&(*iface_iter)))
1.463 + hli_iter->shouldContinue = false;
1.464 + }
1.465 +
1.466 + iface_iter = vfnptr_iter->m_Ifaces.erase(iface_iter);
1.467 + if (vfnptr_iter->m_Ifaces.empty())
1.468 + {
1.469 + // No ifaces at all -> Deactivate the hook
1.470 + *reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = vfnptr_iter->m_OrigEntry;
1.471 +
1.472 + hookman->m_VfnPtrs.erase(vfnptr_iter);
1.473 +
1.474 + // Remove callclass patch
1.475 + for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
1.476 + if (cciter->m_Ptr == adjustediface)
1.477 + cciter->RemoveCallClassPatch(tmp.m_VtblOffs, tmp.m_VtblIdx);
1.478 +
1.479 + if (hookman->m_VfnPtrs.empty())
1.480 + {
1.481 + // Unregister the hook manager
1.482 + hookman->m_Func(HA_Unregister, NULL);
1.483 + }
1.484 +
1.485 + // Don't try to continue looping through ifaces
1.486 + // - the list is already invalid
1.487 + return true;
1.488 + }
1.489 + }
1.490 + else
1.491 + ++iface_iter;
1.492 + }
1.493 + return true;
1.494 + }
1.495 +
1.496 + GenericCallClass *CSourceHookImpl::GetCallClass(void *iface, size_t size)
1.497 + {
1.498 + for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
1.499 + {
1.500 + if (cciter->m_Ptr == iface && cciter->m_ObjSize == size)
1.501 + {
1.502 + ++cciter->m_RefCounter;
1.503 + return &(*cciter);
1.504 + }
1.505 + }
1.506 +
1.507 + // Make a new one
1.508 +
1.509 + CCallClassImpl tmp(iface, size);
1.510 + ApplyCallClassPatches(tmp);
1.511 + m_CallClasses.push_back(tmp);
1.512 + return &m_CallClasses.back();
1.513 + }
1.514 +
1.515 + void CSourceHookImpl::ReleaseCallClass(GenericCallClass *ptr)
1.516 + {
1.517 + Impl_CallClassList::iterator iter = m_CallClasses.find(ptr);
1.518 + if (iter == m_CallClasses.end())
1.519 + return;
1.520 + --iter->m_RefCounter;
1.521 + if (iter->m_RefCounter < 1)
1.522 + m_CallClasses.erase(iter);
1.523 + }
1.524 +
1.525 + void CSourceHookImpl::ApplyCallClassPatches(CCallClassImpl &cc)
1.526 + {
1.527 + for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
1.528 + hmcl_iter != m_HookMans.end(); ++hmcl_iter)
1.529 + {
1.530 + for (CHookManagerContainer::iterator hookman = hmcl_iter->begin();
1.531 + hookman != hmcl_iter->end(); ++hookman)
1.532 + {
1.533 + for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.begin();
1.534 + vfnptr_iter != hookman->m_VfnPtrs.end(); ++vfnptr_iter)
1.535 + {
1.536 + for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
1.537 + iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
1.538 + {
1.539 + if (iface_iter->m_Ptr >= cc.m_Ptr &&
1.540 + iface_iter->m_Ptr < (reinterpret_cast<char*>(cc.m_Ptr) + cc.m_ObjSize))
1.541 + {
1.542 + cc.ApplyCallClassPatch(static_cast<int>(reinterpret_cast<char*>(iface_iter->m_Ptr) -
1.543 + reinterpret_cast<char*>(cc.m_Ptr)) + hookman->m_VtblOffs,
1.544 + hookman->m_VtblIdx, vfnptr_iter->m_OrigEntry);
1.545 + }
1.546 + }
1.547 + }
1.548 + }
1.549 + }
1.550 + }
1.551 +
1.552 + void CSourceHookImpl::ApplyCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx, void *orig_entry)
1.553 + {
1.554 + for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
1.555 + ++cc_iter)
1.556 + {
1.557 + if (ifaceptr >= cc_iter->m_Ptr &&
1.558 + ifaceptr < (reinterpret_cast<char*>(cc_iter->m_Ptr) + cc_iter->m_ObjSize))
1.559 + {
1.560 + cc_iter->ApplyCallClassPatch(static_cast<int>(reinterpret_cast<char*>(ifaceptr) -
1.561 + reinterpret_cast<char*>(cc_iter->m_Ptr)) + vtbl_offs, vtbl_idx, orig_entry);
1.562 + }
1.563 + }
1.564 + }
1.565 +
1.566 + void CSourceHookImpl::RemoveCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx)
1.567 + {
1.568 + for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
1.569 + ++cc_iter)
1.570 + {
1.571 + if (ifaceptr >= cc_iter->m_Ptr &&
1.572 + ifaceptr < (reinterpret_cast<char*>(cc_iter->m_Ptr) + cc_iter->m_ObjSize))
1.573 + {
1.574 + cc_iter->RemoveCallClassPatch(vtbl_offs, vtbl_idx);
1.575 + }
1.576 + }
1.577 + }
1.578 +
1.579 + void CSourceHookImpl::SetPluginPaused(Plugin plug, bool paused)
1.580 + {
1.581 + // Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
1.582 + for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
1.583 + hmcl_iter != m_HookMans.end(); ++hmcl_iter)
1.584 + {
1.585 + for (CHookManagerContainer::iterator hookmaniter = hmcl_iter->begin();
1.586 + hookmaniter != hmcl_iter->end(); ++hookmaniter)
1.587 + {
1.588 + for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->m_VfnPtrs.begin();
1.589 + vfnptr_iter != hookmaniter->m_VfnPtrs.end(); ++vfnptr_iter)
1.590 + {
1.591 + for (CVfnPtr::IfaceListIter ifaceiter = vfnptr_iter->m_Ifaces.begin();
1.592 + ifaceiter != vfnptr_iter->m_Ifaces.end(); ++ifaceiter)
1.593 + {
1.594 + for (List<HookInfo>::iterator hookiter = ifaceiter->m_PreHooks.m_List.begin();
1.595 + hookiter != ifaceiter->m_PreHooks.m_List.end(); ++hookiter)
1.596 + if (plug == hookiter->plug)
1.597 + hookiter->paused = paused;
1.598 +
1.599 + for (List<HookInfo>::iterator hookiter = ifaceiter->m_PostHooks.m_List.begin();
1.600 + hookiter != ifaceiter->m_PostHooks.m_List.end(); ++hookiter)
1.601 + if (plug == hookiter->plug)
1.602 + hookiter->paused = paused;
1.603 + }
1.604 + }
1.605 + }
1.606 + }
1.607 + }
1.608 + void CSourceHookImpl::PausePlugin(Plugin plug)
1.609 + {
1.610 + SetPluginPaused(plug, true);
1.611 + }
1.612 +
1.613 + void CSourceHookImpl::UnpausePlugin(Plugin plug)
1.614 + {
1.615 + SetPluginPaused(plug, false);
1.616 + }
1.617 +
1.618 + void CSourceHookImpl::HookLoopBegin(IIface *pIface)
1.619 + {
1.620 + HookLoopInfo hli;
1.621 + hli.pCurIface = pIface;
1.622 + hli.shouldContinue = true;
1.623 + hli.recall = HookLoopInfo::Recall_No;
1.624 +
1.625 + static_cast<CIface*>(pIface)->m_PreHooks.RQFlagReset();
1.626 + static_cast<CIface*>(pIface)->m_PostHooks.RQFlagReset();
1.627 +
1.628 + m_HLIStack.push(hli);
1.629 + }
1.630 +
1.631 + void CSourceHookImpl::HookLoopEnd()
1.632 + {
1.633 + // When in a post recall... make sure status is high enough so that it returns the orig ret.
1.634 + if (m_HLIStack.size() > 1 && m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
1.635 + *m_HLIStack.front().pStatus = MRES_SUPERCEDE; // THAT'LL TEACH THEM!
1.636 + m_HLIStack.pop();
1.637 + }
1.638 +
1.639 + void CSourceHookImpl::SetRes(META_RES res)
1.640 + {
1.641 + *m_HLIStack.front().pCurRes = res;
1.642 + }
1.643 +
1.644 + META_RES CSourceHookImpl::GetPrevRes()
1.645 + {
1.646 + return *m_HLIStack.front().pPrevRes;
1.647 + }
1.648 +
1.649 + META_RES CSourceHookImpl::GetStatus()
1.650 + {
1.651 + return *m_HLIStack.front().pStatus;
1.652 + }
1.653 +
1.654 + const void *CSourceHookImpl::GetOrigRet()
1.655 + {
1.656 + // When in a post recall... return the orig ret of the previous hookloop.
1.657 + if (m_HLIStack.size() > 1 && m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
1.658 + return m_HLIStack.second().pOrigRet;
1.659 +
1.660 + return m_HLIStack.front().pOrigRet;
1.661 + }
1.662 +
1.663 + const void *CSourceHookImpl::GetOverrideRet()
1.664 + {
1.665 + // pOverrideRet is always set since recalls were introduced
1.666 + // GetOverrideRetPtr was added; a function which always returns pOverrideRet
1.667 + // so that RETURN_META_VALUE_NEWPARAMS can provide an override result
1.668 +
1.669 + // This means that we have to filter GetOverrideRet:
1.670 + // If the status variable is < MRES_OVERRIDE, return NULL.
1.671 +
1.672 + return (*m_HLIStack.front().pStatus < MRES_OVERRIDE) ?
1.673 + NULL : m_HLIStack.front().pOverrideRet;
1.674 + }
1.675 +
1.676 + void *CSourceHookImpl::GetOverrideRetPtr()
1.677 + {
1.678 + // As described in the comment above: always return pOverrideRet
1.679 + return m_HLIStack.front().pOverrideRet;
1.680 + }
1.681 +
1.682 + void *CSourceHookImpl::GetIfacePtr()
1.683 + {
1.684 + return *m_HLIStack.front().pIfacePtrPtr;
1.685 + }
1.686 +
1.687 + void CSourceHookImpl::SetCurResPtr(META_RES *mres)
1.688 + {
1.689 + m_HLIStack.front().pCurRes = mres;
1.690 + }
1.691 +
1.692 + void CSourceHookImpl::SetPrevResPtr(META_RES *mres)
1.693 + {
1.694 + m_HLIStack.front().pPrevRes = mres;
1.695 +
1.696 + // If we're recalling, drag the previous mres value to the new hookfunc
1.697 + if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
1.698 + *mres = *m_HLIStack.second().pPrevRes;
1.699 + }
1.700 +
1.701 + void CSourceHookImpl::SetStatusPtr(META_RES *mres)
1.702 + {
1.703 + m_HLIStack.front().pStatus = mres;
1.704 +
1.705 + // If we're recalling, drag the previous mres value to the new hookfunc
1.706 + if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
1.707 + *mres = *m_HLIStack.second().pStatus;
1.708 + }
1.709 +
1.710 + void CSourceHookImpl::SetIfacePtrPtr(void **pp)
1.711 + {
1.712 + m_HLIStack.front().pIfacePtrPtr = pp;
1.713 + }
1.714 +
1.715 + void CSourceHookImpl::SetOrigRetPtr(const void *ptr)
1.716 + {
1.717 + m_HLIStack.front().pOrigRet = ptr;
1.718 + }
1.719 + void CSourceHookImpl::SetOverrideRetPtr(void *ptr)
1.720 + {
1.721 + m_HLIStack.front().pOverrideRet = ptr;
1.722 + }
1.723 +
1.724 + // New function which does all of the above + more :)
1.725 + void *CSourceHookImpl::SetupHookLoop(META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr,
1.726 + void **ifacePtrPtr, const void *origRetPtr, void *overrideRetPtr)
1.727 + {
1.728 + HookLoopInfo &hli = m_HLIStack.front();
1.729 + hli.pStatus = statusPtr;
1.730 + hli.pPrevRes = prevResPtr;
1.731 + hli.pCurRes = curResPtr;
1.732 + hli.pIfacePtrPtr = ifacePtrPtr;
1.733 + hli.pOrigRet = origRetPtr;
1.734 +
1.735 + // Handle some recall stuff
1.736 + if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
1.737 + {
1.738 + HookLoopInfo &other = m_HLIStack.second();
1.739 + *statusPtr = *other.pStatus;
1.740 + *prevResPtr = *other.pStatus;
1.741 +
1.742 + // When the status is low so there's no override return value and we're in a post recall,
1.743 + // give it the orig return value as override return value.
1.744 + if (*statusPtr < MRES_OVERRIDE && other.recall == HookLoopInfo::Recall_Post1)
1.745 + hli.pOverrideRet = const_cast<void*>(other.pOrigRet);
1.746 + else // Otherwise, transfer override ret normally
1.747 + hli.pOverrideRet = other.pOverrideRet;
1.748 + }
1.749 + else
1.750 + hli.pOverrideRet = overrideRetPtr;
1.751 +
1.752 + // Tell the hook func which override ret ptr to use
1.753 + return hli.pOverrideRet;
1.754 + }
1.755 +
1.756 + bool CSourceHookImpl::ShouldContinue()
1.757 + {
1.758 + // If recall is true, we shall not continue either.
1.759 + // This is because, if it's true and ShouldContinue is called, it suggests that the
1.760 + // actual recall is done and that we are back in the original handler which shall return
1.761 + // immediately.
1.762 +
1.763 + // Post-recalls:
1.764 + // The second element on the stack has recall set to Recall_Post1.
1.765 + // This means that we want to skip this part and the original function calling thing, so
1.766 + // we store the status mres value, set status to MRES_SUPERCEDE, and return false.
1.767 + // We also set the recall flag to Recall_Post2, so the next time the thing calls us, we
1.768 + // can return true (so that the thing goes into post hooks).
1.769 + if (m_HLIStack.size() > 1)
1.770 + {
1.771 + if (m_HLIStack.second().recall == HookLoopInfo::Recall_Post1)
1.772 + {
1.773 + m_HLIStack.front().temporaryStatus = *m_HLIStack.front().pStatus;
1.774 + *m_HLIStack.front().pStatus = MRES_SUPERCEDE;
1.775 + m_HLIStack.second().recall = HookLoopInfo::Recall_Post2;
1.776 + return false;
1.777 + }
1.778 + else if (m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
1.779 + {
1.780 + *m_HLIStack.front().pStatus = m_HLIStack.front().temporaryStatus;
1.781 + return m_HLIStack.front().shouldContinue;
1.782 + }
1.783 + }
1.784 + return m_HLIStack.front().shouldContinue && !m_HLIStack.front().recall;
1.785 + }
1.786 +
1.787 + void CSourceHookImpl::DoRecall()
1.788 + {
1.789 + if (!m_HLIStack.empty())
1.790 + {
1.791 + // Also watch out for post recalls! Described at the beginning of sourcehook_impl.h
1.792 + m_HLIStack.front().recall =
1.793 + static_cast<CIface*>(m_HLIStack.front().pCurIface)->m_PostHooks.RQFlagGet() ?
1.794 + HookLoopInfo::Recall_Post1 : HookLoopInfo::Recall_Pre;
1.795 +
1.796 + CHookList *mlist = static_cast<CHookList*>(m_HLIStack.front().recall == HookLoopInfo::Recall_Pre ?
1.797 + m_HLIStack.front().pCurIface->GetPreHooks() : m_HLIStack.front().pCurIface->GetPostHooks());
1.798 + mlist->m_Recall = true;
1.799 +
1.800 + // The hookfunc usually does this, but it won't have a chance to see it,
1.801 + // so for recalls, we update status here if it's required
1.802 + if (*m_HLIStack.front().pCurRes > *m_HLIStack.front().pStatus)
1.803 + *m_HLIStack.front().pStatus = *m_HLIStack.front().pCurRes;
1.804 +
1.805 + }
1.806 + }
1.807 +
1.808 + ////////////////////////////
1.809 + // CCallClassImpl
1.810 + ////////////////////////////
1.811 + CSourceHookImpl::CCallClassImpl::CCallClassImpl(void *ptr, size_t size)
1.812 + : m_Ptr(ptr), m_ObjSize(size), m_RefCounter(1)
1.813 + {
1.814 + }
1.815 + CSourceHookImpl::CCallClassImpl::~CCallClassImpl()
1.816 + {
1.817 + }
1.818 +
1.819 + void *CSourceHookImpl::CCallClassImpl::GetThisPtr()
1.820 + {
1.821 + return m_Ptr;
1.822 + }
1.823 + void *CSourceHookImpl::CCallClassImpl::GetOrigFunc(int vtbloffs, int vtblidx)
1.824 + {
1.825 + OrigVTables::iterator iter = m_VT.find(vtbloffs);
1.826 + if (iter != m_VT.end() && iter->val.size() > (size_t)vtblidx)
1.827 + {
1.828 + return iter->val[vtblidx];
1.829 + }
1.830 + return NULL;
1.831 + }
1.832 +
1.833 + void CSourceHookImpl::CCallClassImpl::ApplyCallClassPatch(int vtbl_offs, int vtbl_idx, void *orig_entry)
1.834 + {
1.835 + OrigFuncs &tmpvec = m_VT[vtbl_offs];
1.836 + if (tmpvec.size() <= (size_t)vtbl_idx)
1.837 + tmpvec.resize(vtbl_idx+1, NULL);
1.838 + tmpvec[vtbl_idx] = orig_entry;
1.839 + }
1.840 + void CSourceHookImpl::CCallClassImpl::RemoveCallClassPatch(int vtbl_offs, int vtbl_idx)
1.841 + {
1.842 + OrigVTables::iterator iter = m_VT.find(vtbl_offs);
1.843 + if (iter != m_VT.end())
1.844 + {
1.845 + if (iter->val.size() > (size_t)vtbl_idx)
1.846 + {
1.847 + iter->val[vtbl_idx] = 0;
1.848 +
1.849 + OrigFuncs &of = iter->val;
1.850 + OrigFuncs::iterator lastused = of.end();
1.851 + for (OrigFuncs::iterator viter = of.begin(); viter != of.end(); ++viter)
1.852 + {
1.853 + if (*viter)
1.854 + lastused = viter;
1.855 + }
1.856 + if (lastused == of.end())
1.857 + {
1.858 + // No used element => Remove the whole vector
1.859 + m_VT.erase(iter);
1.860 + return;
1.861 + }
1.862 + of.resize(lastused - of.begin() + 1);
1.863 + }
1.864 + }
1.865 + }
1.866 +
1.867 + ////////////////////////////
1.868 + // CHookManagerInfo
1.869 + ////////////////////////////
1.870 + CSourceHookImpl::CHookManagerInfo::CHookManagerInfo() : m_HookManVersion(0)
1.871 + {
1.872 + }
1.873 + CSourceHookImpl::CHookManagerInfo::~CHookManagerInfo()
1.874 + {
1.875 + }
1.876 +
1.877 + IVfnPtr *CSourceHookImpl::CHookManagerInfo::FindVfnPtr(void *vfnptr)
1.878 + {
1.879 + VfnPtrListIter iter = m_VfnPtrs.find(vfnptr);
1.880 + return iter == m_VfnPtrs.end() ? NULL : &(*iter);
1.881 + }
1.882 + void CSourceHookImpl::CHookManagerInfo::SetInfo(int vtbl_offs, int vtbl_idx, const char *proto)
1.883 + {
1.884 + m_VtblOffs = vtbl_offs;
1.885 + m_VtblIdx = vtbl_idx;
1.886 + m_Proto = proto;
1.887 + }
1.888 + void CSourceHookImpl::CHookManagerInfo::SetHookfuncVfnptr(void *hookfunc_vfnptr)
1.889 + {
1.890 + m_HookfuncVfnptr = hookfunc_vfnptr;
1.891 + }
1.892 + void CSourceHookImpl::CHookManagerInfo::SetVersion(int version)
1.893 + {
1.894 + m_HookManVersion = version;
1.895 + }
1.896 + ////////////////////////////
1.897 + // CVfnPtr
1.898 + ////////////////////////////
1.899 +
1.900 +
1.901 + // If you get a crash here, the ptr passed is invalid
1.902 + // This usually means a SH_DECL_MANUALHOOK* with wrong thisptroffs/vtbloffs/vtblidx
1.903 + CSourceHookImpl::CVfnPtr::CVfnPtr(void *ptr) : m_Ptr(ptr), m_OrigEntry(*reinterpret_cast<void**>(ptr))
1.904 + {
1.905 + }
1.906 + CSourceHookImpl::CVfnPtr::~CVfnPtr()
1.907 + {
1.908 + }
1.909 +
1.910 + void *CSourceHookImpl::CVfnPtr::GetVfnPtr()
1.911 + {
1.912 + return m_Ptr;
1.913 + }
1.914 +
1.915 + void *CSourceHookImpl::CVfnPtr::GetOrigEntry()
1.916 + {
1.917 + return m_OrigEntry;
1.918 + }
1.919 +
1.920 + IIface *CSourceHookImpl::CVfnPtr::FindIface(void *ptr)
1.921 + {
1.922 + IfaceListIter iter = m_Ifaces.find(ptr);
1.923 + return iter == m_Ifaces.end() ? NULL : &(*iter);
1.924 + }
1.925 +
1.926 + ////////////////////////////
1.927 + // CIface
1.928 + ////////////////////////////
1.929 + CSourceHookImpl::CIface::CIface(void *ptr) : m_Ptr(ptr)
1.930 + {
1.931 + }
1.932 + CSourceHookImpl::CIface::~CIface()
1.933 + {
1.934 + }
1.935 +
1.936 + void *CSourceHookImpl::CIface::GetPtr()
1.937 + {
1.938 + return m_Ptr;
1.939 + }
1.940 +
1.941 + IHookList *CSourceHookImpl::CIface::GetPreHooks()
1.942 + {
1.943 + return &m_PreHooks;
1.944 + }
1.945 + IHookList *CSourceHookImpl::CIface::GetPostHooks()
1.946 + {
1.947 + return &m_PostHooks;
1.948 + }
1.949 +
1.950 + ////////////////////////////
1.951 + // CHookList
1.952 + ////////////////////////////
1.953 +
1.954 + CSourceHookImpl::CHookList::CHookList() : m_FreeIters(NULL), m_UsedIters(NULL),
1.955 + m_Recall(false)
1.956 + {
1.957 + }
1.958 + CSourceHookImpl::CHookList::CHookList(const CHookList &other) : m_List(other.m_List),
1.959 + m_FreeIters(NULL), m_UsedIters(NULL), m_Recall(false)
1.960 + {
1.961 + }
1.962 +
1.963 + CSourceHookImpl::CHookList::~CHookList()
1.964 + {
1.965 + while (m_FreeIters)
1.966 + {
1.967 + CIter *iter = m_FreeIters->m_pNext;
1.968 + delete m_FreeIters;
1.969 + m_FreeIters = iter;
1.970 + }
1.971 + while (m_UsedIters)
1.972 + {
1.973 + CIter *iter = m_UsedIters->m_pNext;
1.974 + delete m_UsedIters;
1.975 + m_UsedIters = iter;
1.976 + }
1.977 + }
1.978 + IHookList::IIter *CSourceHookImpl::CHookList::GetIter()
1.979 + {
1.980 + m_RQFlag = true;
1.981 +
1.982 + CIter *ret;
1.983 + if (m_FreeIters)
1.984 + {
1.985 + ret = m_FreeIters;
1.986 + m_FreeIters = ret->m_pNext;
1.987 + ret->GoToBegin();
1.988 + }
1.989 + else
1.990 + {
1.991 + ret = new CIter(this);
1.992 + }
1.993 +
1.994 + // Muuuh, if we're recalling, it shall be a copy of the last iterator, incremented by one
1.995 + if (m_Recall && m_UsedIters)
1.996 + {
1.997 + ret->Set(m_UsedIters); // m_UsedIters is the last returned and not released iterator
1.998 + ret->Next(); // Use next instead of directly incrementing its m_Iter:
1.999 + // skips paused plugins
1.1000 + }
1.1001 +
1.1002 + ret->m_pNext = m_UsedIters;
1.1003 + ret->m_pPrev = NULL;
1.1004 + if (m_UsedIters)
1.1005 + m_UsedIters->m_pPrev = ret;
1.1006 + m_UsedIters = ret;
1.1007 +
1.1008 + m_Recall = false;
1.1009 +
1.1010 + return ret;
1.1011 + }
1.1012 + void CSourceHookImpl::CHookList::ReleaseIter(IIter *pIter)
1.1013 + {
1.1014 + CIter *pIter2 = static_cast<CIter*>(pIter);
1.1015 +
1.1016 + // Unlink from m_UsedIters
1.1017 +
1.1018 + if (pIter2->m_pNext)
1.1019 + pIter2->m_pNext->m_pPrev = pIter2->m_pPrev;
1.1020 + if (pIter2->m_pPrev)
1.1021 + pIter2->m_pPrev->m_pNext = pIter2->m_pNext;
1.1022 + if (pIter2 == m_UsedIters)
1.1023 + m_UsedIters = NULL;
1.1024 +
1.1025 + // Link to m_FreeIters
1.1026 +
1.1027 + pIter2->m_pNext = m_FreeIters;
1.1028 +
1.1029 + m_FreeIters = pIter2;
1.1030 +
1.1031 + // Reset recall state.
1.1032 + m_Recall = false;
1.1033 + }
1.1034 +
1.1035 + CSourceHookImpl::CHookList::CIter::CIter(CHookList *pList) : m_pList(pList), m_pNext(NULL)
1.1036 + {
1.1037 + GoToBegin();
1.1038 + }
1.1039 + CSourceHookImpl::CHookList::CIter::~CIter()
1.1040 + {
1.1041 + }
1.1042 +
1.1043 + void CSourceHookImpl::CHookList::CIter::Set(CIter *pOther)
1.1044 + {
1.1045 + m_Iter = pOther->m_Iter;
1.1046 + }
1.1047 +
1.1048 + void CSourceHookImpl::CHookList::CIter::GoToBegin()
1.1049 + {
1.1050 + m_Iter = m_pList->m_List.begin();
1.1051 + SkipPaused();
1.1052 + }
1.1053 +
1.1054 + bool CSourceHookImpl::CHookList::CIter::End()
1.1055 + {
1.1056 + if (!m_pList)
1.1057 + return false;
1.1058 + return m_Iter == m_pList->m_List.end();
1.1059 + }
1.1060 + void CSourceHookImpl::CHookList::CIter::Next()
1.1061 + {
1.1062 + if (!m_pList)
1.1063 + return;
1.1064 + ++m_Iter;
1.1065 + SkipPaused();
1.1066 + }
1.1067 + void CSourceHookImpl::CHookList::CIter::Clear()
1.1068 + {
1.1069 + m_pList = NULL;
1.1070 + }
1.1071 + void CSourceHookImpl::CHookList::CIter::SkipPaused()
1.1072 + {
1.1073 + while (m_Iter != m_pList->m_List.end() && m_Iter->paused)
1.1074 + ++m_Iter;
1.1075 + }
1.1076 +
1.1077 + ISHDelegate *CSourceHookImpl::CHookList::CIter::Handler()
1.1078 + {
1.1079 + return m_Iter->handler;
1.1080 + }
1.1081 + int CSourceHookImpl::CHookList::CIter::ThisPtrOffs()
1.1082 + {
1.1083 + return m_Iter->thisptr_offs;
1.1084 + }
1.1085 +
1.1086 + //////////////////////////////////////////////////////////////////////////
1.1087 + // CProto
1.1088 + //////////////////////////////////////////////////////////////////////////
1.1089 + char *CSourceHookImpl::CProto::DupProto(const char *p)
1.1090 + {
1.1091 + char *newproto;
1.1092 + if (*p)
1.1093 + {
1.1094 + size_t len = strlen(p);
1.1095 + newproto = new char[len+1];
1.1096 + memcpy(newproto, p, len+1);
1.1097 + } else {
1.1098 + const ProtoInfo *pi1 = reinterpret_cast<const ProtoInfo *>(p);
1.1099 + int *ar_copy = new int[pi1->numOfParams + 1];
1.1100 + for (int i = 0; i <= pi1->numOfParams; i++)
1.1101 + ar_copy[i] = pi1->params[i];
1.1102 + ProtoInfo *copy = new ProtoInfo(pi1->retTypeSize, pi1->numOfParams, ar_copy);
1.1103 + newproto = reinterpret_cast<char *>(copy);
1.1104 + }
1.1105 +
1.1106 + return newproto;
1.1107 + }
1.1108 +
1.1109 + void CSourceHookImpl::CProto::FreeProto(char *prot)
1.1110 + {
1.1111 + if (*prot)
1.1112 + {
1.1113 + delete [] prot;
1.1114 + } else {
1.1115 + ProtoInfo *pi = reinterpret_cast<ProtoInfo *>(prot);
1.1116 + delete [] pi->params;
1.1117 + delete pi;
1.1118 + }
1.1119 + }
1.1120 +
1.1121 + bool CSourceHookImpl::CProto::Equal(const char *p1, const char *p2)
1.1122 + {
1.1123 + if (*p1 && *p2) // Case1: Both old
1.1124 + {
1.1125 + // As in old versions
1.1126 + return strcmp(p1, p2) == 0;
1.1127 + }
1.1128 + else if (!*p1 && !*p2) // Case2: Both new
1.1129 + {
1.1130 + const ProtoInfo *pi1 = reinterpret_cast<const ProtoInfo*>(p1);
1.1131 + const ProtoInfo *pi2 = reinterpret_cast<const ProtoInfo*>(p2);
1.1132 +
1.1133 + if (pi1->retTypeSize == pi2->retTypeSize &&
1.1134 + pi1->numOfParams == pi2->numOfParams)
1.1135 + {
1.1136 + // params[0] is 0 for "normal" functions and -1 for vararg functions
1.1137 + // params[1] is size of first parameter
1.1138 + // params[2] is size of second parameter ...
1.1139 + for (int i = 0; i <= pi1->numOfParams; ++i)
1.1140 + {
1.1141 + if (pi1->params[i] != pi2->params[i])
1.1142 + return false;
1.1143 + }
1.1144 + return true;
1.1145 + }
1.1146 + else
1.1147 + {
1.1148 + return false;
1.1149 + }
1.1150 + }
1.1151 + else // Case3: Mixed old/new
1.1152 + {
1.1153 + // Trust the user
1.1154 + return true;
1.1155 + }
1.1156 + }
1.1157 +
1.1158 +
1.1159 + //////////////////////////////////////////////////////////////////////////
1.1160 + // CHookManagerContainer
1.1161 + //////////////////////////////////////////////////////////////////////////
1.1162 + void CSourceHookImpl::CHookManagerContainer::AddHookManager(Plugin plug, const CHookManagerInfo &hookman)
1.1163 + {
1.1164 + iterator iter;
1.1165 + // Check whether such a hook manager already exists; if yes, ignore.
1.1166 + for (iter = begin(); iter != end(); ++iter)
1.1167 + {
1.1168 + if (iter->m_Plug == plug && iter->m_Func == hookman.m_Func)
1.1169 + return;
1.1170 + }
1.1171 +
1.1172 + // It doesn't -> add it. Add it to the end of its version group.
1.1173 + for (iter = begin(); iter != end(); ++iter)
1.1174 + {
1.1175 + if (iter->m_HookManVersion < hookman.m_HookManVersion)
1.1176 + break;
1.1177 + }
1.1178 +
1.1179 + bool isBeginning = iter == begin();
1.1180 +
1.1181 + insert(iter, hookman);
1.1182 +
1.1183 + // If we inserted it at the beginning and if the dam breaks open many years too soon
1.1184 + // and if there is more than one hookman and if the second one isn't empty, transfer
1.1185 + // hooks from second to first
1.1186 +
1.1187 + if (isBeginning && size() > 1)
1.1188 + {
1.1189 + iter = begin();
1.1190 + iterator second = iter;
1.1191 + ++second;
1.1192 +
1.1193 + if (!second->m_VfnPtrs.empty())
1.1194 + {
1.1195 + // Move the vfnptrs from the old hook manager to the new one
1.1196 + iter->m_VfnPtrs = second->m_VfnPtrs;
1.1197 + second->m_VfnPtrs.clear();
1.1198 +
1.1199 + // Unregister the old one, register the new one
1.1200 + second->m_Func(HA_Unregister, NULL);
1.1201 + iter->m_Func(HA_Register, &(*iter));
1.1202 +
1.1203 + // Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
1.1204 + // or whatever
1.1205 + for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = iter->m_VfnPtrs.begin();
1.1206 + vfnptr_iter != iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.1207 + {
1.1208 + // And DEREFERENCE newHookMan->m_HookfuncVfnptr!
1.1209 + // otherwise it will be executing the vtable... had to find out the hard way
1.1210 + *reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = *reinterpret_cast<void**>(iter->m_HookfuncVfnptr);
1.1211 + }
1.1212 + }
1.1213 + }
1.1214 + }
1.1215 +}