public HookStateChangeInfo(Hook aHook, IRunningProcess aProcess, eNktHookState previousState, eNktHookState currentState)
{
Process = aProcess;
PreviousState = previousState;
CurrentState = currentState;
Hook = aHook;
}
public HookNode AddHook(Hook aHook, Function aFunction)
{
var aHookNode = new HookNode(aHook, aFunction);
//var node = Nodes.FirstOrDefault(node1 => node1 .Equals(aHookNode));
//if (node != null) return (HookNode)node;
Nodes.Add(aHookNode);
return aHookNode;
}
private void Add(IRunningProcess aProcess, Module aModule, Function aFunction, Hook aHook)
{
lock (_dataLock)
{
if (_hookNodes.ContainsKey(aHook)) return;
var aProcessNode = _nodes.ValueOrInitialize(aProcess);
var aModuleNode = aProcessNode.ModuleNodeFor(aModule);
var aHookNode = aModuleNode.AddHook(aHook, aFunction);
_hookNodes[aHook] = aHookNode;
_model.Nodes.Add(aProcessNode);
}
}
public bool Equals(Hook other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return other.Id.Equals(Id);
}
public FunctionCallInfo(Hook aHook, IProcess aProcess, NktHookCallInfo hookCallInfo)
{
Hook = aHook;
Process = aProcess;
HookCallInfo = hookCallInfo;
}
public bool IsHookActiveOn(Hook aHook, IRunningProcess aProcess)
{
var nktHook = NktHookFor(aHook);
if (nktHook == null) return false;
return nktHook.State(aProcess.Id) == eNktHookState.stActive;
}
private void RemoveHook(Hook aHook)
{
_spyManager.RemoveHook(aHook);
_hookingSettings.RemoveWhere(rule => rule.Matches(aHook.ModuleName, aHook.FunctionName));
}
private void DisplayHook(IRunningProcess aProcess, Module aModule, Function aFunction, Hook aHook)
{
_view.DisplayHook(aProcess, aModule, aFunction, aHook);
}
private void PerformDragAndDropFromProcessesToHook(IEnumerable<IProcess> processes, Hook hook)
{
processes.ToList().ForEach(p => PerformDragAndDropFromProcessToHook(p, hook));
}
public void Update(Hook aHook, IRunningProcess aProcess, eNktHookState currentState, eNktHookState previousState)
{
var module = aProcess.ModuleByName(aHook.ModuleName);
lock (_syncLock)
{
if (currentState == eNktHookState.stRemoved)
{
_hooks.ValueOrInitialize(aProcess).Remove(aHook);
_activeHooks.ValueOrInitialize(aProcess).Remove(aHook.Id);
if (previousState == eNktHookState.stActive)
_hookCountByModule.Update(aProcess, moduleDictionary =>
{
moduleDictionary.Update(module, oldCount => --oldCount);
return moduleDictionary;
});
}
else
{
_hooks.ValueOrInitialize(aProcess).Add(aHook);
if (currentState == eNktHookState.stActive)
{
_activeHooks.ValueOrInitialize(aProcess).Add(aHook.Id);
_hookCountByModule.Update(aProcess, moduleDictionary =>
{
moduleDictionary.Update(module, oldCount => ++oldCount);
return moduleDictionary;
});
}
}
}
}
public void RemoveHook(Hook aHook)
{
AddTreeViewUpdateJob(_hooksTreeView, () => _hooksTreeView.Remove(aHook));
}
public void DisplayHook(IRunningProcess aProcess, Module aModule, Function aFunction, Hook aHook)
{
}
public void Do(Hook aHook, Action<IRunningProcess, Module, Function> anAction)
{
if (!IsAlive()) return;
var module = ModuleByName(aHook.ModuleName);
if (module == null) return;
var function = module.FunctionByName(aHook.FunctionName);
if (function == null) return;
anAction(this, module, function);
}
public void ApplyHookOn(Hook hook, IRunningProcess process)
{
var rule = new HookingRule(process.Name, hook.ModuleName, hook.FunctionName);
RecreateHookFromRuleOn(new List<IRunningProcess>{ process }, rule);
}
private NktHook NktHookFor(Hook aHook)
{
return _manager.Hooks().GetById(aHook.Id);
}
private void FunctionCalledHandler(Hook hook, IProcess aProcess, NktHookCallInfo hookCallInfo)
{
var aFunctionCallInfo = new FunctionCallInfo(hook, aProcess, hookCallInfo);
_functionCallHandler.Handle(aFunctionCallInfo);
}
private void PerformDragAndDropFromProcessToHook(IProcess process, Hook hook)
{
process.IfRunning(p => _hookLoader.ApplyHookOn(hook, p));
}
public void DisplayHook(Hook hook, IRunningProcess process, HookStateChangeInfo pepe)
{
if (!process.IsAlive()) return;
lock (_dataLock)
{
process.Do(hook, (p, m, f) =>
{
Add(process, m, f, hook);
_hookNodes[hook].UpdateState(pepe.CurrentState);
});
}
}
private void ProcessAddedHook(IRunningProcess aProcess, Module aModule, Function aFunction, Hook aHook)
{
_hookingSettings.Add(aProcess.Name, aModule.Name, aFunction.Name);
DisplayHook(aProcess, aModule, aFunction, aHook);
_view.RemoveAllHooksEnabled = true;
_view.ExportHookingSettings = true;
_view.RemoveHookEnabled = true;
}
public void Remove(Hook aHook)
{
lock (_dataLock)
{
if (!_hookNodes.ContainsKey(aHook)) return;
var aNode = _hookNodes[aHook];
_hookNodes.Remove(aHook);
aNode.Accept(new DeepDeleteVisitor());
}
}
public void SelectedHookChanged(Hook aHook)
{
SelectedHookChanged(new[] { aHook });
}
public HookNode(Hook aHook, Function aFunction)
{
_functionName = aFunction.Name;
Text = _functionName;
Hook = aHook;
}
private void HookStateChangedHandler(Hook hook, IRunningProcess aProcess, eNktHookState previousState, eNktHookState currentState)
{
var aStateChangeInfo = new HookStateChangeInfo(hook, aProcess, previousState, currentState);
var aHook = aStateChangeInfo.Hook;
if (aStateChangeInfo.CurrentState == eNktHookState.stRemoved)
{
_view.RemoveHook(aHook);
_view.RemoveHookEnabled = false;
_view.RemoveAllHooksEnabled = _spyManager.AtLeastOneHookWasCreated;
_view.ExportHookingSettings = _spyManager.AtLeastOneHookWasCreated;
}
else
_view.DisplayHookStatus(aStateChangeInfo);
if (!aProcess.IsHooked())
_view.DisplayRecentlyUnhookedProcess(aProcess);
else if (aProcess.AtLeastOneHookIsActive())
_view.DisplayRecentlyHookedProcessAsActive(aProcess);
else
_view.DisplayRecentlyHookedProcessAsInactive(aProcess);
_view.RefreshModulesView();
}
public void RemoveHook(Hook aHook)
{
var nktHook = NktHookFor(aHook);
if (nktHook == null) return;
_manager.DestroyHook(nktHook);
}
