1.1 --- a/sourcehook/sourcehook.cpp Sun Oct 07 03:12:19 2007 +0000
1.2 +++ b/sourcehook/sourcehook.cpp Sun Oct 07 22:10:07 2007 +0000
1.3 @@ -39,1425 +39,1062 @@
1.4 return -1;
1.5 return 0;
1.6 }
1.7 - CSourceHookImpl::CSourceHookImpl() : m_OneIgnore(NULL), m_IgnoreActive(false)
1.8 - {
1.9 - }
1.10 - CSourceHookImpl::~CSourceHookImpl()
1.11 - {
1.12 - }
1.13
1.14 - int CSourceHookImpl::GetIfaceVersion()
1.15 - {
1.16 - return SH_IFACE_VERSION;
1.17 - }
1.18 -
1.19 - int CSourceHookImpl::GetImplVersion()
1.20 - {
1.21 - return SH_IMPL_VERSION;
1.22 - }
1.23 -
1.24 - bool CSourceHookImpl::IsPluginInUse(Plugin plug)
1.25 + namespace Impl
1.26 {
1.27 - // Iterate through all hook managers which are in this plugin
1.28 - // Iterate through their vfnptrs, ifaces, hooks
1.29 - // If a hook from an other plugin is found, return true
1.30 - // Return false otherwise
1.31 -#define TMP_CHECK_LIST(name) \
1.32 - for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
1.33 - if (hook_iter->plug == plug) \
1.34 + //////////////////////////////////////////////////////////////////////////
1.35 + // CProto
1.36 + //////////////////////////////////////////////////////////////////////////
1.37 + ProtoInfo *CProto::DupProto(const ProtoInfo *src)
1.38 + {
1.39 + if (src == NULL)
1.40 + return NULL;
1.41 +
1.42 + PassInfo *newParamsPassInfo = new PassInfo[src->numOfParams + 1];
1.43 + for (int i = 0; i <= src->numOfParams; ++i)
1.44 + newParamsPassInfo[i] = src->paramsPassInfo[i];
1.45 +
1.46 + ProtoInfo *newProto = new ProtoInfo;
1.47 + newProto->retPassInfo = src->retPassInfo;
1.48 + newProto->paramsPassInfo = newParamsPassInfo;
1.49 + newProto->numOfParams = src->numOfParams;
1.50 + newProto->convention = src->convention;
1.51 +
1.52 + return newProto;
1.53 + }
1.54 +
1.55 + void CProto::FreeProto(ProtoInfo *prot)
1.56 + {
1.57 + if (!prot)
1.58 + return;
1.59 +
1.60 + delete [] prot->paramsPassInfo;
1.61 + delete prot;
1.62 + }
1.63 +
1.64 + bool CProto::Equal(const ProtoInfo *p1, const ProtoInfo *p2)
1.65 + {
1.66 + if (!p1 || !p2)
1.67 + return false;
1.68 +
1.69 + if (p1->numOfParams != p2->numOfParams)
1.70 + return false;
1.71 +
1.72 + if (p1->convention != ProtoInfo::CallConv_Unknown && p2->convention != ProtoInfo::CallConv_Unknown &&
1.73 + p1->convention != p2->convention)
1.74 + return false;
1.75 +
1.76 + if (p1->retPassInfo.size != p2->retPassInfo.size)
1.77 + return false;
1.78 +
1.79 + // Skip params[0] : dummy
1.80 + for (int i = 1; i <= p1->numOfParams; ++i)
1.81 + {
1.82 + if (p1->paramsPassInfo[i].size != p2->paramsPassInfo[i].size)
1.83 + return false;
1.84 + if (p1->paramsPassInfo[i].type != PassInfo::PassType_Unknown && p2->paramsPassInfo[i].type != PassInfo::PassType_Unknown)
1.85 + {
1.86 + if (p1->paramsPassInfo[i].type != p2->paramsPassInfo[i].type)
1.87 + return false;
1.88 + if (p1->paramsPassInfo[i].flags != p2->paramsPassInfo[i].flags)
1.89 + return false;
1.90 + }
1.91 + }
1.92 +
1.93 return true;
1.94 + }
1.95
1.96 - for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
1.97 - hmcl_iter != m_HookMans.end(); ++hmcl_iter)
1.98 +
1.99 + //////////////////////////////////////////////////////////////////////////
1.100 + // CHookManContainerList
1.101 + //////////////////////////////////////////////////////////////////////////
1.102 + CHookManagerContainer &CHookManContainerList::GetContainer(int vtbloffs, int vtblidx, const CProto &proto)
1.103 + {
1.104 + iterator iter = find(CHookManagerContainer::Descriptor(vtbloffs, vtblidx, proto));
1.105 + if (iter == end())
1.106 + {
1.107 + CHookManagerContainer newCont(vtbloffs, vtblidx, proto);
1.108 + push_back(newCont);
1.109 + return back();
1.110 + }
1.111 + else
1.112 + {
1.113 + return *iter;
1.114 + }
1.115 + }
1.116 +
1.117 + void CHookManContainerList::RemoveHookMans(Plugin plug)
1.118 + {
1.119 + for (iterator iter = begin(); iter != end(); ++iter)
1.120 + iter->RemoveHookMans(plug);
1.121 + }
1.122 +
1.123 + void CHookManContainerList::RemoveHookMans(Plugin plug, HookManagerPubFunc pubFunc)
1.124 + {
1.125 + for (iterator iter = begin(); iter != end(); ++iter)
1.126 + iter->RemoveHookMans(plug, pubFunc);
1.127 + }
1.128 +
1.129 + //////////////////////////////////////////////////////////////////////////
1.130 + // CHookManagerContainer
1.131 + //////////////////////////////////////////////////////////////////////////
1.132 +
1.133 + bool CHookManagerContainer::AddHookManager(const CHookManager &hookMan)
1.134 {
1.135 - for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
1.136 - hmil_iter != hmcl_iter->end(); ++hmil_iter)
1.137 + iterator iter;
1.138 +
1.139 + // Don't accept invalid hook managers
1.140 + if (!hookMan)
1.141 + return false;
1.142 +
1.143 + // Check whether such a hook manager already exists; if yes, ignore.
1.144 + iter = find(hookMan);
1.145 + if (iter != end())
1.146 {
1.147 - if (hmil_iter->m_Plug != plug)
1.148 - continue;
1.149 - for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
1.150 - vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.151 + // but make sure that it's activated (ms_HI stored)
1.152 + iter->Register();
1.153 + return true;
1.154 + }
1.155 +
1.156 + // It doesn't -> add it. Add it to the end of its version group.
1.157 + for (iter = begin(); iter != end(); ++iter)
1.158 + {
1.159 + if (iter->GetVersion() < hookMan.GetVersion())
1.160 + break;
1.161 + }
1.162 +
1.163 + bool isBeginning = iter == begin();
1.164 +
1.165 + insert(iter, hookMan);
1.166 +
1.167 + if (isBeginning)
1.168 + {
1.169 + iter = begin();
1.170 +
1.171 + if (size() > 1)
1.172 {
1.173 - for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
1.174 - iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
1.175 + // If the next hookman isn't empty (there were hooks before, but this hookman is better)
1.176 + // transfer its vfnptrs and deactivate it
1.177 +
1.178 + iterator second = iter;
1.179 + ++second;
1.180 +
1.181 + if (!second->GetVfnPtrList().empty())
1.182 {
1.183 - List<HookInfo>::iterator hook_iter;
1.184 - TMP_CHECK_LIST(m_PreHooks);
1.185 - TMP_CHECK_LIST(m_PostHooks);
1.186 + // Move the vfnptrs from the old hook manager to the new one
1.187 + iter->GetVfnPtrList() = second->GetVfnPtrList();
1.188 + second->GetVfnPtrList().clear();
1.189 +
1.190 + // Unregister the old one, register the new one
1.191 + second->Unregister();
1.192 +
1.193 + // Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
1.194 + // :TODO: change this to something like for_all :X
1.195 + for (List<CVfnPtr>::iterator vfnptr_iter = iter->GetVfnPtrList().begin();
1.196 + vfnptr_iter != iter->GetVfnPtrList().end(); ++vfnptr_iter)
1.197 + {
1.198 + vfnptr_iter->Patch(iter->GetHookFunc());
1.199 + }
1.200 }
1.201 }
1.202 +
1.203 + // activate the new active hookman
1.204 + iter->Register();
1.205 + }
1.206 +
1.207 + return true;
1.208 + }
1.209 +
1.210 + void CHookManagerContainer::RemoveHookMans(Plugin plug, HookManagerPubFunc pubFunc)
1.211 + {
1.212 + bool erasethis = false;
1.213 +
1.214 + for (iterator iter = begin(); iter != end(); erasethis ? (iter = erase(iter)) : ++iter)
1.215 + {
1.216 + erasethis = false;
1.217 + if (iter->GetOwnerPlugin() == plug
1.218 + && (pubFunc == NULL ? true : (iter->GetPubFunc() == pubFunc)))
1.219 + {
1.220 + if (iter == begin() && !iter->GetVfnPtrList().empty())
1.221 + {
1.222 + // The hook manager is active
1.223 + // -> Transfer its hooks to the next hook manager (which _has_ to exist)
1.224 + SH_ASSERT(size() > 1, ("No more hook managers!?"));
1.225 +
1.226 + iterator second = iter;
1.227 + ++second;
1.228 +
1.229 + SH_ASSERT(second->GetOwnerPlugin() != plug, ("New hook manager from same plugin!"));
1.230 +
1.231 + second->GetVfnPtrList() = iter->GetVfnPtrList();
1.232 + iter->GetVfnPtrList().clear();
1.233 +
1.234 + second->Register();
1.235 + iter->Unregister();
1.236 +
1.237 + // Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
1.238 + // :TODO: change this to something like for_all :X
1.239 + for (List<CVfnPtr>::iterator vfnptr_iter = second->GetVfnPtrList().begin();
1.240 + vfnptr_iter != second->GetVfnPtrList().end(); ++vfnptr_iter)
1.241 + {
1.242 + vfnptr_iter->Patch(second->GetHookFunc());
1.243 + }
1.244 + }
1.245 + erasethis = true;
1.246 + }
1.247 }
1.248 }
1.249
1.250 -#undef TMP_CHECK_LIST
1.251 - return false;
1.252 - }
1.253 -
1.254 - void CSourceHookImpl::UnloadPlugin(Plugin plug)
1.255 - {
1.256 - // 1) Manually remove all hooks by this plugin
1.257 - // 2) Manually remove all hook mans by this plugin
1.258 -
1.259 - List<RemoveHookInfo> hookstoremove;
1.260 - List<RemoveHookManInfo> hookmanstoremove;
1.261 - HookManInfoList::iterator hmil_iter;
1.262 -
1.263 -#define TMP_CHECK_LIST(name, ispost) \
1.264 - for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
1.265 - if (hook_iter->plug == plug) \
1.266 - hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
1.267 - hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost)); \
1.268 -
1.269 - for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
1.270 - hmcl_iter != m_HookMans.end(); ++hmcl_iter)
1.271 + //////////////////////////////////////////////////////////////////////////
1.272 + // CHookManager
1.273 + //////////////////////////////////////////////////////////////////////////
1.274 + void CHookManager::SetInfo(int hookman_version, int vtbloffs, int vtblidx,
1.275 + ProtoInfo *proto, void *hookfunc_vfnptr)
1.276 {
1.277 - for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
1.278 - hmil_iter != hmcl_iter->end(); ++hmil_iter)
1.279 - {
1.280 - if (hmil_iter->m_Plug == plug)
1.281 - hookmanstoremove.push_back(RemoveHookManInfo(plug, hmil_iter->m_Func));
1.282 -
1.283 - for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
1.284 - vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.285 - {
1.286 - for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
1.287 - iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
1.288 - {
1.289 - List<HookInfo>::iterator hook_iter;
1.290 - TMP_CHECK_LIST(m_PreHooks, false);
1.291 - TMP_CHECK_LIST(m_PostHooks, true);
1.292 - }
1.293 - }
1.294 - }
1.295 - }
1.296 -#undef TMP_CHECK_LIST
1.297 -
1.298 - for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
1.299 - RemoveHook(*rmiter);
1.300 -
1.301 - for (List<RemoveHookManInfo>::iterator rmiter = hookmanstoremove.begin(); rmiter != hookmanstoremove.end(); ++rmiter)
1.302 - RemoveHookManager(*rmiter);
1.303 - }
1.304 -
1.305 - void CSourceHookImpl::RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc)
1.306 - {
1.307 - // Moo!
1.308 -
1.309 - CHookManagerInfo tmp;
1.310 - if (pubFunc(HA_GetInfo, &tmp) != 0)
1.311 - return;
1.312 -
1.313 -
1.314 - HookManContList::iterator hmcl_iter = m_HookMans.find(
1.315 - CHookManagerContainer::HMCI(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx));
1.316 -
1.317 - if (hmcl_iter == m_HookMans.end())
1.318 - {
1.319 - // Moo?
1.320 - return;
1.321 - }
1.322 -
1.323 - CHookManagerContainer::iterator hmil_iter = hmcl_iter->find(
1.324 - CHookManagerInfo::Descriptor(plug, pubFunc));
1.325 -
1.326 - if (hmil_iter == hmcl_iter->end())
1.327 - {
1.328 - // Moo?
1.329 - return;
1.330 + m_Version = hookman_version;
1.331 + m_VtblOffs = vtbloffs;
1.332 + m_VtblIdx = vtblidx;
1.333 + m_Proto = proto;
1.334 + m_HookfuncVfnptr = hookfunc_vfnptr;
1.335 }
1.336
1.337 - bool stillInUse = false;
1.338 - List<RemoveHookInfo> hookstoremove;
1.339 -
1.340 - // Iterate through all of the hook manager's hooks. Remove all hooks from the hookman's plugin.
1.341 -#define TMP_CHECK_LIST(name, ispost) \
1.342 - for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
1.343 - if (hook_iter->plug == plug) \
1.344 - hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
1.345 - hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost)); \
1.346 - else \
1.347 - stillInUse = true; \
1.348 -
1.349 - for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
1.350 - vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.351 - {
1.352 - for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
1.353 - iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
1.354 - {
1.355 - List<HookInfo>::iterator hook_iter;
1.356 - TMP_CHECK_LIST(m_PreHooks, false);
1.357 - TMP_CHECK_LIST(m_PostHooks, true);
1.358 - }
1.359 - }
1.360 -#undef TMP_CHECK_LIST
1.361 -
1.362 - for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
1.363 - RemoveHook(*rmiter);
1.364 -
1.365 - CHookManagerInfo info = *hmil_iter;
1.366 -
1.367 - // Unlink the hook manager from the list
1.368 - hmcl_iter->erase(hmil_iter);
1.369 -
1.370 - // If there were any hooks from other plugins, find a new suitable hook manager.
1.371 - if (stillInUse)
1.372 + CVfnPtr &CHookManager::GetVfnPtr(void *vfnptr)
1.373 {
1.374 - // Find a suitable hook manager in an other plugin
1.375 - hmil_iter = hmcl_iter->begin();
1.376 -
1.377 - // This should _never_ happen.
1.378 - // If there is a hook from an other plugin, the plugin must have provided a hook manager as well.
1.379 - SH_ASSERT(hmil_iter != hmcl_iter->end(),
1.380 - ("Could not find a suitable hook manager in an other plugin!"));
1.381 -
1.382 - // AddHook should make sure that every plugin only has _one_ hook manager for _one_ proto/vi/vo
1.383 - SH_ASSERT(hmil_iter->m_Plug != plug, ("New hook manager from same plugin!"));
1.384 -
1.385 - // The first hook manager should be always used - so the new hook manager has to be empty
1.386 - SH_ASSERT(hmil_iter->m_VfnPtrs.empty(), ("New hook manager not empty!"));
1.387 -
1.388 - // Move the vfnptrs from the old hook manager to the new one
1.389 - hmil_iter->m_VfnPtrs = info.m_VfnPtrs;
1.390 -
1.391 - // Unregister the old one, register the new one
1.392 - info.m_Func(HA_Unregister, NULL);
1.393 - hmil_iter->m_Func(HA_Register, &(*hmil_iter));
1.394 -
1.395 - // Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
1.396 - // or whatever
1.397 - for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
1.398 - vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.399 + List<CVfnPtr>::iterator iter = m_VfnPtrList.find(vfnptr);
1.400 + if (iter == m_VfnPtrList.end())
1.401 {
1.402 - // And DEREFERENCE newHookMan->m_HookfuncVfnptr!
1.403 - // otherwise it will be executing the vtable... had to find out the hard way
1.404 - *reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = *reinterpret_cast<void**>(hmil_iter->m_HookfuncVfnptr);
1.405 - }
1.406 - }
1.407 - }
1.408 -
1.409 - void CSourceHookImpl::RemoveHookManager(RemoveHookManInfo info)
1.410 - {
1.411 - RemoveHookManager(info.plug, info.hookman);
1.412 - }
1.413 -
1.414 - void CSourceHookImpl::CompleteShutdown()
1.415 - {
1.416 - // Remove all hooks
1.417 -
1.418 - List<RemoveHookInfo> hookstoremove;
1.419 + CVfnPtr newVfnPtr(vfnptr);
1.420 + m_VfnPtrList.push_back(newVfnPtr);
1.421
1.422 -#define TMP_CHECK_LIST(name, ispost) \
1.423 - for (hook_iter = iface_iter->name.m_List.begin(); hook_iter != iface_iter->name.m_List.end(); ++hook_iter) \
1.424 - hookstoremove.push_back(RemoveHookInfo(hook_iter->plug, iface_iter->m_Ptr, \
1.425 - hook_iter->thisptr_offs, hmil_iter->m_Func, hook_iter->handler, ispost))
1.426 - for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
1.427 - hmcl_iter != m_HookMans.end(); ++hmcl_iter)
1.428 - {
1.429 - for (CHookManagerContainer::iterator hmil_iter = hmcl_iter->begin();
1.430 - hmil_iter != hmcl_iter->end(); ++hmil_iter)
1.431 - {
1.432 - for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hmil_iter->m_VfnPtrs.begin();
1.433 - vfnptr_iter != hmil_iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.434 - {
1.435 - for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
1.436 - iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
1.437 - {
1.438 - List<HookInfo>::iterator hook_iter;
1.439 - TMP_CHECK_LIST(m_PreHooks, false);
1.440 - TMP_CHECK_LIST(m_PostHooks, true);
1.441 - }
1.442 - }
1.443 - }
1.444 - }
1.445 -#undef TMP_CHECK_LIST
1.446 -
1.447 - for (List<RemoveHookInfo>::iterator rmiter = hookstoremove.begin(); rmiter != hookstoremove.end(); ++rmiter)
1.448 - RemoveHook(*rmiter);
1.449 -
1.450 - m_HookMans.clear();
1.451 - }
1.452 -
1.453 -
1.454 - bool CSourceHookImpl::AddHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
1.455 - {
1.456 - return AddHookNew(plug, Hook_Normal, iface, thisptr_offs, myHookMan, handler, post) != 0 ? true : false;
1.457 - }
1.458 + newVfnPtr.Patch(GetHookFunc());
1.459
1.460 - int CSourceHookImpl::AddHookNew(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
1.461 - ISHDelegate *handler, bool post)
1.462 - {
1.463 - void *adjustediface = NULL;
1.464 - void **cur_vtptr = NULL;
1.465 - void *cur_vfnptr = NULL;
1.466 -
1.467 - if (mode != Hook_Normal && mode != Hook_VP && mode != Hook_DVP)
1.468 - return 0;
1.469 -
1.470 - // 1) Get info about the hook manager
1.471 - CHookManagerInfo tmp;
1.472 - if (myHookMan(HA_GetInfo, &tmp) != 0)
1.473 - return 0;
1.474 -
1.475 - tmp.m_Func = myHookMan;
1.476 - tmp.m_Plug = plug;
1.477 -
1.478 - CHookManagerContainer::HMCI hmci(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx);
1.479 -
1.480 - // Add the container if not already added
1.481 - HookManContList::iterator hmcl_iter = m_HookMans.find(hmci);
1.482 - if (hmcl_iter == m_HookMans.end())
1.483 - {
1.484 - m_HookMans.push_back(CHookManagerContainer(hmci));
1.485 - hmcl_iter = m_HookMans.end();
1.486 - --hmcl_iter;
1.487 - }
1.488 -
1.489 - hmcl_iter->AddHookManager(plug, tmp);
1.490 -
1.491 - CHookManagerContainer::iterator hookman = hmcl_iter->begin();
1.492 - SH_ASSERT(hookman != hmcl_iter->end(), ("No hookman found - but we've just added one!"));
1.493 -
1.494 - // Check whether any other container holds a hook manager which holds this vfnptr
1.495 - // If yes, it means that the two are incompatible, so return false.
1.496 - for (HookManContList::iterator hmcl_iter2 = m_HookMans.begin();
1.497 - hmcl_iter2 != m_HookMans.end(); ++hmcl_iter2)
1.498 - {
1.499 - if (hmcl_iter2 != hmcl_iter)
1.500 + return m_VfnPtrList.back();
1.501 + }
1.502 + else
1.503 {
1.504 - for (CHookManagerContainer::iterator hmil_iter = hmcl_iter2->begin();
1.505 - hmil_iter != hmcl_iter2->end(); ++hmil_iter)
1.506 - {
1.507 - if (hmil_iter->m_VfnPtrs.find(cur_vfnptr) != hmil_iter->m_VfnPtrs.end())
1.508 - return 0;
1.509 - }
1.510 + return *iter;
1.511 }
1.512 }
1.513
1.514 - // Tell it to store the pointer if it's not already active
1.515 - if (hookman->m_VfnPtrs.empty())
1.516 - hookman->m_Func(HA_Register, &(*hookman));
1.517 -
1.518 -
1.519 - // find vfnptr
1.520 - if (mode == Hook_Normal || mode == Hook_VP)
1.521 + //////////////////////////////////////////////////////////////////////////
1.522 + // CVfnPtr
1.523 + //////////////////////////////////////////////////////////////////////////
1.524 +
1.525 + bool CVfnPtr::Patch(void *newValue)
1.526 {
1.527 - adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
1.528 + if (!SetMemAccess(m_Ptr, sizeof(void*), SH_MEM_READ | SH_MEM_WRITE))
1.529 + return false;
1.530
1.531 - cur_vtptr = *reinterpret_cast<void***>(
1.532 - reinterpret_cast<char*>(adjustediface) + tmp.m_VtblOffs);
1.533 - cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + tmp.m_VtblIdx);
1.534 + *reinterpret_cast<void**>(m_Ptr) = newValue;
1.535
1.536 - // For Hook_VP, adjustediface will be set to NULL later
1.537 - // because we first have to patch callclasses (callclasses are deprecated but left in for backwards compat)
1.538 - }
1.539 - else if (mode == Hook_DVP)
1.540 - {
1.541 - adjustediface = NULL;
1.542 -
1.543 - cur_vtptr = reinterpret_cast<void**>(iface);
1.544 - cur_vfnptr = cur_vtptr + tmp.m_VtblIdx;
1.545 + return true;
1.546 }
1.547
1.548 - CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.find(cur_vfnptr);
1.549 -
1.550 - if (vfnptr_iter == hookman->m_VfnPtrs.end())
1.551 + CIface &CVfnPtr::GetIface(void *iface)
1.552 {
1.553 - // Add a new one
1.554 - CVfnPtr vfp(cur_vfnptr, &m_OneIgnore);
1.555 -
1.556 - // Alter vtable entry
1.557 - if (!SetMemAccess(cur_vtptr, sizeof(void*) * (tmp.m_VtblIdx + 1), SH_MEM_READ | SH_MEM_WRITE))
1.558 - return 0;
1.559 -
1.560 - *reinterpret_cast<void**>(cur_vfnptr) = *reinterpret_cast<void**>(hookman->m_HookfuncVfnptr);
1.561 -
1.562 - hookman->m_VfnPtrs.push_back(vfp);
1.563 -
1.564 - // Make vfnptr_iter point to the new element
1.565 - vfnptr_iter = hookman->m_VfnPtrs.end();
1.566 - --vfnptr_iter;
1.567 -
1.568 - // Now that it is done, check whether we have to update any callclasses
1.569 - ApplyCallClassPatches(adjustediface, tmp.m_VtblOffs, tmp.m_VtblIdx, vfp.m_OrigEntry);
1.570 - }
1.571 -
1.572 - // If it's a VP hook, set adjustediface to NULL now ( see the comments at the beginning of sourcehook_impl.h )
1.573 - if (mode == Hook_VP)
1.574 - adjustediface = NULL;
1.575 -
1.576 - CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.find(adjustediface);
1.577 - if (iface_iter == vfnptr_iter->m_Ifaces.end())
1.578 - {
1.579 - // Add a new one
1.580 - vfnptr_iter->m_Ifaces.push_back(CIface(adjustediface));
1.581 -
1.582 - // Make iface_iter point to the new element
1.583 - iface_iter = vfnptr_iter->m_Ifaces.end();
1.584 - --iface_iter;
1.585 -
1.586 - // If this is a VP-Hook-NULL interface, go through all other interfaces of this vfnptr and tell them!
1.587 - if (adjustediface == NULL)
1.588 + List<CIface>::iterator iter = m_IfaceList.find(iface);
1.589 + if (iter == m_IfaceList.end())
1.590 {
1.591 - for (CVfnPtr::IfaceListIter iface_iter2 = vfnptr_iter->m_Ifaces.begin();
1.592 - iface_iter2 != vfnptr_iter->m_Ifaces.end(); ++iface_iter2)
1.593 + CIface newIface(iface);
1.594 + if (iface == NULL)
1.595 {
1.596 - if (*iface_iter2 != NULL)
1.597 - {
1.598 - iface_iter2->m_PreHooks.SetVPList(&iface_iter->m_PreHooks.m_List);
1.599 - iface_iter2->m_PostHooks.SetVPList(&iface_iter->m_PostHooks.m_List);
1.600 - }
1.601 + m_IfaceList.push_front(newIface);
1.602 + return m_IfaceList.front();
1.603 + }
1.604 + else
1.605 + {
1.606 + m_IfaceList.push_back(newIface);
1.607 + return m_IfaceList.back();
1.608 }
1.609 }
1.610 else
1.611 {
1.612 - // If this is a new non-VP-Hook-NULL interface, look for a non-VP-Hook-NULL interface!
1.613 - for (CVfnPtr::IfaceListIter iface_iter2 = vfnptr_iter->m_Ifaces.begin();
1.614 - iface_iter2 != vfnptr_iter->m_Ifaces.end(); ++iface_iter2)
1.615 - {
1.616 - if (*iface_iter2 == NULL)
1.617 - {
1.618 - iface_iter->m_PreHooks.SetVPList(&iface_iter2->m_PreHooks.m_List);
1.619 - iface_iter->m_PostHooks.SetVPList(&iface_iter2->m_PostHooks.m_List);
1.620 - break; // There can only be one!
1.621 - }
1.622 - }
1.623 + return *iter;
1.624 }
1.625 }
1.626
1.627 - // Add the hook
1.628 - HookInfo hookinfo;
1.629 - hookinfo.handler = handler;
1.630 - hookinfo.plug = plug;
1.631 - hookinfo.paused = false;
1.632 - hookinfo.thisptr_offs = thisptr_offs;
1.633 - hookinfo.hookid = m_HookIDMan.New(tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx, cur_vfnptr,
1.634 - adjustediface, plug, thisptr_offs, handler, post);
1.635 -
1.636 - if (post)
1.637 - iface_iter->m_PostHooks.m_List.push_back(hookinfo);
1.638 - else
1.639 - iface_iter->m_PreHooks.m_List.push_back(hookinfo);
1.640 -
1.641 - return hookinfo.hookid;
1.642 - }
1.643 -
1.644 - bool CSourceHookImpl::RemoveHookByID(Plugin plug, int hookid)
1.645 - {
1.646 - const CHookIDManager::Entry *hentry;
1.647 -
1.648 - hentry = m_HookIDMan.QueryHook(hookid);
1.649 - if (!hentry)
1.650 + //////////////////////////////////////////////////////////////////////////
1.651 + // CHookIdManager
1.652 + //////////////////////////////////////////////////////////////////////////
1.653 + CHookIDManager::CHookIDManager()
1.654 {
1.655 - // hookid doesn't exist !
1.656 - return false;
1.657 }
1.658
1.659 - HookManContList::iterator hmcl_iter = m_HookMans.find(
1.660 - CHookManagerContainer::HMCI(hentry->proto.GetProto(), hentry->vtbl_offs, hentry->vtbl_idx));
1.661 - if (hmcl_iter == m_HookMans.end() || hmcl_iter->empty())
1.662 - return false;
1.663 - CHookManagerContainer::iterator hookman = hmcl_iter->begin();
1.664 -
1.665 - // Find vfnptr
1.666 - CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.find(hentry->vfnptr);
1.667 - if (vfnptr_iter == hookman->m_VfnPtrs.end())
1.668 - return false;
1.669 -
1.670 - // Find iface
1.671 - CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.find(hentry->adjustediface);
1.672 - if (iface_iter == vfnptr_iter->m_Ifaces.end())
1.673 - return false;
1.674 -
1.675 - // Find hook
1.676 - List<HookInfo> &hooks = hentry->post ? iface_iter->m_PostHooks.m_List : iface_iter->m_PreHooks.m_List;
1.677 -
1.678 - List<HookInfo>::iterator hookiter = hooks.find(hookid);
1.679 - if (hookiter == hooks.end())
1.680 - return false;
1.681 -
1.682 - hookiter->handler->DeleteThis();
1.683 + int CHookIDManager::New(const CProto &proto, int vtbl_offs, int vtbl_idx, void *vfnptr,
1.684 + void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
1.685 + {
1.686 + Entry tmp(proto, vtbl_offs, vtbl_idx, vfnptr, adjustediface, plug, thisptr_offs, handler, post);
1.687
1.688 - // Move all iterators pointing at this
1.689 - List<HookInfo>::iterator oldhookiter = hookiter;
1.690 - hookiter = hooks.erase(hookiter);
1.691 - List<HookInfo>::iterator newhookiter = hookiter;
1.692 - --newhookiter; // The hook loop will ++ it then
1.693 - CHookList::CIter *pItIter;
1.694 -
1.695 - for (pItIter = iface_iter->m_PreHooks.m_UsedIters; pItIter; pItIter = pItIter->m_pNext)
1.696 - if (pItIter->m_Iter == oldhookiter)
1.697 - pItIter->m_Iter = newhookiter;
1.698 -
1.699 - // If this is VP-Hook-NULL interface, also check all other interfaces of this vfnptr
1.700 - if (*iface_iter == NULL)
1.701 - {
1.702 - for (CVfnPtr::IfaceListIter iface_iter2 = vfnptr_iter->m_Ifaces.begin();
1.703 - iface_iter2 != vfnptr_iter->m_Ifaces.end(); ++iface_iter2)
1.704 + size_t cursize = m_Entries.size();
1.705 + for (size_t i = 0; i < cursize; ++i)
1.706 {
1.707 - if (*iface_iter2 != NULL)
1.708 + if (m_Entries[i].isfree)
1.709 {
1.710 - for (pItIter = iface_iter2->m_PreHooks.m_UsedIters; pItIter; pItIter = pItIter->m_pNext)
1.711 - if (pItIter->m_Iter == oldhookiter)
1.712 - pItIter->m_Iter = newhookiter;
1.713 - }
1.714 - }
1.715 - }
1.716 -
1.717 - if (iface_iter->m_PostHooks.m_List.empty() && iface_iter->m_PreHooks.m_List.empty())
1.718 - {
1.719 - // If this is a VP-Hook-NULL interface, go through all other interfaces of this vfnptr and tell them!
1.720 - if (*iface_iter == NULL)
1.721 - {
1.722 - for (CVfnPtr::IfaceListIter iface_iter2 = vfnptr_iter->m_Ifaces.begin();
1.723 - iface_iter2 != vfnptr_iter->m_Ifaces.end(); ++iface_iter2)
1.724 - {
1.725 - if (iface_iter2->m_Ptr != NULL)
1.726 - {
1.727 - iface_iter2->m_PreHooks.ClearVPList();
1.728 - iface_iter2->m_PostHooks.ClearVPList();
1.729 - }
1.730 + m_Entries[i] = tmp;
1.731 + return static_cast<int>(i) + 1;
1.732 }
1.733 }
1.734
1.735 + m_Entries.push_back(tmp);
1.736 + return static_cast<int>(m_Entries.size()); // return size() because hookid = id+1 anyway
1.737 + }
1.738
1.739 - // There are no hooks on this iface anymore...
1.740 - for (HookLoopInfoStack::iterator hli_iter = m_HLIStack.begin();
1.741 - hli_iter != m_HLIStack.end(); ++hli_iter)
1.742 - {
1.743 - if (hli_iter->pCurIface == static_cast<IIface*>(&(*iface_iter)))
1.744 - hli_iter->shouldContinue = false;
1.745 - }
1.746 + bool CHookIDManager::Remove(int hookid)
1.747 + {
1.748 + int realid = hookid - 1;
1.749 + if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
1.750 + return false;
1.751
1.752 - iface_iter = vfnptr_iter->m_Ifaces.erase(iface_iter);
1.753 - if (vfnptr_iter->m_Ifaces.empty())
1.754 - {
1.755 - // No ifaces at all -> Deactivate the hook
1.756 + m_Entries[realid].isfree = true;
1.757 +
1.758 + // :TODO: remove free ids from back sometimes ??
1.759 +
1.760 + return true;
1.761 + }
1.762
1.763 - // Only patch the vfnptr back if the module is still in memory
1.764 - // If it's not, do not remove stuff like we did before
1.765 - // First off we did it wrong (shutdown the whole hookman, uh..) and secondly applications may be
1.766 - // confused by RemoveHook returning false then (yeah, I know, I made this one up, no one checks for RemoveHook error)
1.767 - if (ModuleInMemory(reinterpret_cast<char*>(vfnptr_iter->m_Ptr), SH_PTRSIZE))
1.768 - {
1.769 - *reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = vfnptr_iter->m_OrigEntry;
1.770 - }
1.771 + const CHookIDManager::Entry * CHookIDManager::QueryHook(int hookid)
1.772 + {
1.773 + int realid = hookid - 1;
1.774 + if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
1.775 + return NULL;
1.776 +
1.777 + return &m_Entries[realid];
1.778 + }
1.779
1.780 - hookman->m_VfnPtrs.erase(vfnptr_iter);
1.781 -
1.782 - // Remove callclass patch
1.783 - for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
1.784 - if (cciter->m_Ptr == hentry->adjustediface)
1.785 - cciter->RemoveCallClassPatch(hentry->vtbl_offs, hentry->vtbl_idx);
1.786 -
1.787 - if (hookman->m_VfnPtrs.empty())
1.788 + void CHookIDManager::FindAllHooks(CVector<int> &output, const CProto &proto, int vtbl_offs,
1.789 + int vtbl_idx, void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
1.790 + {
1.791 + // oh my god, a lot of parameters...
1.792 + size_t cursize = m_Entries.size();
1.793 + for (size_t i = 0; i < cursize; ++i)
1.794 + {
1.795 + if (!m_Entries[i].isfree && m_Entries[i].proto == proto && m_Entries[i].vtbl_offs == vtbl_offs &&
1.796 + m_Entries[i].vtbl_idx == vtbl_idx && m_Entries[i].adjustediface == adjustediface && m_Entries[i].plug == plug &&
1.797 + m_Entries[i].thisptr_offs == thisptr_offs && m_Entries[i].handler->IsEqual(handler) && m_Entries[i].post == post)
1.798 {
1.799 - // Unregister the hook manager
1.800 - hookman->m_Func(HA_Unregister, NULL);
1.801 + output.push_back(static_cast<int>(i) + 1);
1.802 }
1.803 }
1.804 }
1.805
1.806 - // Don't forget to remove the hookid from m_HookIDMan
1.807 - m_HookIDMan.Remove(hookid);
1.808 -
1.809 - return true;
1.810 - }
1.811 -
1.812 - bool CSourceHookImpl::RemoveHook(RemoveHookInfo info)
1.813 - {
1.814 - return RemoveHook(info.plug, info.iface, info.thisptr_offs, info.hookman, info.handler, info.post);
1.815 - }
1.816 -
1.817 - bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan, ISHDelegate *handler, bool post)
1.818 - {
1.819 - // Get info about hook manager and compute adjustediface
1.820 - CHookManagerInfo tmp;
1.821 - if (myHookMan(HA_GetInfo, &tmp) != 0)
1.822 - return false;
1.823 -
1.824 - void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
1.825 + void CHookIDManager::FindAllHooks(CVector<int> &output)
1.826 + {
1.827 + size_t cursize = m_Entries.size();
1.828 + for (size_t i = 0; i < cursize; ++i)
1.829 + {
1.830 + if (!m_Entries[i].isfree)
1.831 + output.push_back(static_cast<int>(i) + 1);
1.832 + }
1.833 + }
1.834
1.835 - // Loop through all hooks and remove those which match:
1.836 - // hookman, vfnptr, iface, plug, adjusted iface, this ptr offs, handler, post
1.837 - CVector<int> removehooks;
1.838 - m_HookIDMan.FindAllHooks(removehooks, tmp.m_Proto, tmp.m_VtblOffs, tmp.m_VtblIdx, adjustediface, plug, thisptr_offs, handler, post);
1.839 -
1.840 - if (removehooks.empty())
1.841 - return false;
1.842 -
1.843 - bool status = false;
1.844 -
1.845 - for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
1.846 + void CHookIDManager::FindAllHooks(CVector<int> &output, Plugin plug)
1.847 {
1.848 - if (RemoveHookByID(plug, *iter))
1.849 - status = true;
1.850 - }
1.851 - return status;
1.852 - }
1.853 -
1.854 - DeprecatedCallClass<void> *CSourceHookImpl::GetCallClass(void *iface, size_t size)
1.855 - {
1.856 - for (Impl_CallClassList::iterator cciter = m_CallClasses.begin(); cciter != m_CallClasses.end(); ++cciter)
1.857 - {
1.858 - if (cciter->m_Ptr == iface && cciter->m_ObjSize == size)
1.859 + size_t cursize = m_Entries.size();
1.860 + for (size_t i = 0; i < cursize; ++i)
1.861 {
1.862 - ++cciter->m_RefCounter;
1.863 - return &(*cciter);
1.864 + if (!m_Entries[i].isfree && m_Entries[i].plug == plug)
1.865 + output.push_back(static_cast<int>(i) + 1);
1.866 }
1.867 }
1.868
1.869 - // Make a new one
1.870 +
1.871 + //////////////////////////////////////////////////////////////////////////
1.872 + // CSourceHookImpl
1.873 + //////////////////////////////////////////////////////////////////////////
1.874 +
1.875
1.876 - CCallClassImpl tmp(iface, size);
1.877 - ApplyCallClassPatches(tmp);
1.878 - m_CallClasses.push_back(tmp);
1.879 - return &m_CallClasses.back();
1.880 - }
1.881 + CSourceHookImpl::CSourceHookImpl()
1.882 + {
1.883 + }
1.884 + CSourceHookImpl::~CSourceHookImpl()
1.885 + {
1.886 + }
1.887 +
1.888 + int CSourceHookImpl::GetIfaceVersion()
1.889 + {
1.890 + return SH_IFACE_VERSION;
1.891 + }
1.892 +
1.893 + int CSourceHookImpl::GetImplVersion()
1.894 + {
1.895 + return SH_IMPL_VERSION;
1.896 + }
1.897
1.898 - void CSourceHookImpl::ReleaseCallClass(DeprecatedCallClass<void> *ptr)
1.899 - {
1.900 - Impl_CallClassList::iterator iter = m_CallClasses.find(ptr);
1.901 - if (iter == m_CallClasses.end())
1.902 - return;
1.903 - --iter->m_RefCounter;
1.904 - if (iter->m_RefCounter < 1)
1.905 - m_CallClasses.erase(iter);
1.906 - }
1.907 + int CSourceHookImpl::AddHook(Plugin plug, AddHookMode mode, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
1.908 + ISHDelegate *handler, bool post)
1.909 + {
1.910 + if (mode != Hook_Normal && mode != Hook_VP && mode != Hook_DVP)
1.911 + return 0;
1.912 +
1.913 + // Get info about hook manager
1.914 + CHookManager hookManager(plug, myHookMan);
1.915 + if (!hookManager)
1.916 + return 0;
1.917 +
1.918 + // Make sure that the container exists
1.919 + CHookManagerContainer &container = m_HookManContainers.GetContainer(hookManager.GetVtblOffs(),
1.920 + hookManager.GetVtblIdx(), hookManager.GetProto());
1.921 +
1.922 + container.AddHookManager(hookManager);
1.923 +
1.924 + if (!container)
1.925 + {
1.926 + // For some weird reason, the container is empty!
1.927 + SH_ASSERT(0, ("No hookman found - but we've just added one!"));
1.928 + return 0;
1.929 + }
1.930 +
1.931 + CHookManager &hookMan = container.GetActiveHookManager();
1.932
1.933 - void CSourceHookImpl::ApplyCallClassPatches(CCallClassImpl &cc)
1.934 - {
1.935 - for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
1.936 - hmcl_iter != m_HookMans.end(); ++hmcl_iter)
1.937 - {
1.938 - for (CHookManagerContainer::iterator hookman = hmcl_iter->begin();
1.939 - hookman != hmcl_iter->end(); ++hookman)
1.940 + void *adjustediface = NULL;
1.941 + void **cur_vtptr = NULL;
1.942 + void *cur_vfnptr = NULL;
1.943 +
1.944 + // find vfnptr
1.945 + switch (mode)
1.946 {
1.947 - for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookman->m_VfnPtrs.begin();
1.948 - vfnptr_iter != hookman->m_VfnPtrs.end(); ++vfnptr_iter)
1.949 - {
1.950 - for (CVfnPtr::IfaceListIter iface_iter = vfnptr_iter->m_Ifaces.begin();
1.951 - iface_iter != vfnptr_iter->m_Ifaces.end(); ++iface_iter)
1.952 - {
1.953 - if (iface_iter->m_Ptr >= cc.m_Ptr &&
1.954 - iface_iter->m_Ptr < (reinterpret_cast<char*>(cc.m_Ptr) + cc.m_ObjSize))
1.955 - {
1.956 - cc.ApplyCallClassPatch(static_cast<int>(reinterpret_cast<char*>(iface_iter->m_Ptr) -
1.957 - reinterpret_cast<char*>(cc.m_Ptr)) + hookman->m_VtblOffs,
1.958 - hookman->m_VtblIdx, vfnptr_iter->m_OrigEntry);
1.959 - }
1.960 - }
1.961 - }
1.962 + case Hook_Normal:
1.963 + adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
1.964 +
1.965 + cur_vtptr = *reinterpret_cast<void***>(
1.966 + reinterpret_cast<char*>(adjustediface) + hookMan.GetVtblOffs());
1.967 + cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + hookMan.GetVtblIdx());
1.968 + break;
1.969 +
1.970 + case Hook_VP:
1.971 +
1.972 + adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface) + thisptr_offs);
1.973 +
1.974 + cur_vtptr = *reinterpret_cast<void***>(
1.975 + reinterpret_cast<char*>(adjustediface) + hookMan.GetVtblOffs());
1.976 + cur_vfnptr = reinterpret_cast<void*>(cur_vtptr + hookMan.GetVtblIdx());
1.977 +
1.978 + adjustediface = NULL;
1.979 + break;
1.980 +
1.981 + case Hook_DVP:
1.982 + adjustediface = NULL;
1.983 +
1.984 + cur_vtptr = reinterpret_cast<void**>(iface);
1.985 + cur_vfnptr = cur_vtptr + hookMan.GetVtblIdx();
1.986 +
1.987 + break;
1.988 }
1.989 +
1.990 + CVfnPtr &vfnPtr = hookMan.GetVfnPtr(cur_vfnptr);
1.991 + CIface &ifaceinst = vfnPtr.GetIface(adjustediface);
1.992 +
1.993 + // Add the hook
1.994 + CHook hook(plug, thisptr_offs, handler,
1.995 +
1.996 + m_HookIDMan.New(hookMan.GetProto(), hookMan.GetVtblOffs(), hookMan.GetVtblIdx(),
1.997 + cur_vfnptr, adjustediface, plug, thisptr_offs, handler, post)
1.998 +
1.999 + );
1.1000 +
1.1001 + if (post)
1.1002 + ifaceinst.GetPostHookList().push_back(hook);
1.1003 + else
1.1004 + ifaceinst.GetPreHookList().push_back(hook);
1.1005 +
1.1006 + return hook.GetID();
1.1007 }
1.1008 - }
1.1009
1.1010 - void CSourceHookImpl::ApplyCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx, void *orig_entry)
1.1011 - {
1.1012 - for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
1.1013 - ++cc_iter)
1.1014 + bool CSourceHookImpl::RemoveHook(Plugin plug, void *iface, int thisptr_offs, HookManagerPubFunc myHookMan,
1.1015 + ISHDelegate *handler, bool post)
1.1016 {
1.1017 - if (ifaceptr >= cc_iter->m_Ptr &&
1.1018 - ifaceptr < (reinterpret_cast<char*>(cc_iter->m_Ptr) + cc_iter->m_ObjSize))
1.1019 + // Get info about hook manager and compute adjustediface
1.1020 + CHookManager tmpHookMan(plug, myHookMan);
1.1021 +
1.1022 + void *adjustediface = reinterpret_cast<void*>(reinterpret_cast<char*>(iface)+thisptr_offs);
1.1023 +
1.1024 + // Loop through all hooks and remove those which match:
1.1025 + // hookman, vfnptr, iface, plug, adjusted iface, this ptr offs, handler, post
1.1026 + CVector<int> removehooks;
1.1027 + m_HookIDMan.FindAllHooks(removehooks, tmpHookMan.GetProto(), tmpHookMan.GetVtblOffs(), tmpHookMan.GetVtblIdx(),
1.1028 + adjustediface, plug, thisptr_offs, handler, post);
1.1029 +
1.1030 + if (removehooks.empty())
1.1031 + return false;
1.1032 +
1.1033 + bool status = false;
1.1034 +
1.1035 + for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
1.1036 {
1.1037 - cc_iter->ApplyCallClassPatch(static_cast<int>(reinterpret_cast<char*>(ifaceptr) -
1.1038 - reinterpret_cast<char*>(cc_iter->m_Ptr)) + vtbl_offs, vtbl_idx, orig_entry);
1.1039 + if (RemoveHookByID(*iter))
1.1040 + status = true;
1.1041 }
1.1042 - }
1.1043 - }
1.1044 -
1.1045 - void CSourceHookImpl::RemoveCallClassPatches(void *ifaceptr, int vtbl_offs, int vtbl_idx)
1.1046 - {
1.1047 - for (Impl_CallClassList::iterator cc_iter = m_CallClasses.begin(); cc_iter != m_CallClasses.end();
1.1048 - ++cc_iter)
1.1049 - {
1.1050 - if (ifaceptr >= cc_iter->m_Ptr &&
1.1051 - ifaceptr < (reinterpret_cast<char*>(cc_iter->m_Ptr) + cc_iter->m_ObjSize))
1.1052 - {
1.1053 - cc_iter->RemoveCallClassPatch(vtbl_offs, vtbl_idx);
1.1054 - }
1.1055 + return status;
1.1056 }
1.1057 - }
1.1058
1.1059 - void CSourceHookImpl::SetPluginPaused(Plugin plug, bool paused)
1.1060 - {
1.1061 - // Go through all hook managers, all interfaces, and set the status of all hooks of this plugin to paused
1.1062 - for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
1.1063 - hmcl_iter != m_HookMans.end(); ++hmcl_iter)
1.1064 + bool CSourceHookImpl::RemoveHookByID(int hookid)
1.1065 {
1.1066 - for (CHookManagerContainer::iterator hookmaniter = hmcl_iter->begin();
1.1067 - hookmaniter != hmcl_iter->end(); ++hookmaniter)
1.1068 + const CHookIDManager::Entry *hentry;
1.1069 +
1.1070 + hentry = m_HookIDMan.QueryHook(hookid);
1.1071 + if (!hentry)
1.1072 {
1.1073 - for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->m_VfnPtrs.begin();
1.1074 - vfnptr_iter != hookmaniter->m_VfnPtrs.end(); ++vfnptr_iter)
1.1075 + // hookid doesn't exist !
1.1076 + return false;
1.1077 + }
1.1078 +
1.1079 + // find hookman
1.1080 + CHookManContainerList::iterator hmcl_iter = m_HookManContainers.find(
1.1081 + CHookManagerContainer::Descriptor(hentry->vtbl_offs, hentry->vtbl_idx, hentry->proto));
1.1082 +
1.1083 + if (hmcl_iter == m_HookManContainers.end() || !(*hmcl_iter))
1.1084 + return false;
1.1085 +
1.1086 + CHookManager &hookman = hmcl_iter->GetActiveHookManager();
1.1087 +
1.1088 + // find vfnptr
1.1089 + List<CVfnPtr>::iterator vfnptr_iter = hookman.GetVfnPtrList().find(hentry->vfnptr);
1.1090 + if (vfnptr_iter == hookman.GetVfnPtrList().end())
1.1091 + return false;
1.1092 +
1.1093 + // find iface
1.1094 + List<CIface>::iterator iface_iter = vfnptr_iter->GetIfaceList().find(hentry->adjustediface);
1.1095 + if (iface_iter == vfnptr_iter->GetIfaceList().end())
1.1096 + return false;
1.1097 +
1.1098 + // find hook
1.1099 + List<CHook> &hooks = hentry->post ? iface_iter->GetPostHookList() : iface_iter->GetPreHookList();
1.1100 + List<CHook>::iterator hook_iter = hooks.find(hookid);
1.1101 + if (hook_iter == hooks.end())
1.1102 + return false;
1.1103 +
1.1104 + hook_iter->GetHandler()->DeleteThis();
1.1105 +
1.1106 + // Iterator movage!
1.1107 + List<CHook>::iterator oldhookiter = hook_iter;
1.1108 + hook_iter = hooks.erase(hook_iter);
1.1109 +
1.1110 + for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
1.1111 + ctx_iter != m_ContextStack.end(); ++ctx_iter)
1.1112 + {
1.1113 + ctx_iter->HookRemoved(oldhookiter, hook_iter);
1.1114 + }
1.1115 +
1.1116 + if (iface_iter->GetPreHookList().empty() && iface_iter->GetPostHookList().empty())
1.1117 + {
1.1118 + // -> Kill all contexts that use it!
1.1119 + for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
1.1120 + ctx_iter != m_ContextStack.end(); ++ctx_iter)
1.1121 {
1.1122 - for (CVfnPtr::IfaceListIter ifaceiter = vfnptr_iter->m_Ifaces.begin();
1.1123 - ifaceiter != vfnptr_iter->m_Ifaces.end(); ++ifaceiter)
1.1124 + ctx_iter->IfaceRemoved(&(*iface_iter));
1.1125 + }
1.1126 +
1.1127 + // There are no hooks on this iface anymore...
1.1128 + iface_iter = vfnptr_iter->GetIfaceList().erase(iface_iter);
1.1129 +
1.1130 + if (vfnptr_iter->GetIfaceList().empty())
1.1131 + {
1.1132 + // No ifaces at all -> Deactivate the hook
1.1133 +
1.1134 + for (CStack<CHookContext>::iterator ctx_iter = m_ContextStack.begin();
1.1135 + ctx_iter != m_ContextStack.end(); ++ctx_iter)
1.1136 {
1.1137 - for (List<HookInfo>::iterator hookiter = ifaceiter->m_PreHooks.m_List.begin();
1.1138 - hookiter != ifaceiter->m_PreHooks.m_List.end(); ++hookiter)
1.1139 - if (plug == hookiter->plug)
1.1140 - hookiter->paused = paused;
1.1141 + ctx_iter->VfnPtrRemoved(&(*vfnptr_iter));
1.1142 + }
1.1143
1.1144 - for (List<HookInfo>::iterator hookiter = ifaceiter->m_PostHooks.m_List.begin();
1.1145 - hookiter != ifaceiter->m_PostHooks.m_List.end(); ++hookiter)
1.1146 - if (plug == hookiter->plug)
1.1147 - hookiter->paused = paused;
1.1148 + // Only patch the vfnptr back if the module is still in memory
1.1149 + // If it's not, do not remove stuff like we did before
1.1150 + // First off we did it wrong (shutdown the whole hookman, uh..) and secondly applications may be
1.1151 + // confused by RemoveHook returning false then (yeah, I know, I made this one up, no one checks for RemoveHook error)
1.1152 + if (ModuleInMemory(reinterpret_cast<char*>(vfnptr_iter->GetPtr()), SH_PTRSIZE))
1.1153 + {
1.1154 + vfnptr_iter->Revert();
1.1155 + }
1.1156 +
1.1157 + hookman.GetVfnPtrList().erase(vfnptr_iter);
1.1158 +
1.1159 + if (hookman.GetVfnPtrList().empty())
1.1160 + {
1.1161 + // Unregister the hook manager
1.1162 + hookman.Unregister();
1.1163 }
1.1164 }
1.1165 }
1.1166 +
1.1167 + m_HookIDMan.Remove(hookid);
1.1168 + return true;
1.1169 }
1.1170 - }
1.1171 - void CSourceHookImpl::PausePlugin(Plugin plug)
1.1172 - {
1.1173 - SetPluginPaused(plug, true);
1.1174 - }
1.1175 -
1.1176 - void CSourceHookImpl::UnpausePlugin(Plugin plug)
1.1177 - {
1.1178 - SetPluginPaused(plug, false);
1.1179 - }
1.1180 -
1.1181 - void CSourceHookImpl::HookLoopBegin(IIface *pIface)
1.1182 - {
1.1183 - HookLoopInfo hli = {0};
1.1184 - hli.pCurIface = pIface;
1.1185 - hli.shouldContinue = true;
1.1186 - hli.recall = HookLoopInfo::Recall_No;
1.1187
1.1188 - static_cast<CIface*>(pIface)->m_PreHooks.RQFlagReset();
1.1189 - static_cast<CIface*>(pIface)->m_PostHooks.RQFlagReset();
1.1190 -
1.1191 - m_HLIStack.push(hli);
1.1192 - }
1.1193 -
1.1194 - void CSourceHookImpl::HookLoopEnd()
1.1195 - {
1.1196 - // When in a post recall... make sure status is high enough so that it returns the orig ret.
1.1197 - if (m_HLIStack.size() > 1 && m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
1.1198 - *m_HLIStack.front().pStatus = MRES_SUPERCEDE; // THAT'LL TEACH THEM!
1.1199 - m_HLIStack.pop();
1.1200 - }
1.1201 -
1.1202 - void CSourceHookImpl::SetRes(META_RES res)
1.1203 - {
1.1204 - *m_HLIStack.front().pCurRes = res;
1.1205 - }
1.1206 -
1.1207 - META_RES CSourceHookImpl::GetPrevRes()
1.1208 - {
1.1209 - return *m_HLIStack.front().pPrevRes;
1.1210 - }
1.1211 + void CSourceHookImpl::SetRes(META_RES res)
1.1212 + {
1.1213 + *m_ContextStack.front().pCurRes = res;
1.1214 + }
1.1215
1.1216 - META_RES CSourceHookImpl::GetStatus()
1.1217 - {
1.1218 - return *m_HLIStack.front().pStatus;
1.1219 - }
1.1220 -
1.1221 - const void *CSourceHookImpl::GetOrigRet()
1.1222 - {
1.1223 - // When in a post recall... return the orig ret of the previous hookloop.
1.1224 - if (m_HLIStack.size() > 1 && m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
1.1225 - return m_HLIStack.second().pOrigRet;
1.1226 -
1.1227 - return m_HLIStack.front().pOrigRet;
1.1228 - }
1.1229 -
1.1230 - const void *CSourceHookImpl::GetOverrideRet()
1.1231 - {
1.1232 - // pOverrideRet is always set since recalls were introduced
1.1233 - // GetOverrideRetPtr was added; a function which always returns pOverrideRet
1.1234 - // so that RETURN_META_VALUE_NEWPARAMS can provide an override result
1.1235 + META_RES CSourceHookImpl::GetPrevRes()
1.1236 + {
1.1237 + return *m_ContextStack.front().pPrevRes;
1.1238 + }
1.1239
1.1240 - // This means that we have to filter GetOverrideRet:
1.1241 - // If the status variable is < MRES_OVERRIDE, return NULL.
1.1242 -
1.1243 - return (*m_HLIStack.front().pStatus < MRES_OVERRIDE) ?
1.1244 - NULL : m_HLIStack.front().pOverrideRet;
1.1245 - }
1.1246 + META_RES CSourceHookImpl::GetStatus()
1.1247 + {
1.1248 + return *m_ContextStack.front().pStatus;
1.1249
1.1250 - void *CSourceHookImpl::GetOverrideRetPtr()
1.1251 - {
1.1252 - // As described in the comment above: always return pOverrideRet
1.1253 - return m_HLIStack.front().pOverrideRet;
1.1254 - }
1.1255 -
1.1256 - void *CSourceHookImpl::GetIfacePtr()
1.1257 - {
1.1258 - return *m_HLIStack.front().pIfacePtrPtr;
1.1259 - }
1.1260 -
1.1261 - void CSourceHookImpl::SetCurResPtr(META_RES *mres)
1.1262 - {
1.1263 - m_HLIStack.front().pCurRes = mres;
1.1264 - }
1.1265 + }
1.1266
1.1267 - void CSourceHookImpl::SetPrevResPtr(META_RES *mres)
1.1268 - {
1.1269 - m_HLIStack.front().pPrevRes = mres;
1.1270 -
1.1271 - // If we're recalling, drag the previous mres value to the new hookfunc
1.1272 - if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
1.1273 - *mres = *m_HLIStack.second().pPrevRes;
1.1274 - }
1.1275 -
1.1276 - void CSourceHookImpl::SetStatusPtr(META_RES *mres)
1.1277 - {
1.1278 - m_HLIStack.front().pStatus = mres;
1.1279 -
1.1280 - // If we're recalling, drag the previous mres value to the new hookfunc
1.1281 - if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
1.1282 - *mres = *m_HLIStack.second().pStatus;
1.1283 - }
1.1284 + const void *CSourceHookImpl::GetOrigRet()
1.1285 + {
1.1286 + return m_ContextStack.front().pOrigRet;
1.1287 + }
1.1288
1.1289 - void CSourceHookImpl::SetIfacePtrPtr(void **pp)
1.1290 - {
1.1291 - m_HLIStack.front().pIfacePtrPtr = pp;
1.1292 - }
1.1293 -
1.1294 - void CSourceHookImpl::SetOrigRetPtr(const void *ptr)
1.1295 - {
1.1296 - m_HLIStack.front().pOrigRet = ptr;
1.1297 - }
1.1298 - void CSourceHookImpl::SetOverrideRetPtr(void *ptr)
1.1299 - {
1.1300 - m_HLIStack.front().pOverrideRet = ptr;
1.1301 - }
1.1302 -
1.1303 - // New function which does all of the above + more :)
1.1304 - void *CSourceHookImpl::SetupHookLoop(META_RES *statusPtr, META_RES *prevResPtr, META_RES *curResPtr,
1.1305 - void **ifacePtrPtr, const void *origRetPtr, void *overrideRetPtr)
1.1306 - {
1.1307 - HookLoopInfo &hli = m_HLIStack.front();
1.1308 - hli.pStatus = statusPtr;
1.1309 - hli.pPrevRes = prevResPtr;
1.1310 - hli.pCurRes = curResPtr;
1.1311 - hli.pIfacePtrPtr = ifacePtrPtr;
1.1312 - hli.pOrigRet = origRetPtr;
1.1313 + const void *CSourceHookImpl::GetOverrideRet()
1.1314 + {
1.1315 + return (*m_ContextStack.front().pStatus < MRES_OVERRIDE) ?
1.1316 + NULL : m_ContextStack.front().pOverrideRet;
1.1317 + }
1.1318
1.1319 - // Handle some recall stuff
1.1320 - if (m_HLIStack.size() > 1 && m_HLIStack.second().recall)
1.1321 + void *CSourceHookImpl::GetIfacePtr()
1.1322 {
1.1323 - HookLoopInfo &other = m_HLIStack.second();
1.1324 - *statusPtr = *other.pStatus;
1.1325 - *prevResPtr = *other.pStatus;
1.1326 -
1.1327 - // When the status is low so there's no override return value and we're in a post recall,
1.1328 - // give it the orig return value as override return value.
1.1329 - if (*statusPtr < MRES_OVERRIDE && other.recall == HookLoopInfo::Recall_Post1)
1.1330 - hli.pOverrideRet = const_cast<void*>(other.pOrigRet);
1.1331 - else // Otherwise, transfer override ret normally
1.1332 - hli.pOverrideRet = other.pOverrideRet;
1.1333 - }
1.1334 - else
1.1335 - hli.pOverrideRet = overrideRetPtr;
1.1336 -
1.1337 - // Tell the hook func which override ret ptr to use
1.1338 - return hli.pOverrideRet;
1.1339 - }
1.1340 -
1.1341 - bool CSourceHookImpl::ShouldContinue()
1.1342 - {
1.1343 - // If recall is true, we shall not continue either.
1.1344 - // This is because, if it's true and ShouldContinue is called, it suggests that the
1.1345 - // actual recall is done and that we are back in the original handler which shall return
1.1346 - // immediately.
1.1347 -
1.1348 - // Post-recalls:
1.1349 - // The second element on the stack has recall set to Recall_Post1.
1.1350 - // This means that we want to skip this part and the original function calling thing, so
1.1351 - // we store the status mres value, set status to MRES_SUPERCEDE, and return false.
1.1352 - // We also set the recall flag to Recall_Post2, so the next time the thing calls us, we
1.1353 - // can return true (so that the thing goes into post hooks).
1.1354 - if (m_HLIStack.size() > 1)
1.1355 - {
1.1356 - if (m_HLIStack.second().recall == HookLoopInfo::Recall_Post1)
1.1357 + // If in recall: return last one
1.1358 + if (m_ContextStack.front().m_State >= CHookContext::State_Recall_Pre &&
1.1359 + m_ContextStack.front().m_State <= CHookContext::State_Recall_PostVP)
1.1360 {
1.1361 - m_HLIStack.front().temporaryStatus = *m_HLIStack.front().pStatus;
1.1362 - *m_HLIStack.front().pStatus = MRES_SUPERCEDE;
1.1363 - m_HLIStack.second().recall = HookLoopInfo::Recall_Post2;
1.1364 - return false;
1.1365 + return m_ContextStack.second().pIfacePtr;
1.1366 }
1.1367 - else if (m_HLIStack.second().recall == HookLoopInfo::Recall_Post2)
1.1368 + else
1.1369 {
1.1370 - *m_HLIStack.front().pStatus = m_HLIStack.front().temporaryStatus;
1.1371 - return m_HLIStack.front().shouldContinue;
1.1372 + return m_ContextStack.front().pIfacePtr;
1.1373 }
1.1374 }
1.1375 - return m_HLIStack.front().shouldContinue && !m_HLIStack.front().recall;
1.1376 - }
1.1377 +
1.1378 + void *CSourceHookImpl::GetOverrideRetPtr()
1.1379 + {
1.1380 + return m_ContextStack.front().pOverrideRet;
1.1381 + }
1.1382 +
1.1383 + void CSourceHookImpl::UnloadPlugin(Plugin plug)
1.1384 + {
1.1385 + // 1) Remove all hooks by this plugin
1.1386
1.1387 - void CSourceHookImpl::DoRecall()
1.1388 - {
1.1389 - if (!m_HLIStack.empty())
1.1390 + CVector<int> removehooks;
1.1391 + m_HookIDMan.FindAllHooks(removehooks, plug);
1.1392 +
1.1393 + for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
1.1394 + RemoveHookByID(*iter);
1.1395 +
1.1396 + // 2) Remove all hook managers
1.1397 + m_HookManContainers.RemoveHookMans(plug);
1.1398 + }
1.1399 +
1.1400 + void CSourceHookImpl::RemoveHookManager(Plugin plug, HookManagerPubFunc pubFunc)
1.1401 {
1.1402 - // Also watch out for post recalls! Described at the beginning of sourcehook_impl.h
1.1403 - m_HLIStack.front().recall =
1.1404 - static_cast<CIface*>(m_HLIStack.front().pCurIface)->m_PostHooks.RQFlagGet() ?
1.1405 - HookLoopInfo::Recall_Post1 : HookLoopInfo::Recall_Pre;
1.1406 -
1.1407 - CHookList *mlist = static_cast<CHookList*>(m_HLIStack.front().recall == HookLoopInfo::Recall_Pre ?
1.1408 - m_HLIStack.front().pCurIface->GetPreHooks() : m_HLIStack.front().pCurIface->GetPostHooks());
1.1409 - mlist->m_Recall = true;
1.1410 + // 1) Remove all its hooks
1.1411 + CVector<int> removehooks;
1.1412 +
1.1413 + // Get info about hook manager
1.1414 + CHookManager hookManager(plug, pubFunc);
1.1415 + if (!hookManager)
1.1416 + return;
1.1417 +
1.1418 + // Make sure that the container exists
1.1419 + CHookManagerContainer &container = m_HookManContainers.GetContainer(hookManager.GetVtblOffs(),
1.1420 + hookManager.GetVtblIdx(), hookManager.GetProto());
1.1421 +
1.1422 + CHookManagerContainer::iterator cont_iter = container.find(CHookManager::Descriptor(plug, pubFunc));
1.1423 +
1.1424 + for (List<CVfnPtr>::iterator vfnptr_iter = cont_iter->GetVfnPtrList().begin();
1.1425 + vfnptr_iter != cont_iter->GetVfnPtrList().end(); ++vfnptr_iter)
1.1426 + {
1.1427 + for (List<CIface>::iterator iface_iter = vfnptr_iter->GetIfaceList().begin();
1.1428 + iface_iter != vfnptr_iter->GetIfaceList().end(); ++iface_iter)
1.1429 + {
1.1430 + List<CHook>::iterator hook_iter;
1.1431 + for (hook_iter = iface_iter->GetPreHookList().begin();
1.1432 + hook_iter != iface_iter->GetPreHookList().end(); ++hook_iter)
1.1433 + removehooks.push_back(hook_iter->GetID());
1.1434 +
1.1435 + for (hook_iter = iface_iter->GetPostHookList().begin();
1.1436 + hook_iter != iface_iter->GetPostHookList().end(); ++hook_iter)
1.1437 + removehooks.push_back(hook_iter->GetID());
1.1438 + }
1.1439 + }
1.1440 +
1.1441 + for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
1.1442 + RemoveHookByID(*iter);
1.1443 +
1.1444 + // 2) Remove it
1.1445 + container.RemoveHookMans(plug, pubFunc);
1.1446 + }
1.1447 +
1.1448 + void CSourceHookImpl::SetIgnoreHooks(void *vfnptr)
1.1449 + {
1.1450 + CHookContext ctx;
1.1451 + ctx.m_State = CHookContext::State_Ignore;
1.1452 + m_ContextStack.push(ctx);
1.1453 + }
1.1454 +
1.1455 + void CSourceHookImpl::ResetIgnoreHooks(void *vfnptr)
1.1456 + {
1.1457 + if (!m_ContextStack.empty() && m_ContextStack.front().m_State == CHookContext::State_Ignore)
1.1458 + m_ContextStack.pop();
1.1459 + }
1.1460 +
1.1461 + void CSourceHookImpl::DoRecall()
1.1462 + {
1.1463 + CHookContext newCtx;
1.1464 + CHookContext &curCtx = m_ContextStack.front();
1.1465 +
1.1466 +
1.1467 + newCtx.m_State = curCtx.m_State + (CHookContext::State_Recall_Pre - CHookContext::State_Pre);
1.1468 + if (newCtx.m_State == CHookContext::State_Recall_Post || newCtx.m_State == CHookContext::State_Recall_PostVP)
1.1469 + {
1.1470 + // Also save orig ret
1.1471 + newCtx.pOrigRet = curCtx.pOrigRet;
1.1472 + }
1.1473
1.1474 // The hookfunc usually does this, but it won't have a chance to see it,
1.1475 // so for recalls, we update status here if it's required
1.1476 - if (*m_HLIStack.front().pCurRes > *m_HLIStack.front().pStatus)
1.1477 - *m_HLIStack.front().pStatus = *m_HLIStack.front().pCurRes;
1.1478 + if (*curCtx.pCurRes > *curCtx.pStatus)
1.1479 + *curCtx.pStatus = *curCtx.pCurRes;
1.1480
1.1481 + newCtx.pStatus = curCtx.pStatus;
1.1482 + newCtx.pOverrideRet = curCtx.pOverrideRet;
1.1483 + newCtx.pPrevRes = curCtx.pPrevRes;
1.1484 + newCtx.m_Iter = curCtx.m_Iter;
1.1485 +
1.1486 + // Take this with us!
1.1487 + newCtx.pCurRes = curCtx.pCurRes;
1.1488 +
1.1489 + m_ContextStack.push(newCtx);
1.1490 + curCtx.m_State = CHookContext::State_Dead;
1.1491 }
1.1492 - }
1.1493 +
1.1494 + IHookContext *CSourceHookImpl::SetupHookLoop(IHookManagerInfo *hi, void *vfnptr, void *thisptr, void **origentry, META_RES *statusPtr,
1.1495 + META_RES *prevResPtr, META_RES *curResPtr, const void *origRetPtr, void *overrideRetPtr)
1.1496 + {
1.1497 + CHookContext *pCtx = NULL;
1.1498 + CHookContext *oldctx = m_ContextStack.empty() ? NULL : &m_ContextStack.front();
1.1499 + if (oldctx)
1.1500 + {
1.1501 + // SH_CALL
1.1502 + if (oldctx->m_State == CHookContext::State_Ignore)
1.1503 + {
1.1504 + *statusPtr = MRES_IGNORED;
1.1505 + oldctx->m_State = CHookContext::State_Dead;
1.1506 +
1.1507 + List<CVfnPtr> &vfnptrList = static_cast<CHookManager*>(hi)->GetVfnPtrList();
1.1508 + List<CVfnPtr>::iterator vfnptr_iter = vfnptrList.find(vfnptr);
1.1509 + if (vfnptr_iter == vfnptrList.end())
1.1510 + {
1.1511 + // :TODO: what??
1.1512 + }
1.1513 + else
1.1514 + {
1.1515 + *origentry = vfnptr_iter->GetOrigEntry();
1.1516 + }
1.1517 +
1.1518 + oldctx->pOrigRet = origRetPtr;
1.1519 + return oldctx;
1.1520 + }
1.1521 + // Recall
1.1522 + else if (oldctx->m_State >= CHookContext::State_Recall_Pre &&
1.1523 + oldctx->m_State <= CHookContext::State_Recall_PostVP)
1.1524 + {
1.1525 + pCtx = oldctx;
1.1526 +
1.1527 + *statusPtr = *(oldctx->pStatus);
1.1528 + *prevResPtr = *(oldctx->pPrevRes);
1.1529 +
1.1530 + pCtx->m_Iter = oldctx->m_Iter;
1.1531 +
1.1532 + // Only have possibility of calling the orig func in pre recall mode
1.1533 + pCtx->m_CallOrig = (oldctx->m_State == CHookContext::State_Recall_Pre ||
1.1534 + oldctx->m_State == CHookContext::State_Recall_PreVP);
1.1535 +
1.1536 + overrideRetPtr = pCtx->pOverrideRet;
1.1537 +
1.1538 + // When the status is low so there's no override return value and we're in a post recall,
1.1539 + // give it the orig return value as override return value.
1.1540 + if (pCtx->m_State == CHookContext::State_Recall_Post ||
1.1541 + pCtx->m_State == CHookContext::State_Recall_PostVP)
1.1542 + {
1.1543 + origRetPtr = oldctx->pOrigRet;
1.1544 + if (*statusPtr < MRES_OVERRIDE)
1.1545 + overrideRetPtr = const_cast<void*>(pCtx->pOrigRet);
1.1546 + }
1.1547 + }
1.1548 + }
1.1549 + if (!pCtx)
1.1550 + {
1.1551 + pCtx = m_ContextStack.make_next();
1.1552 + pCtx->m_State = CHookContext::State_Born;
1.1553 + pCtx->m_CallOrig = true;
1.1554 + }
1.1555 +
1.1556 + pCtx->pIface = NULL;
1.1557
1.1558 - void CSourceHookImpl::SetIgnoreHooks(Plugin plug, void *vfnptr)
1.1559 - {
1.1560 - m_OneIgnore = vfnptr;
1.1561 - }
1.1562 + List<CVfnPtr> &vfnptrList = static_cast<CHookManager*>(hi)->GetVfnPtrList();
1.1563 + List<CVfnPtr>::iterator vfnptr_iter = vfnptrList.find(vfnptr);
1.1564 + if (vfnptr_iter == vfnptrList.end())
1.1565 + {
1.1566 + pCtx->m_State = CHookContext::State_Dead;
1.1567 + }
1.1568 + else
1.1569 + {
1.1570 + pCtx->pVfnPtr = &(*vfnptr_iter);
1.1571 + *origentry = vfnptr_iter->GetOrigEntry();
1.1572 + pCtx->pIface = vfnptr_iter->FindIface(thisptr);
1.1573 + }
1.1574 +
1.1575 + pCtx->pStatus = statusPtr;
1.1576 + pCtx->pPrevRes = prevResPtr;
1.1577 + pCtx->pCurRes = curResPtr;
1.1578 + pCtx->pThisPtr = thisptr;
1.1579 + pCtx->pOverrideRet = overrideRetPtr;
1.1580 + pCtx->pOrigRet = origRetPtr;
1.1581 +
1.1582 + return pCtx;
1.1583 + }
1.1584 +
1.1585 + void CSourceHookImpl::EndContext(IHookContext *pCtx)
1.1586 + {
1.1587 + m_ContextStack.pop();
1.1588 + }
1.1589 +
1.1590 + void CSourceHookImpl::CompleteShutdown()
1.1591 + {
1.1592 + CVector<int> removehooks;
1.1593 + m_HookIDMan.FindAllHooks(removehooks);
1.1594 +
1.1595 + for (CVector<int>::iterator iter = removehooks.begin(); iter != removehooks.end(); ++iter)
1.1596 + RemoveHookByID(*iter);
1.1597 + }
1.1598 +
1.1599 + void CSourceHookImpl::PausePlugin(Plugin plug)
1.1600 + {
1.1601 + CVector<int> pausehooks;
1.1602 + m_HookIDMan.FindAllHooks(pausehooks, plug);
1.1603 +
1.1604 + for (CVector<int>::iterator iter = pausehooks.begin(); iter != pausehooks.end(); ++iter)
1.1605 + PauseHookByID(*iter);
1.1606 + }
1.1607 +
1.1608 + void CSourceHookImpl::UnpausePlugin(Plugin plug)
1.1609 + {
1.1610 + CVector<int> unpausehooks;
1.1611 + m_HookIDMan.FindAllHooks(unpausehooks, plug);
1.1612 +
1.1613 + for (CVector<int>::iterator iter = unpausehooks.begin(); iter != unpausehooks.end(); ++iter)
1.1614 + UnpauseHookByID(*iter);
1.1615 + }
1.1616 +
1.1617 + bool CSourceHookImpl::PauseHookByID(int hookid)
1.1618 + {
1.1619 + return SetHookPaused(hookid, true);
1.1620 + }
1.1621 +
1.1622 + bool CSourceHookImpl::UnpauseHookByID(int hookid)
1.1623 + {
1.1624 + return SetHookPaused(hookid, false);
1.1625 + }
1.1626 +
1.1627 + bool CSourceHookImpl::SetHookPaused(int hookid, bool paused)
1.1628 + {
1.1629 + const CHookIDManager::Entry *hentry;
1.1630 +
1.1631 + hentry = m_HookIDMan.QueryHook(hookid);
1.1632 + if (!hentry)
1.1633 + {
1.1634 + // hookid doesn't exist !
1.1635 + return false;
1.1636 + }
1.1637 +
1.1638 + // find hookman
1.1639 + CHookManContainerList::iterator hmcl_iter = m_HookManContainers.find(
1.1640 + CHookManagerContainer::Descriptor(hentry->vtbl_offs, hentry->vtbl_idx, hentry->proto));
1.1641 +
1.1642 + if (hmcl_iter == m_HookManContainers.end() || !(*hmcl_iter))
1.1643 + return false;
1.1644 +
1.1645 + CHookManager &hookman = hmcl_iter->GetActiveHookManager();
1.1646
1.1647 - void CSourceHookImpl::ResetIgnoreHooks(Plugin plug, void *vfnptr)
1.1648 - {
1.1649 - m_OneIgnore = NULL;
1.1650 - }
1.1651 + // find vfnptr
1.1652 + List<CVfnPtr>::iterator vfnptr_iter = hookman.GetVfnPtrList().find(hentry->vfnptr);
1.1653 + if (vfnptr_iter == hookman.GetVfnPtrList().end())
1.1654 + return false;
1.1655 +
1.1656 + // find iface
1.1657 + List<CIface>::iterator iface_iter = vfnptr_iter->GetIfaceList().find(hentry->adjustediface);
1.1658 + if (iface_iter == vfnptr_iter->GetIfaceList().end())
1.1659 + return false;
1.1660
1.1661 - void *CSourceHookImpl::GetOrigVfnPtrEntry(void *vfnptr)
1.1662 - {
1.1663 - for (HookManContList::iterator hmcl_iter = m_HookMans.begin();
1.1664 - hmcl_iter != m_HookMans.end(); ++hmcl_iter)
1.1665 + // find hook
1.1666 + List<CHook> &hooks = hentry->post ? iface_iter->GetPostHookList() : iface_iter->GetPreHookList();
1.1667 + List<CHook>::iterator hook_iter = hooks.find(hookid);
1.1668 + if (hook_iter == hooks.end())
1.1669 + return false;
1.1670 +
1.1671 + hook_iter->SetPaused(paused);
1.1672 + return true;
1.1673 + }
1.1674 +
1.1675 + //////////////////////////////////////////////////////////////////////////
1.1676 + // CHookContext
1.1677 + //////////////////////////////////////////////////////////////////////////
1.1678 + ISHDelegate *CHookContext::GetNext()
1.1679 {
1.1680 - for (CHookManagerContainer::iterator hookmaniter = hmcl_iter->begin();
1.1681 - hookmaniter != hmcl_iter->end(); ++hookmaniter)
1.1682 + CIface *pVPIface;
1.1683 +
1.1684 + switch (m_State)
1.1685 {
1.1686 - for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = hookmaniter->m_VfnPtrs.begin();
1.1687 - vfnptr_iter != hookmaniter->m_VfnPtrs.end(); ++vfnptr_iter)
1.1688 + case State_Dead:
1.1689 + return NULL;
1.1690 +
1.1691 + case State_Born:
1.1692 + m_Iter = List<CHook>::iterator();
1.1693 + m_State = State_Pre;
1.1694 +
1.1695 + // fall-through
1.1696 + case State_Recall_Pre:
1.1697 + m_State = State_Pre;
1.1698 + case State_Pre:
1.1699 + if (pIface)
1.1700 + {
1.1701 + if (!m_Iter)
1.1702 + m_Iter = pIface->GetPreHookList().begin();
1.1703 + else
1.1704 + ++m_Iter;
1.1705 + SkipPaused(m_Iter, pIface->GetPreHookList());
1.1706 +
1.1707 + if (m_Iter != pIface->GetPreHookList().end())
1.1708 + {
1.1709 + pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
1.1710 + return m_Iter->GetHandler();
1.1711 + }
1.1712 + }
1.1713 +
1.1714 + // end of normal hooks -> VP
1.1715 +
1.1716 + m_State = State_PreVP;
1.1717 + m_Iter = List<CHook>::iterator();
1.1718 +
1.1719 + // fall-through
1.1720 + case State_Recall_PreVP:
1.1721 + m_State = State_PreVP;
1.1722 + case State_PreVP:
1.1723 + pVPIface = pVfnPtr->FindIface(NULL);
1.1724 + if (pVPIface)
1.1725 + {
1.1726 + if (!m_Iter)
1.1727 + m_Iter = pVPIface->GetPreHookList().begin();
1.1728 + else
1.1729 + ++m_Iter;
1.1730 + SkipPaused(m_Iter, pVPIface->GetPreHookList());
1.1731 +
1.1732 + if (m_Iter != pVPIface->GetPreHookList())
1.1733 + {
1.1734 + pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
1.1735 + return m_Iter->GetHandler();
1.1736 + }
1.1737 + }
1.1738 +
1.1739 + // end VP hooks -> orig call
1.1740 +
1.1741 + m_State = State_OrigCall;
1.1742 + return NULL;
1.1743 +
1.1744 + case State_OrigCall:
1.1745 + m_Iter = List<CHook>::iterator();
1.1746 + m_State = State_Post;
1.1747 +
1.1748 + // fall-through
1.1749 + case State_Post:
1.1750 + if (pIface)
1.1751 {
1.1752 - if (vfnptr_iter->m_Ptr == vfnptr)
1.1753 - return vfnptr_iter->m_OrigEntry;
1.1754 + if (!m_Iter)
1.1755 + m_Iter = pIface->GetPostHookList().begin();
1.1756 + else
1.1757 + ++m_Iter;
1.1758 + SkipPaused(m_Iter, pIface->GetPostHookList());
1.1759 +
1.1760 + if (m_Iter != pIface->GetPostHookList().end())
1.1761 + {
1.1762 + pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
1.1763 + return m_Iter->GetHandler();
1.1764 + }
1.1765 + }
1.1766 + // end of normal hooks -> VP
1.1767 +
1.1768 + m_State = State_PostVP;
1.1769 + m_Iter = List<CHook>::iterator();
1.1770 +
1.1771 + // fall-through
1.1772 + case State_PostVP:
1.1773 + pVPIface = pVfnPtr->FindIface(NULL);
1.1774 + if (pVPIface)
1.1775 + {
1.1776 + if (!m_Iter)
1.1777 + m_Iter = pVPIface->GetPostHookList().begin();
1.1778 + else
1.1779 + ++m_Iter;
1.1780 + SkipPaused(m_Iter, pVPIface->GetPostHookList());
1.1781 +
1.1782 + if (m_Iter != pVPIface->GetPostHookList())
1.1783 + {
1.1784 + pIfacePtr = reinterpret_cast<void*>(reinterpret_cast<char*>(pThisPtr) - m_Iter->GetThisPointerOffset());
1.1785 + return m_Iter->GetHandler();
1.1786 + }
1.1787 }
1.1788 +
1.1789 + // end VP hooks -> done
1.1790 +
1.1791 + m_State = State_Dead;
1.1792 + return NULL;
1.1793 +
1.1794 + case State_Recall_Post:
1.1795 + // Skip pre hooks _and_ orig call
1.1796 + m_State = State_Post;
1.1797 + return NULL;
1.1798 +
1.1799 + case State_Recall_PostVP:
1.1800 + // Skip pre hooks _and_ orig call
1.1801 + m_State = State_PostVP;
1.1802 + return NULL;
1.1803 + }
1.1804 + return NULL;
1.1805 + }
1.1806 +
1.1807 + void *CHookContext::GetOverrideRetPtr()
1.1808 + {
1.1809 + return pOverrideRet;
1.1810 + }
1.1811 +
1.1812 + const void *CHookContext::GetOrigRetPtr()
1.1813 + {
1.1814 + return pOrigRet;
1.1815 + }
1.1816 +
1.1817 + bool CHookContext::ShouldCallOrig()
1.1818 + {
1.1819 + return m_CallOrig;
1.1820 + }
1.1821 +
1.1822 + void CHookContext::HookRemoved(List<CHook>::iterator oldhookiter, List<CHook>::iterator nexthookiter)
1.1823 + {
1.1824 + if (m_Iter == oldhookiter)
1.1825 + {
1.1826 + m_Iter = nexthookiter;
1.1827 + --m_Iter;
1.1828 }
1.1829 }
1.1830 - return NULL;
1.1831 - }
1.1832
1.1833 - ////////////////////////////
1.1834 - // CCallClassImpl
1.1835 - ////////////////////////////
1.1836 - CSourceHookImpl::CCallClassImpl::CCallClassImpl(void *ptr, size_t size)
1.1837 - : m_Ptr(ptr), m_ObjSize(size), m_RefCounter(1)
1.1838 - {
1.1839 - }
1.1840 - CSourceHookImpl::CCallClassImpl::~CCallClassImpl()
1.1841 - {
1.1842 - }
1.1843 -
1.1844 - void *CSourceHookImpl::CCallClassImpl::GetThisPtr()
1.1845 - {
1.1846 - return m_Ptr;
1.1847 - }
1.1848 - void *CSourceHookImpl::CCallClassImpl::GetOrigFunc(int vtbloffs, int vtblidx)
1.1849 - {
1.1850 - OrigVTables::iterator iter = m_VT.find(vtbloffs);
1.1851 - if (iter != m_VT.end() && iter->val.size() > (size_t)vtblidx)
1.1852 + void CHookContext::IfaceRemoved(CIface *iface)
1.1853 {
1.1854 - return iter->val[vtblidx];
1.1855 + if (pIface == iface)
1.1856 + pIface = NULL;
1.1857 }
1.1858 - return NULL;
1.1859 - }
1.1860
1.1861 - void CSourceHookImpl::CCallClassImpl::ApplyCallClassPatch(int vtbl_offs, int vtbl_idx, void *orig_entry)
1.1862 - {
1.1863 - OrigFuncs &tmpvec = m_VT[vtbl_offs];
1.1864 - if (tmpvec.size() <= (size_t)vtbl_idx)
1.1865 - tmpvec.resize(vtbl_idx+1, NULL);
1.1866 - tmpvec[vtbl_idx] = orig_entry;
1.1867 - }
1.1868 - void CSourceHookImpl::CCallClassImpl::RemoveCallClassPatch(int vtbl_offs, int vtbl_idx)
1.1869 - {
1.1870 - OrigVTables::iterator iter = m_VT.find(vtbl_offs);
1.1871 - if (iter != m_VT.end())
1.1872 + void CHookContext::VfnPtrRemoved(CVfnPtr *vfnptr)
1.1873 {
1.1874 - if (iter->val.size() > (size_t)vtbl_idx)
1.1875 + if (pVfnPtr == vfnptr)
1.1876 {
1.1877 - iter->val[vtbl_idx] = 0;
1.1878 -
1.1879 - OrigFuncs &of = iter->val;
1.1880 - OrigFuncs::iterator lastused = of.end();
1.1881 - for (OrigFuncs::iterator viter = of.begin(); viter != of.end(); ++viter)
1.1882 - {
1.1883 - if (*viter)
1.1884 - lastused = viter;
1.1885 - }
1.1886 - if (lastused == of.end())
1.1887 - {
1.1888 - // No used element => Remove the whole vector
1.1889 - m_VT.erase(iter);
1.1890 - return;
1.1891 - }
1.1892 - of.resize(lastused - of.begin() + 1);
1.1893 + pVfnPtr = NULL;
1.1894 + m_State = State_Dead;
1.1895 }
1.1896 }
1.1897 }
1.1898 -
1.1899 - ////////////////////////////
1.1900 - // CHookManagerInfo
1.1901 - ////////////////////////////
1.1902 - CSourceHookImpl::CHookManagerInfo::CHookManagerInfo() : m_HookManVersion(0)
1.1903 - {
1.1904 - }
1.1905 - CSourceHookImpl::CHookManagerInfo::~CHookManagerInfo()
1.1906 - {
1.1907 - }
1.1908 -
1.1909 - IVfnPtr *CSourceHookImpl::CHookManagerInfo::FindVfnPtr(void *vfnptr)
1.1910 - {
1.1911 - VfnPtrListIter iter = m_VfnPtrs.find(vfnptr);
1.1912 - return iter == m_VfnPtrs.end() ? NULL : &(*iter);
1.1913 - }
1.1914 - void CSourceHookImpl::CHookManagerInfo::SetInfo(int vtbl_offs, int vtbl_idx, const char *proto)
1.1915 - {
1.1916 - m_VtblOffs = vtbl_offs;
1.1917 - m_VtblIdx = vtbl_idx;
1.1918 - m_Proto = proto;
1.1919 - }
1.1920 - void CSourceHookImpl::CHookManagerInfo::SetHookfuncVfnptr(void *hookfunc_vfnptr)
1.1921 - {
1.1922 - m_HookfuncVfnptr = hookfunc_vfnptr;
1.1923 - }
1.1924 - void CSourceHookImpl::CHookManagerInfo::SetVersion(int version)
1.1925 - {
1.1926 - m_HookManVersion = version;
1.1927 - }
1.1928 - ////////////////////////////
1.1929 - // CVfnPtr
1.1930 - ////////////////////////////
1.1931 -
1.1932 -
1.1933 - // If you get a crash here, the ptr passed is invalid
1.1934 - // This usually means a SH_DECL_MANUALHOOK* with wrong thisptroffs/vtbloffs/vtblidx
1.1935 - CSourceHookImpl::CVfnPtr::CVfnPtr(void *ptr, void **pOneIgnore) : m_Ptr(ptr),
1.1936 - m_OrigEntry(*reinterpret_cast<void**>(ptr)), m_pOneIgnore(pOneIgnore)
1.1937 - {
1.1938 - }
1.1939 - CSourceHookImpl::CVfnPtr::~CVfnPtr()
1.1940 - {
1.1941 - }
1.1942 -
1.1943 - void *CSourceHookImpl::CVfnPtr::GetVfnPtr()
1.1944 - {
1.1945 - return m_Ptr;
1.1946 - }
1.1947 -
1.1948 - void *CSourceHookImpl::CVfnPtr::GetOrigEntry()
1.1949 - {
1.1950 - return m_OrigEntry;
1.1951 - }
1.1952 -
1.1953 - IIface *CSourceHookImpl::CVfnPtr::FindIface(void *ptr)
1.1954 - {
1.1955 - if (m_Ptr == *m_pOneIgnore)
1.1956 - {
1.1957 - *m_pOneIgnore = NULL; // Only once!
1.1958 - return NULL;
1.1959 - }
1.1960 -
1.1961 - IfaceListIter iter = m_Ifaces.find(ptr);
1.1962 -
1.1963 - // If nothing is found, check for a NULL-interface (VP hooks only)
1.1964 - if (iter == m_Ifaces.end())
1.1965 - {
1.1966 - iter = m_Ifaces.find((void*)0);
1.1967 - return iter == m_Ifaces.end() ? NULL : &(*iter);
1.1968 - }
1.1969 - else
1.1970 - {
1.1971 - return &(*iter);
1.1972 - }
1.1973 - }
1.1974 -
1.1975 - ////////////////////////////
1.1976 - // CIface
1.1977 - ////////////////////////////
1.1978 - CSourceHookImpl::CIface::CIface(void *ptr) : m_Ptr(ptr)
1.1979 - {
1.1980 - }
1.1981 - CSourceHookImpl::CIface::~CIface()
1.1982 - {
1.1983 - }
1.1984 -
1.1985 - void *CSourceHookImpl::CIface::GetPtr()
1.1986 - {
1.1987 - return m_Ptr;
1.1988 - }
1.1989 -
1.1990 - IHookList *CSourceHookImpl::CIface::GetPreHooks()
1.1991 - {
1.1992 - return &m_PreHooks;
1.1993 - }
1.1994 - IHookList *CSourceHookImpl::CIface::GetPostHooks()
1.1995 - {
1.1996 - return &m_PostHooks;
1.1997 - }
1.1998 -
1.1999 - ////////////////////////////
1.2000 - // CHookList
1.2001 - ////////////////////////////
1.2002 -
1.2003 - CSourceHookImpl::CHookList::CHookList() : m_VPList(NULL), m_FreeIters(NULL), m_UsedIters(NULL),
1.2004 - m_Recall(false)
1.2005 - {
1.2006 - }
1.2007 - CSourceHookImpl::CHookList::CHookList(const CHookList &other) : m_VPList(other.m_VPList), m_List(other.m_List),
1.2008 - m_FreeIters(NULL), m_UsedIters(NULL), m_Recall(false)
1.2009 - {
1.2010 - }
1.2011 -
1.2012 - CSourceHookImpl::CHookList::~CHookList()
1.2013 - {
1.2014 - while (m_FreeIters)
1.2015 - {
1.2016 - CIter *iter = m_FreeIters->m_pNext;
1.2017 - delete m_FreeIters;
1.2018 - m_FreeIters = iter;
1.2019 - }
1.2020 - while (m_UsedIters)
1.2021 - {
1.2022 - CIter *iter = m_UsedIters->m_pNext;
1.2023 - delete m_UsedIters;
1.2024 - m_UsedIters = iter;
1.2025 - }
1.2026 - }
1.2027 - IHookList::IIter *CSourceHookImpl::CHookList::GetIter()
1.2028 - {
1.2029 - m_RQFlag = true;
1.2030 -
1.2031 - CIter *ret;
1.2032 - if (m_FreeIters)
1.2033 - {
1.2034 - ret = m_FreeIters;
1.2035 - m_FreeIters = ret->m_pNext;
1.2036 - ret->GoToBegin();
1.2037 - }
1.2038 - else
1.2039 - {
1.2040 - ret = new CIter(this);
1.2041 - }
1.2042 -
1.2043 - // Muuuh, if we're recalling, it shall be a copy of the last iterator, incremented by one
1.2044 - if (m_Recall && m_UsedIters)
1.2045 - {
1.2046 - ret->Set(m_UsedIters); // m_UsedIters is the last returned and not released iterator
1.2047 - ret->Next(); // Use next instead of directly incrementing its m_Iter:
1.2048 - // skips paused plugins
1.2049 - }
1.2050 -
1.2051 - ret->m_pNext = m_UsedIters;
1.2052 - ret->m_pPrev = NULL;
1.2053 - if (m_UsedIters)
1.2054 - m_UsedIters->m_pPrev = ret;
1.2055 - m_UsedIters = ret;
1.2056 -
1.2057 - m_Recall = false;
1.2058 -
1.2059 - return ret;
1.2060 - }
1.2061 - void CSourceHookImpl::CHookList::ReleaseIter(IIter *pIter)
1.2062 - {
1.2063 - CIter *pIter2 = static_cast<CIter*>(pIter);
1.2064 -
1.2065 - // Unlink from m_UsedIters
1.2066 -
1.2067 - if (pIter2->m_pNext)
1.2068 - pIter2->m_pNext->m_pPrev = pIter2->m_pPrev;
1.2069 - if (pIter2->m_pPrev)
1.2070 - pIter2->m_pPrev->m_pNext = pIter2->m_pNext;
1.2071 - if (pIter2 == m_UsedIters)
1.2072 - m_UsedIters = NULL;
1.2073 -
1.2074 - // Link to m_FreeIters
1.2075 -
1.2076 - pIter2->m_pNext = m_FreeIters;
1.2077 -
1.2078 - m_FreeIters = pIter2;
1.2079 -
1.2080 - // Reset recall state.
1.2081 - m_Recall = false;
1.2082 - }
1.2083 -
1.2084 - void CSourceHookImpl::CHookList::SetVPList(List<HookInfo> *newList)
1.2085 - {
1.2086 - m_VPList = newList;
1.2087 -
1.2088 - // Update cached CIter objects
1.2089 -
1.2090 - CIter *pTmp;
1.2091 - pTmp = m_FreeIters;
1.2092 - while (pTmp)
1.2093 - {
1.2094 - pTmp->m_Iter.SetListLeft(m_VPList);
1.2095 - pTmp = pTmp->m_pNext;
1.2096 - }
1.2097 -
1.2098 - pTmp = m_UsedIters;
1.2099 - while (pTmp)
1.2100 - {
1.2101 - pTmp->m_Iter.SetListLeft(m_VPList);
1.2102 - pTmp = pTmp->m_pNext;
1.2103 - }
1.2104 - }
1.2105 -
1.2106 - void CSourceHookImpl::CHookList::ClearVPList()
1.2107 - {
1.2108 - SetVPList(NULL);
1.2109 - }
1.2110 -
1.2111 - CSourceHookImpl::CHookList::CIter::CIter(CHookList *pList) : m_pList(pList),
1.2112 - m_Iter(pList->m_VPList, &m_pList->m_List), m_pNext(NULL)
1.2113 - {
1.2114 - }
1.2115 - CSourceHookImpl::CHookList::CIter::~CIter()
1.2116 - {
1.2117 - }
1.2118 -
1.2119 - void CSourceHookImpl::CHookList::CIter::Set(CIter *pOther)
1.2120 - {
1.2121 - m_Iter = pOther->m_Iter;
1.2122 - }
1.2123 -
1.2124 - void CSourceHookImpl::CHookList::CIter::GoToBegin()
1.2125 - {
1.2126 - m_Iter.GoToBegin();
1.2127 - SkipPaused();
1.2128 - }
1.2129 -
1.2130 - bool CSourceHookImpl::CHookList::CIter::End()
1.2131 - {
1.2132 - if (!m_pList)
1.2133 - return false;
1.2134 - return m_Iter.End();;
1.2135 - }
1.2136 - void CSourceHookImpl::CHookList::CIter::Next()
1.2137 - {
1.2138 - if (!m_pList)
1.2139 - return;
1.2140 - ++m_Iter;
1.2141 - SkipPaused();
1.2142 - }
1.2143 - void CSourceHookImpl::CHookList::CIter::Clear()
1.2144 - {
1.2145 - m_pList = NULL;
1.2146 - }
1.2147 - void CSourceHookImpl::CHookList::CIter::SkipPaused()
1.2148 - {
1.2149 - while (!m_Iter.End() && m_Iter->paused)
1.2150 - ++m_Iter;
1.2151 - }
1.2152 -
1.2153 - ISHDelegate *CSourceHookImpl::CHookList::CIter::Handler()
1.2154 - {
1.2155 - return m_Iter->handler;
1.2156 - }
1.2157 - int CSourceHookImpl::CHookList::CIter::ThisPtrOffs()
1.2158 - {
1.2159 - return m_Iter->thisptr_offs;
1.2160 - }
1.2161 -
1.2162 - //////////////////////////////////////////////////////////////////////////
1.2163 - // CProto
1.2164 - //////////////////////////////////////////////////////////////////////////
1.2165 - char *CSourceHookImpl::CProto::DupProto(const char *p)
1.2166 - {
1.2167 - if (!p)
1.2168 - return NULL;
1.2169 -
1.2170 - char *newproto;
1.2171 - if (*p)
1.2172 - {
1.2173 - size_t len = strlen(p);
1.2174 - newproto = new char[len+1];
1.2175 - memcpy(newproto, p, len+1);
1.2176 - } else {
1.2177 - const ProtoInfo *pi1 = reinterpret_cast<const ProtoInfo *>(p);
1.2178 - int *ar_copy = new int[pi1->numOfParams + 1];
1.2179 - for (int i = 0; i <= pi1->numOfParams; i++)
1.2180 - ar_copy[i] = pi1->params[i];
1.2181 - ProtoInfo *copy = new ProtoInfo(pi1->retTypeSize, pi1->numOfParams, ar_copy);
1.2182 - newproto = reinterpret_cast<char *>(copy);
1.2183 - }
1.2184 -
1.2185 - return newproto;
1.2186 - }
1.2187 -
1.2188 - void CSourceHookImpl::CProto::FreeProto(char *prot)
1.2189 - {
1.2190 - if (!prot)
1.2191 - return;
1.2192 -
1.2193 - if (*prot)
1.2194 - {
1.2195 - delete [] prot;
1.2196 - } else {
1.2197 - ProtoInfo *pi = reinterpret_cast<ProtoInfo *>(prot);
1.2198 - delete [] pi->params;
1.2199 - delete pi;
1.2200 - }
1.2201 - }
1.2202 -
1.2203 - bool CSourceHookImpl::CProto::Equal(const char *p1, const char *p2)
1.2204 - {
1.2205 - if (!p1 || !p2)
1.2206 - return false;
1.2207 -
1.2208 - if (*p1 && *p2) // Case1: Both old
1.2209 - {
1.2210 - // As in old versions
1.2211 - return strcmp(p1, p2) == 0;
1.2212 - }
1.2213 - else if (!*p1 && !*p2) // Case2: Both new
1.2214 - {
1.2215 - const ProtoInfo *pi1 = reinterpret_cast<const ProtoInfo*>(p1);
1.2216 - const ProtoInfo *pi2 = reinterpret_cast<const ProtoInfo*>(p2);
1.2217 -
1.2218 - if (pi1->retTypeSize == pi2->retTypeSize &&
1.2219 - pi1->numOfParams == pi2->numOfParams)
1.2220 - {
1.2221 - // params[0] is 0 for "normal" functions and -1 for vararg functions
1.2222 - // params[1] is size of first parameter
1.2223 - // params[2] is size of second parameter ...
1.2224 - for (int i = 0; i <= pi1->numOfParams; ++i)
1.2225 - {
1.2226 - if (pi1->params[i] != pi2->params[i])
1.2227 - return false;
1.2228 - }
1.2229 - return true;
1.2230 - }
1.2231 - else
1.2232 - {
1.2233 - return false;
1.2234 - }
1.2235 - }
1.2236 - else // Case3: Mixed old/new
1.2237 - {
1.2238 - // Trust the user
1.2239 - return true;
1.2240 - }
1.2241 - }
1.2242 -
1.2243 -
1.2244 - //////////////////////////////////////////////////////////////////////////
1.2245 - // CHookManagerContainer
1.2246 - //////////////////////////////////////////////////////////////////////////
1.2247 - void CSourceHookImpl::CHookManagerContainer::AddHookManager(Plugin plug, const CHookManagerInfo &hookman)
1.2248 - {
1.2249 - iterator iter;
1.2250 - // Check whether such a hook manager already exists; if yes, ignore.
1.2251 - for (iter = begin(); iter != end(); ++iter)
1.2252 - {
1.2253 - if (iter->m_Plug == plug && iter->m_Func == hookman.m_Func)
1.2254 - return;
1.2255 - }
1.2256 -
1.2257 - // It doesn't -> add it. Add it to the end of its version group.
1.2258 - for (iter = begin(); iter != end(); ++iter)
1.2259 - {
1.2260 - if (iter->m_HookManVersion < hookman.m_HookManVersion)
1.2261 - break;
1.2262 - }
1.2263 -
1.2264 - bool isBeginning = iter == begin();
1.2265 -
1.2266 - insert(iter, hookman);
1.2267 -
1.2268 - // If we inserted it at the beginning and if the dam breaks open many years too soon
1.2269 - // and if there is more than one hookman and if the second one isn't empty, transfer
1.2270 - // hooks from second to first
1.2271 -
1.2272 - if (isBeginning && size() > 1)
1.2273 - {
1.2274 - iter = begin();
1.2275 - iterator second = iter;
1.2276 - ++second;
1.2277 -
1.2278 - if (!second->m_VfnPtrs.empty())
1.2279 - {
1.2280 - // Move the vfnptrs from the old hook manager to the new one
1.2281 - iter->m_VfnPtrs = second->m_VfnPtrs;
1.2282 - second->m_VfnPtrs.clear();
1.2283 -
1.2284 - // Unregister the old one, register the new one
1.2285 - second->m_Func(HA_Unregister, NULL);
1.2286 - iter->m_Func(HA_Register, &(*iter));
1.2287 -
1.2288 - // Go through all vfnptrs in this hookman and patch them to point to the new manager's handler!
1.2289 - // or whatever
1.2290 - for (CHookManagerInfo::VfnPtrListIter vfnptr_iter = iter->m_VfnPtrs.begin();
1.2291 - vfnptr_iter != iter->m_VfnPtrs.end(); ++vfnptr_iter)
1.2292 - {
1.2293 - // And DEREFERENCE newHookMan->m_HookfuncVfnptr!
1.2294 - // otherwise it will be executing the vtable... had to find out the hard way
1.2295 - *reinterpret_cast<void**>(vfnptr_iter->m_Ptr) = *reinterpret_cast<void**>(iter->m_HookfuncVfnptr);
1.2296 - }
1.2297 - }
1.2298 - }
1.2299 - }
1.2300 -
1.2301 - //////////////////////////////////////////////////////////////////////////
1.2302 - // CHookIDManager
1.2303 - //////////////////////////////////////////////////////////////////////////
1.2304 - CSourceHookImpl::CHookIDManager::CHookIDManager()
1.2305 - {
1.2306 - }
1.2307 -
1.2308 - int CSourceHookImpl::CHookIDManager::New(const CProto &proto, int vtbl_offs, int vtbl_idx, void *vfnptr,
1.2309 - void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
1.2310 - {
1.2311 - Entry tmp(proto, vtbl_offs, vtbl_idx, vfnptr, adjustediface, plug, thisptr_offs, handler, post);
1.2312 -
1.2313 - size_t cursize = m_Entries.size();
1.2314 - for (size_t i = 0; i < cursize; ++i)
1.2315 - {
1.2316 - if (m_Entries[i].isfree)
1.2317 - {
1.2318 - m_Entries[i] = tmp;
1.2319 - return static_cast<int>(i) + 1;
1.2320 - }
1.2321 - }
1.2322 -
1.2323 - m_Entries.push_back(tmp);
1.2324 - return static_cast<int>(m_Entries.size()); // return size() because hookid = id+1 anyway
1.2325 - }
1.2326 -
1.2327 - bool CSourceHookImpl::CHookIDManager::Remove(int hookid)
1.2328 - {
1.2329 - int realid = hookid - 1;
1.2330 - if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
1.2331 - return false;
1.2332 -
1.2333 - m_Entries[realid].isfree = true;
1.2334 -
1.2335 - // :TODO: remove free ids from back sometimes ??
1.2336 -
1.2337 - return true;
1.2338 - }
1.2339 -
1.2340 - const CSourceHookImpl::CHookIDManager::Entry * CSourceHookImpl::CHookIDManager::QueryHook(int hookid)
1.2341 - {
1.2342 - int realid = hookid - 1;
1.2343 - if (realid < 0 || realid >= static_cast<int>(m_Entries.size()) || m_Entries[realid].isfree)
1.2344 - return NULL;
1.2345 -
1.2346 - return &m_Entries[realid];
1.2347 - }
1.2348 -
1.2349 - void CSourceHookImpl::CHookIDManager::FindAllHooks(CVector<int> &output, const CProto &proto, int vtbl_offs,
1.2350 - int vtbl_idx, void *adjustediface, Plugin plug, int thisptr_offs, ISHDelegate *handler, bool post)
1.2351 - {
1.2352 - // oh my god, a lot of parameters...
1.2353 - size_t cursize = m_Entries.size();
1.2354 - for (size_t i = 0; i < cursize; ++i)
1.2355 - {
1.2356 - if (!m_Entries[i].isfree && m_Entries[i].proto == proto && m_Entries[i].vtbl_offs == vtbl_offs &&
1.2357 - m_Entries[i].vtbl_idx == vtbl_idx && m_Entries[i].adjustediface == adjustediface && m_Entries[i].plug == plug &&
1.2358 - m_Entries[i].thisptr_offs == thisptr_offs && m_Entries[i].handler->IsEqual(handler) && m_Entries[i].post == post)
1.2359 - {
1.2360 - output.push_back(static_cast<int>(i) + 1);
1.2361 - }
1.2362 - }
1.2363 - }
1.2364 }