mirror of
https://github.com/mirror/processhacker
synced 2026-06-08 16:03:24 +00:00
wj32
01b533163a
git-svn-id: svn://svn.code.sf.net/p/processhacker/code@412 21ef857c-d57f-4fe0-8362-d861dc6d29cd
1487 lines
54 KiB
C#
1487 lines
54 KiB
C#
/*
|
|
* Process Hacker
|
|
*
|
|
* Copyright (C) 2008 Dean
|
|
* Copyright (C) 2008 wj32
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
using Aga.Controls.Tree;
|
|
|
|
namespace ProcessHacker
|
|
{
|
|
public partial class HackerWindow : Form
|
|
{
|
|
delegate void QueueUpdatedCallback();
|
|
delegate void AddIconCallback(Icon icon);
|
|
delegate void AddListViewItemCallback(ListView lv, string[] text);
|
|
|
|
#region Variables
|
|
|
|
public int RefreshInterval = 1000;
|
|
|
|
public HelpWindow HelpForm = new HelpWindow();
|
|
public SysInfoWindow SysInfoWindow = null;
|
|
public HandleFilterWindow HandleFilterForm = new HandleFilterWindow();
|
|
|
|
ProcessProvider processP = new ProcessProvider();
|
|
ServiceProvider serviceP = new ServiceProvider();
|
|
|
|
Dictionary<int, List<string>> processServices = new Dictionary<int, List<string>>();
|
|
|
|
int processSelectedItems;
|
|
int processSelectedPID;
|
|
Process processSelected;
|
|
|
|
List<Control> listControls = new List<Control>();
|
|
|
|
Queue<KeyValuePair<string, Icon>> statusMessages = new Queue<KeyValuePair<string, Icon>>();
|
|
List<string> log = new List<string>();
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
public MenuItem WindowMenuItem
|
|
{
|
|
get { return windowMenuItem; }
|
|
}
|
|
|
|
public NotifyIcon NotifyIcon
|
|
{
|
|
get { return notifyIcon; }
|
|
}
|
|
|
|
public wyDay.Controls.VistaMenu VistaMenu
|
|
{
|
|
get { return vistaMenu; }
|
|
}
|
|
|
|
public ProcessProvider ProcessProvider
|
|
{
|
|
get { return processP; }
|
|
}
|
|
|
|
public ServiceProvider ServiceProvider
|
|
{
|
|
get { return serviceP; }
|
|
}
|
|
|
|
public ProcessTree ProcessList
|
|
{
|
|
get { return treeProcesses; }
|
|
}
|
|
|
|
public Dictionary<int, List<string>> ProcessServices
|
|
{
|
|
get { return processServices; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Events
|
|
|
|
#region Buttons
|
|
|
|
//private void buttonSearch_Click(object sender, EventArgs e)
|
|
//{
|
|
// PerformSearch(buttonSearch.Text);
|
|
//}
|
|
|
|
#endregion
|
|
|
|
#region Lists
|
|
|
|
private void listProcesses_KeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
if (e.KeyData == Keys.Delete)
|
|
{
|
|
terminateMenuItem_Click(null, null);
|
|
}
|
|
}
|
|
|
|
private void listProcesses_SelectionChanged(object sender, EventArgs e)
|
|
{
|
|
processSelectedItems = treeProcesses.SelectedNodes.Count;
|
|
|
|
if (processSelectedItems == 1)
|
|
{
|
|
processSelectedPID = treeProcesses.SelectedNodes[0].PID;
|
|
|
|
try
|
|
{
|
|
try
|
|
{
|
|
if (processSelected != null)
|
|
processSelected.Close();
|
|
}
|
|
catch
|
|
{ }
|
|
|
|
processSelected = Process.GetProcessById(processSelectedPID);
|
|
}
|
|
catch
|
|
{
|
|
processSelected = null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
processSelectedPID = -1;
|
|
|
|
try
|
|
{
|
|
if (processSelected != null)
|
|
processSelected.Close();
|
|
}
|
|
catch
|
|
{ }
|
|
|
|
processSelected = null;
|
|
}
|
|
}
|
|
|
|
private void listServices_DoubleClick(object sender, EventArgs e)
|
|
{
|
|
propertiesServiceMenuItem_Click(null, null);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Main Menu
|
|
|
|
private void selectAllHackerMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
foreach (Control c in listControls)
|
|
{
|
|
if (c.Focused)
|
|
{
|
|
if (c is ListView)
|
|
{
|
|
Misc.SelectAll((c as ListView).Items);
|
|
}
|
|
else if (c is TreeViewAdv)
|
|
{
|
|
Misc.SelectAll((c as TreeViewAdv).AllNodes);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void getSNFAMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
PromptBox box = new PromptBox();
|
|
|
|
if (box.ShowDialog() == DialogResult.OK)
|
|
{
|
|
try
|
|
{
|
|
int address = (int)BaseConverter.ToNumberParse(box.Value);
|
|
|
|
InformationBox infoBox = new InformationBox(Symbols.GetNameFromAddress(address));
|
|
|
|
infoBox.ShowDialog();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Process Hacker", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void runAsMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
RunWindow run = new RunWindow();
|
|
|
|
run.TopMost = this.TopMost;
|
|
run.ShowDialog();
|
|
}
|
|
|
|
private void findHandlesMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
HandleFilterForm.Show();
|
|
HandleFilterForm.Activate();
|
|
}
|
|
|
|
private void inspectPEFileMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
OpenFileDialog ofd = new OpenFileDialog();
|
|
|
|
if (ofd.ShowDialog() == DialogResult.OK)
|
|
{
|
|
PEWindow pw = Program.GetPEWindow(ofd.FileName, new Program.PEWindowInvokeAction(delegate(PEWindow f)
|
|
{
|
|
try
|
|
{
|
|
f.Show();
|
|
}
|
|
catch
|
|
{ }
|
|
}));
|
|
}
|
|
}
|
|
|
|
private void logMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
string str = "";
|
|
|
|
foreach (string item in log)
|
|
str += item + "\r\n";
|
|
|
|
InformationBox box = new InformationBox(str);
|
|
|
|
box.TopMost = this.TopMost;
|
|
box.ShowDialog();
|
|
}
|
|
|
|
private void aboutMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
AboutWindow about = new AboutWindow();
|
|
|
|
about.TopMost = this.TopMost;
|
|
about.ShowDialog();
|
|
}
|
|
|
|
private void optionsMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
OptionsWindow options = new OptionsWindow();
|
|
|
|
options.TopMost = this.TopMost;
|
|
options.ShowDialog();
|
|
|
|
RefreshInterval = Properties.Settings.Default.RefreshInterval;
|
|
timerFire.Interval = RefreshInterval;
|
|
}
|
|
|
|
private void helpMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
HelpForm.Show();
|
|
HelpForm.Activate();
|
|
}
|
|
|
|
private void exitMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
this.Close();
|
|
}
|
|
|
|
private void sysInfoMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
if (SysInfoWindow == null)
|
|
{
|
|
SysInfoWindow = new SysInfoWindow();
|
|
}
|
|
SysInfoWindow.Show();
|
|
SysInfoWindow.Activate();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Notification Icon & Menu
|
|
|
|
private void notifyIcon_MouseDoubleClick(object sender, MouseEventArgs e)
|
|
{
|
|
showHideMenuItem_Click(null, null);
|
|
}
|
|
|
|
private void showHideMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
this.Visible = !this.Visible;
|
|
this.WindowState = FormWindowState.Normal;
|
|
this.Activate();
|
|
}
|
|
|
|
private void exitTrayMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
this.Close();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Process Context Menu
|
|
|
|
private void menuProcess_Popup(object sender, EventArgs e)
|
|
{
|
|
if (treeProcesses.SelectedTreeNodes.Count == 0)
|
|
{
|
|
Misc.DisableAllMenuItems(menuProcess);
|
|
}
|
|
else if (treeProcesses.SelectedTreeNodes.Count == 1)
|
|
{
|
|
Misc.EnableAllMenuItems(menuProcess);
|
|
|
|
priorityMenuItem.Text = "&Priority";
|
|
terminateMenuItem.Text = "&Terminate Process";
|
|
suspendMenuItem.Text = "&Suspend Process";
|
|
resumeMenuItem.Text = "&Resume Process";
|
|
|
|
realTimeMenuItem.Checked = false;
|
|
highMenuItem.Checked = false;
|
|
aboveNormalMenuItem.Checked = false;
|
|
normalMenuItem.Checked = false;
|
|
belowNormalMenuItem.Checked = false;
|
|
idleMenuItem.Checked = false;
|
|
|
|
try
|
|
{
|
|
switch (Process.GetProcessById(processSelectedPID).PriorityClass)
|
|
{
|
|
case ProcessPriorityClass.RealTime:
|
|
realTimeMenuItem.Checked = true;
|
|
break;
|
|
|
|
case ProcessPriorityClass.High:
|
|
highMenuItem.Checked = true;
|
|
break;
|
|
|
|
case ProcessPriorityClass.AboveNormal:
|
|
aboveNormalMenuItem.Checked = true;
|
|
break;
|
|
|
|
case ProcessPriorityClass.Normal:
|
|
normalMenuItem.Checked = true;
|
|
break;
|
|
|
|
case ProcessPriorityClass.BelowNormal:
|
|
belowNormalMenuItem.Checked = true;
|
|
break;
|
|
|
|
case ProcessPriorityClass.Idle:
|
|
idleMenuItem.Checked = true;
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
priorityMenuItem.Text = "(" + ex.Message + ")";
|
|
priorityMenuItem.Enabled = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Misc.DisableAllMenuItems(menuProcess);
|
|
|
|
terminateMenuItem.Text = "&Terminate Processes";
|
|
suspendMenuItem.Text = "&Suspend Processes";
|
|
resumeMenuItem.Text = "&Resume Processes";
|
|
|
|
terminateMenuItem.Enabled = true;
|
|
suspendMenuItem.Enabled = true;
|
|
resumeMenuItem.Enabled = true;
|
|
copyProcessMenuItem.Enabled = true;
|
|
}
|
|
|
|
if (treeProcesses.Model.Nodes.Count == 0)
|
|
{
|
|
selectAllProcessMenuItem.Enabled = false;
|
|
}
|
|
else
|
|
{
|
|
selectAllProcessMenuItem.Enabled = true;
|
|
}
|
|
}
|
|
|
|
private void terminateMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
if (MessageBox.Show("Are you sure you want to terminate the selected process(es)?",
|
|
"Process Hacker", MessageBoxButtons.YesNo,
|
|
MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button2) == DialogResult.Yes)
|
|
{
|
|
foreach (ProcessNode node in treeProcesses.SelectedNodes)
|
|
{
|
|
try
|
|
{
|
|
using (Win32.ProcessHandle handle = new Win32.ProcessHandle(node.PID,
|
|
Win32.PROCESS_RIGHTS.PROCESS_TERMINATE))
|
|
handle.Terminate();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DialogResult result = MessageBox.Show("Could not terminate process \"" + node.Name +
|
|
"\" with PID " + node.PID.ToString() + ":\n\n" +
|
|
ex.Message, "Process Hacker", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
|
|
|
|
if (result == DialogResult.Cancel)
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void suspendMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
foreach (ProcessNode node in treeProcesses.SelectedNodes)
|
|
{
|
|
Process process;
|
|
|
|
try
|
|
{
|
|
process = Process.GetProcessById(node.PID);
|
|
}
|
|
catch { return; }
|
|
|
|
if (Properties.Settings.Default.WarnDangerous && IsDangerousPID(process.Id))
|
|
{
|
|
DialogResult result = MessageBox.Show("The process with PID " + process.Id + " is a system process. Are you" +
|
|
" sure you want to suspend it?", "Process Hacker", MessageBoxButtons.YesNoCancel,
|
|
MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button2);
|
|
|
|
if (result == DialogResult.No)
|
|
continue;
|
|
else if (result == DialogResult.Cancel)
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
foreach (ProcessThread thread in process.Threads)
|
|
{
|
|
using (Win32.ThreadHandle handle = new Win32.ThreadHandle(thread.Id,
|
|
Win32.THREAD_RIGHTS.THREAD_SUSPEND_RESUME))
|
|
handle.Suspend();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DialogResult result = MessageBox.Show("Could not suspend process with PID " + node.PID +
|
|
".\n\n" + ex.Message, "Process Hacker", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
|
|
|
|
if (result == DialogResult.Cancel)
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void resumeMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
foreach (ProcessNode node in treeProcesses.SelectedNodes)
|
|
{
|
|
Process process;
|
|
|
|
try
|
|
{
|
|
process = Process.GetProcessById(node.PID);
|
|
}
|
|
catch { return; }
|
|
|
|
try
|
|
{
|
|
foreach (ProcessThread thread in process.Threads)
|
|
{
|
|
using (Win32.ThreadHandle handle = new Win32.ThreadHandle(thread.Id,
|
|
Win32.THREAD_RIGHTS.THREAD_SUSPEND_RESUME))
|
|
handle.Resume();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
DialogResult result = MessageBox.Show("Could not resume process with PID " + node.PID.ToString() +
|
|
".\n\n" + ex.Message, "Process Hacker", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
|
|
|
|
if (result == DialogResult.Cancel)
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void inspectProcessMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
ProcessWindow pForm = Program.GetProcessWindow(processP.Dictionary[processSelectedPID],
|
|
new Program.PWindowInvokeAction(delegate(ProcessWindow f)
|
|
{
|
|
f.Show();
|
|
f.Activate();
|
|
}));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show("Could not inspect the process:\n\n" + ex.Message,
|
|
"Process Hacker", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void affinityProcessMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
ProcessAffinity affForm = new ProcessAffinity(processSelectedPID);
|
|
|
|
try
|
|
{
|
|
affForm.TopMost = this.TopMost;
|
|
affForm.ShowDialog();
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
private void servicesProcessMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
ServiceWindow sw = new ServiceWindow(processServices[processSelectedPID].ToArray());
|
|
|
|
sw.TopMost = this.TopMost;
|
|
sw.ShowDialog();
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
private void tokenMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
using (Win32.ProcessHandle process = new Win32.ProcessHandle(processSelectedPID,
|
|
Program.MinProcessQueryRights))
|
|
{
|
|
TokenWindow tokForm = new TokenWindow(process);
|
|
|
|
tokForm.TopMost = this.TopMost;
|
|
tokForm.Text = "Token - " + processP.Dictionary[processSelectedPID].Name +
|
|
" (PID " + processSelectedPID.ToString() + ")";
|
|
tokForm.ShowDialog();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Process Hacker", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void terminatorProcessMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
TerminatorWindow w = new TerminatorWindow(processSelectedPID);
|
|
|
|
w.Text = "Terminator - " + processP.Dictionary[processSelectedPID].Name +
|
|
" (PID " + processSelectedPID.ToString() + ")";
|
|
|
|
w.ShowDialog();
|
|
}
|
|
|
|
#region Run As
|
|
|
|
private void launchAsUserProcessMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
Properties.Settings.Default.RunAsCommand = Misc.GetRealPath(processSelected.MainModule.FileName);
|
|
|
|
RunWindow run = new RunWindow();
|
|
|
|
run.TopMost = this.TopMost;
|
|
run.ShowDialog();
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
private void launchAsThisUserProcessMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
RunWindow run = new RunWindow();
|
|
|
|
run.TopMost = this.TopMost;
|
|
run.UsePID(processSelectedPID);
|
|
run.ShowDialog();
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Injector
|
|
|
|
private void startProcessProcessMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
PromptBox box = new PromptBox();
|
|
|
|
box.TextBox.AutoCompleteSource = AutoCompleteSource.FileSystem;
|
|
box.TextBox.AutoCompleteMode = AutoCompleteMode.SuggestAppend;
|
|
|
|
if (box.ShowDialog() == DialogResult.OK)
|
|
{
|
|
ProcessStartInfo info = new ProcessStartInfo();
|
|
|
|
info.FileName = Application.StartupPath + "\\Injector.exe";
|
|
info.Arguments = "createprocessc " + processSelectedPID.ToString() + " \"" +
|
|
box.Value.Replace("\"", "\\\"") + "\"";
|
|
info.RedirectStandardOutput = true;
|
|
info.UseShellExecute = false;
|
|
info.CreateNoWindow = true;
|
|
|
|
Process p = Process.Start(info);
|
|
|
|
p.WaitForExit();
|
|
|
|
if (p.ExitCode != 0)
|
|
{
|
|
InformationBox infoBox = new InformationBox(p.StandardOutput.ReadToEnd() + "\r\nReturn code: " + p.ExitCode +
|
|
" (" + Win32.GetErrorMessage(p.ExitCode) + ")");
|
|
|
|
infoBox.ShowDialog();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void getCommandLineProcessMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
ProcessStartInfo info = new ProcessStartInfo();
|
|
|
|
info.FileName = Application.StartupPath + "\\Injector.exe";
|
|
info.Arguments = "cmdline " + processSelectedPID.ToString();
|
|
info.RedirectStandardOutput = true;
|
|
info.UseShellExecute = false;
|
|
info.CreateNoWindow = true;
|
|
|
|
Process p = Process.Start(info);
|
|
|
|
p.WaitForExit();
|
|
|
|
InformationBox infoBox = new InformationBox(p.StandardOutput.ReadToEnd() + (p.ExitCode != 0 ? "\r\nReturn code: " + p.ExitCode +
|
|
" (" + Win32.GetErrorMessage(p.ExitCode) + ")" : ""));
|
|
|
|
infoBox.ShowDialog();
|
|
}
|
|
|
|
private void exitProcessProcessMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
if (MessageBox.Show("Are you sure you want to terminate the selected process?", "Process Hacker",
|
|
MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button2) == DialogResult.No)
|
|
return;
|
|
|
|
ProcessStartInfo info = new ProcessStartInfo();
|
|
|
|
info.FileName = Application.StartupPath + "\\Injector.exe";
|
|
info.Arguments = "exitprocess " + processSelectedPID.ToString();
|
|
info.RedirectStandardOutput = true;
|
|
info.UseShellExecute = false;
|
|
info.CreateNoWindow = true;
|
|
|
|
Process p = Process.Start(info);
|
|
|
|
p.WaitForExit();
|
|
|
|
if (p.ExitCode != 0)
|
|
{
|
|
InformationBox infoBox = new InformationBox(p.StandardOutput.ReadToEnd() + "\r\nReturn code: " + p.ExitCode +
|
|
" (" + Win32.GetErrorMessage(p.ExitCode) + ")");
|
|
|
|
infoBox.ShowDialog();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Priority
|
|
|
|
private void realTimeMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
SetProcessPriority(ProcessPriorityClass.RealTime);
|
|
}
|
|
|
|
private void highMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
SetProcessPriority(ProcessPriorityClass.High);
|
|
}
|
|
|
|
private void aboveNormalMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
SetProcessPriority(ProcessPriorityClass.AboveNormal);
|
|
}
|
|
|
|
private void normalMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
SetProcessPriority(ProcessPriorityClass.Normal);
|
|
}
|
|
|
|
private void belowNormalMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
SetProcessPriority(ProcessPriorityClass.BelowNormal);
|
|
}
|
|
|
|
private void idleMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
SetProcessPriority(ProcessPriorityClass.Idle);
|
|
}
|
|
|
|
#endregion
|
|
|
|
private void searchProcessMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
Process.Start(Properties.Settings.Default.SearchEngine.Replace("%s",
|
|
treeProcesses.SelectedNodes[0].Name));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Process Hacker", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void selectAllProcessMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
Misc.SelectAll(treeProcesses.Tree.AllNodes);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Providers
|
|
|
|
public void processP_DictionaryAdded(ProcessItem item)
|
|
{
|
|
ProcessItem parent = new ProcessItem();
|
|
string parentText = "";
|
|
|
|
if (item.ParentPID != -1)
|
|
{
|
|
try
|
|
{
|
|
parent = processP.Dictionary[item.ParentPID];
|
|
|
|
parentText += " started by " + parent.Name + " (PID " + parent.PID.ToString() + ")";
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
this.QueueMessage("New Process: " + item.Name + " (PID " + item.PID.ToString() + ")" + parentText, item.Icon);
|
|
|
|
if (NPMenuItem.Checked)
|
|
notifyIcon.ShowBalloonTip(2000, "New Process",
|
|
"The process " + item.Name + " (" + item.PID.ToString() +
|
|
") was started" + ((parentText != "") ? " by " +
|
|
parent.Name + " (PID " + parent.PID.ToString() + ")" : "") + ".", ToolTipIcon.Info);
|
|
}
|
|
|
|
public void processP_DictionaryRemoved(ProcessItem item)
|
|
{
|
|
this.QueueMessage("Terminated Process: " + item.Name + " (PID " + item.PID.ToString() + ")", item.Icon);
|
|
|
|
if (processServices.ContainsKey(item.PID))
|
|
processServices.Remove(item.PID);
|
|
|
|
if (TPMenuItem.Checked)
|
|
notifyIcon.ShowBalloonTip(2000, "Terminated Process",
|
|
"The process " + item.Name + " (" + item.PID.ToString() + ") was terminated.", ToolTipIcon.Info);
|
|
}
|
|
|
|
public void serviceP_DictionaryAdded(ServiceItem item)
|
|
{
|
|
this.QueueMessage("New Service: " + item.Status.ServiceName +
|
|
" (" + item.Status.ServiceStatusProcess.ServiceType.ToString() + ")" +
|
|
((item.Status.DisplayName != "") ?
|
|
" (" + item.Status.DisplayName + ")" :
|
|
""), null);
|
|
|
|
if (NSMenuItem.Checked)
|
|
notifyIcon.ShowBalloonTip(2000, "New Service",
|
|
"The service " + item.Status.ServiceName + " (" + item.Status.DisplayName + ") has been created.",
|
|
ToolTipIcon.Info);
|
|
}
|
|
|
|
public void serviceP_DictionaryAdded_Process(ServiceItem item)
|
|
{
|
|
if (item.Status.ServiceStatusProcess.ProcessID != 0)
|
|
{
|
|
if (!processServices.ContainsKey(item.Status.ServiceStatusProcess.ProcessID))
|
|
processServices.Add(item.Status.ServiceStatusProcess.ProcessID, new List<string>());
|
|
|
|
processServices[item.Status.ServiceStatusProcess.ProcessID].Add(item.Status.ServiceName);
|
|
}
|
|
}
|
|
|
|
public void serviceP_DictionaryModified(ServiceItem oldItem, ServiceItem newItem)
|
|
{
|
|
Win32.SERVICE_STATE oldState = oldItem.Status.ServiceStatusProcess.CurrentState;
|
|
Win32.SERVICE_STATE newState = newItem.Status.ServiceStatusProcess.CurrentState;
|
|
|
|
if ((oldState == Win32.SERVICE_STATE.Paused || oldState == Win32.SERVICE_STATE.Stopped ||
|
|
oldState == Win32.SERVICE_STATE.StartPending) &&
|
|
newState == Win32.SERVICE_STATE.Running)
|
|
{
|
|
this.QueueMessage("Service Started: " + newItem.Status.ServiceName +
|
|
" (" + newItem.Status.ServiceStatusProcess.ServiceType.ToString() + ")" +
|
|
((newItem.Status.DisplayName != "") ?
|
|
" (" + newItem.Status.DisplayName + ")" :
|
|
""), null);
|
|
|
|
if (startedSMenuItem.Checked)
|
|
notifyIcon.ShowBalloonTip(2000, "Service Started",
|
|
"The service " + newItem.Status.ServiceName + " (" + newItem.Status.DisplayName + ") has been started.",
|
|
ToolTipIcon.Info);
|
|
}
|
|
|
|
if (oldState == Win32.SERVICE_STATE.Running &&
|
|
newState == Win32.SERVICE_STATE.Paused)
|
|
this.QueueMessage("Service Paused: " + newItem.Status.ServiceName +
|
|
" (" + newItem.Status.ServiceStatusProcess.ServiceType.ToString() + ")" +
|
|
((newItem.Status.DisplayName != "") ?
|
|
" (" + newItem.Status.DisplayName + ")" :
|
|
""), null);
|
|
|
|
if (oldState == Win32.SERVICE_STATE.Running &&
|
|
newState == Win32.SERVICE_STATE.Stopped)
|
|
{
|
|
this.QueueMessage("Service Stopped: " + newItem.Status.ServiceName +
|
|
" (" + newItem.Status.ServiceStatusProcess.ServiceType.ToString() + ")" +
|
|
((newItem.Status.DisplayName != "") ?
|
|
" (" + newItem.Status.DisplayName + ")" :
|
|
""), null);
|
|
|
|
if (stoppedSMenuItem.Checked)
|
|
notifyIcon.ShowBalloonTip(2000, "Service Stopped",
|
|
"The service " + newItem.Status.ServiceName + " (" + newItem.Status.DisplayName + ") has been stopped.",
|
|
ToolTipIcon.Info);
|
|
}
|
|
}
|
|
|
|
public void serviceP_DictionaryModified_Process(ServiceItem oldItem, ServiceItem newItem)
|
|
{
|
|
ServiceItem sitem = (ServiceItem)newItem;
|
|
|
|
if (sitem.Status.ServiceStatusProcess.ProcessID != 0)
|
|
{
|
|
if (!processServices.ContainsKey(sitem.Status.ServiceStatusProcess.ProcessID))
|
|
processServices.Add(sitem.Status.ServiceStatusProcess.ProcessID, new List<string>());
|
|
|
|
if (!processServices[sitem.Status.ServiceStatusProcess.ProcessID].Contains(
|
|
sitem.Status.ServiceName))
|
|
processServices[sitem.Status.ServiceStatusProcess.ProcessID].Add(sitem.Status.ServiceName);
|
|
|
|
processServices[sitem.Status.ServiceStatusProcess.ProcessID].Sort();
|
|
}
|
|
else
|
|
{
|
|
int oldId = ((ServiceItem)oldItem).Status.ServiceStatusProcess.ProcessID;
|
|
|
|
if (processServices.ContainsKey(oldId))
|
|
{
|
|
if (processServices[oldId].Contains(
|
|
sitem.Status.ServiceName))
|
|
processServices[oldId].Remove(sitem.Status.ServiceName);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void serviceP_DictionaryRemoved(ServiceItem item)
|
|
{
|
|
this.QueueMessage("Deleted Service: " + item.Status.ServiceName +
|
|
" (" + item.Status.ServiceStatusProcess.ServiceType.ToString() + ")" +
|
|
((item.Status.DisplayName != "") ?
|
|
" (" + item.Status.DisplayName + ")" :
|
|
""), null);
|
|
|
|
if (DSMenuItem.Checked)
|
|
notifyIcon.ShowBalloonTip(2000, "Service Deleted",
|
|
"The service " + item.Status.ServiceName + " (" + item.Status.DisplayName + ") has been deleted.",
|
|
ToolTipIcon.Info);
|
|
}
|
|
|
|
public void serviceP_DictionaryRemoved_Process(ServiceItem item)
|
|
{
|
|
if (item.Status.ServiceStatusProcess.ProcessID != 0)
|
|
{
|
|
if (processServices.ContainsKey(item.Status.ServiceStatusProcess.ProcessID))
|
|
{
|
|
if (processServices[item.Status.ServiceStatusProcess.ProcessID].Contains(
|
|
item.Status.ServiceName))
|
|
processServices[item.Status.ServiceStatusProcess.ProcessID].Remove(item.Status.ServiceName);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Service Context Menu
|
|
|
|
private void menuService_Popup(object sender, EventArgs e)
|
|
{
|
|
if (listServices.SelectedItems.Count == 0)
|
|
{
|
|
Misc.DisableAllMenuItems(menuService);
|
|
goToProcessServiceMenuItem.Visible = true;
|
|
startServiceMenuItem.Visible = true;
|
|
continueServiceMenuItem.Visible = true;
|
|
pauseServiceMenuItem.Visible = true;
|
|
stopServiceMenuItem.Visible = true;
|
|
|
|
selectAllServiceMenuItem.Enabled = true;
|
|
}
|
|
else if (listServices.SelectedItems.Count == 1)
|
|
{
|
|
Misc.EnableAllMenuItems(menuService);
|
|
|
|
goToProcessServiceMenuItem.Visible = true;
|
|
startServiceMenuItem.Visible = true;
|
|
continueServiceMenuItem.Visible = true;
|
|
pauseServiceMenuItem.Visible = true;
|
|
stopServiceMenuItem.Visible = true;
|
|
|
|
try
|
|
{
|
|
ServiceItem item = serviceP.Dictionary[listServices.SelectedItems[0].Name];
|
|
|
|
if (item.Status.ServiceStatusProcess.ProcessID != 0)
|
|
{
|
|
goToProcessServiceMenuItem.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
goToProcessServiceMenuItem.Enabled = false;
|
|
}
|
|
|
|
if ((item.Status.ServiceStatusProcess.ControlsAccepted & Win32.SERVICE_ACCEPT.PauseContinue)
|
|
== 0)
|
|
{
|
|
continueServiceMenuItem.Visible = false;
|
|
pauseServiceMenuItem.Visible = false;
|
|
}
|
|
else
|
|
{
|
|
continueServiceMenuItem.Visible = true;
|
|
pauseServiceMenuItem.Visible = true;
|
|
}
|
|
|
|
if (item.Status.ServiceStatusProcess.CurrentState == Win32.SERVICE_STATE.Paused)
|
|
{
|
|
startServiceMenuItem.Enabled = false;
|
|
pauseServiceMenuItem.Enabled = false;
|
|
}
|
|
else if (item.Status.ServiceStatusProcess.CurrentState == Win32.SERVICE_STATE.Running)
|
|
{
|
|
startServiceMenuItem.Enabled = false;
|
|
continueServiceMenuItem.Enabled = false;
|
|
}
|
|
else if (item.Status.ServiceStatusProcess.CurrentState == Win32.SERVICE_STATE.Stopped)
|
|
{
|
|
pauseServiceMenuItem.Enabled = false;
|
|
stopServiceMenuItem.Enabled = false;
|
|
}
|
|
|
|
if ((item.Status.ServiceStatusProcess.ControlsAccepted & Win32.SERVICE_ACCEPT.Stop) == 0 &&
|
|
item.Status.ServiceStatusProcess.CurrentState == Win32.SERVICE_STATE.Running)
|
|
{
|
|
stopServiceMenuItem.Enabled = false;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
Misc.DisableAllMenuItems(menuService);
|
|
copyServiceMenuItem.Enabled = true;
|
|
propertiesServiceMenuItem.Enabled = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Misc.DisableAllMenuItems(menuService);
|
|
|
|
goToProcessServiceMenuItem.Visible = false;
|
|
startServiceMenuItem.Visible = false;
|
|
continueServiceMenuItem.Visible = false;
|
|
pauseServiceMenuItem.Visible = false;
|
|
stopServiceMenuItem.Visible = false;
|
|
|
|
copyServiceMenuItem.Enabled = true;
|
|
propertiesServiceMenuItem.Enabled = true;
|
|
selectAllServiceMenuItem.Enabled = true;
|
|
}
|
|
|
|
if (listServices.List.Items.Count == 0)
|
|
selectAllServiceMenuItem.Enabled = false;
|
|
}
|
|
|
|
private void goToProcessServiceMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
DeselectAll(treeProcesses.Tree);
|
|
|
|
try
|
|
{
|
|
TreeNodeAdv node = treeProcesses.FindTreeNode(serviceP.Dictionary[
|
|
listServices.SelectedItems[0].Name].Status.ServiceStatusProcess.ProcessID);
|
|
|
|
node.IsSelected = true;
|
|
node.EnsureVisible();
|
|
|
|
tabControlBig.SelectedTab = tabProcesses;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
private void startServiceMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
using (Win32.ServiceHandle service = new Win32.ServiceHandle(
|
|
listServices.SelectedItems[0].Name, Win32.SERVICE_RIGHTS.SERVICE_ALL_ACCESS))
|
|
service.Start();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show("Error starting service:\n\n" + ex.Message, "Process Hacker",
|
|
MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void continueServiceMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
using (Win32.ServiceHandle service = new Win32.ServiceHandle(
|
|
listServices.SelectedItems[0].Name, Win32.SERVICE_RIGHTS.SERVICE_ALL_ACCESS))
|
|
service.Control(Win32.SERVICE_CONTROL.Continue);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show("Error continuing service:\n\n" + ex.Message, "Process Hacker",
|
|
MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void pauseServiceMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
using (Win32.ServiceHandle service = new Win32.ServiceHandle(
|
|
listServices.SelectedItems[0].Name, Win32.SERVICE_RIGHTS.SERVICE_ALL_ACCESS))
|
|
service.Control(Win32.SERVICE_CONTROL.Pause);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show("Error pausing service:\n\n" + ex.Message, "Process Hacker",
|
|
MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void stopServiceMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
using (Win32.ServiceHandle service = new Win32.ServiceHandle(
|
|
listServices.SelectedItems[0].Name, Win32.SERVICE_RIGHTS.SERVICE_ALL_ACCESS))
|
|
service.Control(Win32.SERVICE_CONTROL.Stop);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show("Error stopping service:\n\n" + ex.Message, "Process Hacker",
|
|
MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
private void deleteServiceMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
if (MessageBox.Show("Are you sure you want to delete the service '" +
|
|
listServices.SelectedItems[0].Name + "'?",
|
|
"Process Hacker",
|
|
MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button2) == DialogResult.Yes)
|
|
{
|
|
try
|
|
{
|
|
using (Win32.ServiceHandle service = new Win32.ServiceHandle(
|
|
listServices.SelectedItems[0].Name, Win32.SERVICE_RIGHTS.SERVICE_ALL_ACCESS))
|
|
service.Delete();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show("Error deleting service:\n\n" + ex.Message, "Process Hacker",
|
|
MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void propertiesServiceMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
List<string> selected = new List<string>();
|
|
ServiceWindow sw;
|
|
|
|
foreach (ListViewItem item in listServices.SelectedItems)
|
|
selected.Add(item.Name);
|
|
|
|
if (selected.Count == 1)
|
|
{
|
|
sw = new ServiceWindow(selected[0]);
|
|
}
|
|
else
|
|
{
|
|
sw = new ServiceWindow(selected.ToArray());
|
|
}
|
|
|
|
sw.TopMost = this.TopMost;
|
|
sw.ShowDialog();
|
|
}
|
|
|
|
private void selectAllServiceMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
Misc.SelectAll(listServices.Items);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Timers
|
|
|
|
private void timerFire_Tick(object sender, EventArgs e)
|
|
{
|
|
UpdateStatusInfo();
|
|
}
|
|
|
|
private void timerMessages_Tick(object sender, EventArgs e)
|
|
{
|
|
if (statusMessages.Count != 0)
|
|
{
|
|
KeyValuePair<string, Icon> v = statusMessages.Dequeue();
|
|
statusText.Text = v.Key;
|
|
|
|
if (v.Value != null)
|
|
statusIcon.Icon = v.Value;
|
|
else
|
|
statusIcon.Icon = null;
|
|
}
|
|
else
|
|
{
|
|
statusText.Text = "";
|
|
statusIcon.Icon = null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Form-related Helper functions
|
|
|
|
private void AddIcon(Icon icon)
|
|
{
|
|
imageList.Images.Add(icon);
|
|
}
|
|
|
|
private void AddListViewItem(ListView lv, string[] text)
|
|
{
|
|
ListViewItem item = new ListViewItem();
|
|
|
|
item.Text = text[0];
|
|
|
|
for (int i = 1; i < text.Length; i++)
|
|
{
|
|
item.SubItems.Add(new ListViewItem.ListViewSubItem(item, text[i]));
|
|
}
|
|
}
|
|
|
|
public void DeselectAll(ListView list)
|
|
{
|
|
foreach (ListViewItem item in list.SelectedItems)
|
|
item.Selected = false;
|
|
}
|
|
|
|
public void DeselectAll(TreeViewAdv tree)
|
|
{
|
|
foreach (TreeNodeAdv node in tree.AllNodes)
|
|
node.IsSelected = false;
|
|
}
|
|
|
|
private void LoadSettings()
|
|
{
|
|
RefreshInterval = Properties.Settings.Default.RefreshInterval;
|
|
this.Location = Properties.Settings.Default.WindowLocation;
|
|
this.Size = Properties.Settings.Default.WindowSize;
|
|
this.WindowState = Properties.Settings.Default.WindowState;
|
|
PromptBox.LastValue = Properties.Settings.Default.PromptBoxText;
|
|
|
|
ColumnSettings.LoadSettings(Properties.Settings.Default.ProcessTreeColumns, treeProcesses.Tree);
|
|
ColumnSettings.LoadSettings(Properties.Settings.Default.ServiceListViewColumns, listServices.List);
|
|
}
|
|
|
|
public void QueueMessage(string message)
|
|
{
|
|
this.QueueMessage(message, null);
|
|
}
|
|
|
|
public void QueueMessage(string message, Icon icon)
|
|
{
|
|
log.Add(DateTime.Now.ToString() + ": " + message);
|
|
statusMessages.Enqueue(new KeyValuePair<string,Icon>(message, icon));
|
|
}
|
|
|
|
private void SaveSettings()
|
|
{
|
|
Properties.Settings.Default.RefreshInterval = RefreshInterval;
|
|
|
|
if (this.WindowState == FormWindowState.Normal && this.Visible)
|
|
{
|
|
Properties.Settings.Default.WindowLocation = this.Location;
|
|
Properties.Settings.Default.WindowSize = this.Size;
|
|
}
|
|
|
|
Properties.Settings.Default.WindowState = this.WindowState == FormWindowState.Minimized ?
|
|
FormWindowState.Normal : this.WindowState;
|
|
|
|
Properties.Settings.Default.PromptBoxText = PromptBox.LastValue;
|
|
|
|
Properties.Settings.Default.ProcessTreeColumns = ColumnSettings.SaveSettings(treeProcesses.Tree);
|
|
Properties.Settings.Default.ServiceListViewColumns = ColumnSettings.SaveSettings(listServices.List);
|
|
|
|
Properties.Settings.Default.NewProcesses = NPMenuItem.Checked;
|
|
Properties.Settings.Default.TerminatedProcesses = TPMenuItem.Checked;
|
|
Properties.Settings.Default.NewServices = NSMenuItem.Checked;
|
|
Properties.Settings.Default.StartedServices = startedSMenuItem.Checked;
|
|
Properties.Settings.Default.StoppedServices = stoppedSMenuItem.Checked;
|
|
Properties.Settings.Default.DeletedServices = DSMenuItem.Checked;
|
|
|
|
try
|
|
{
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
public void SelectAll(TreeViewAdv tree)
|
|
{
|
|
foreach (TreeNodeAdv node in tree.AllNodes)
|
|
node.IsSelected = true;
|
|
}
|
|
|
|
private void UpdateStatusInfo()
|
|
{
|
|
statusGeneral.Text = string.Format("{0} processes", processP.Dictionary.Count);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helper functions
|
|
|
|
private bool IsDangerousPID(int pid)
|
|
{
|
|
if (pid == 4)
|
|
return true;
|
|
|
|
try
|
|
{
|
|
Process p = Process.GetProcessById(pid);
|
|
|
|
foreach (string s in Misc.DangerousNames)
|
|
{
|
|
if ((Environment.SystemDirectory + "\\" + s).ToLower() == Misc.GetRealPath(p.MainModule.FileName).ToLower())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
catch { }
|
|
|
|
return false;
|
|
}
|
|
|
|
private void SetProcessPriority(ProcessPriorityClass priority)
|
|
{
|
|
try
|
|
{
|
|
Process.GetProcessById(processSelectedPID).PriorityClass = priority;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show("The priority could not be set:\n\n" + ex.Message, "Process Hacker", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
private void formViewer_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
Properties.Settings.Default.AlwaysOnTop = this.TopMost;
|
|
|
|
processP.Kill();
|
|
serviceP.Kill();
|
|
|
|
notifyIcon.Visible = false;
|
|
|
|
SaveSettings();
|
|
|
|
// kill, just in case we are performing an operation we don't want random .net errors about disposed objects.
|
|
Process.GetCurrentProcess().Kill();
|
|
}
|
|
|
|
public HackerWindow()
|
|
{
|
|
InitializeComponent();
|
|
|
|
if (!System.IO.File.Exists(Application.StartupPath + "\\Assistant.exe"))
|
|
{
|
|
runAsMenuItem.Enabled = false;
|
|
runAsProcessMenuItem.Visible = false;
|
|
}
|
|
|
|
this.TopMost = Properties.Settings.Default.AlwaysOnTop;
|
|
HighlightedListViewItem.Colors[ListViewItemState.New] = Properties.Settings.Default.ColorNewProcesses;
|
|
HighlightedListViewItem.Colors[ListViewItemState.Removed] = Properties.Settings.Default.ColorRemovedProcesses;
|
|
TreeNodeAdv.StateColors[TreeNodeAdv.NodeState.New] = Properties.Settings.Default.ColorNewProcesses;
|
|
TreeNodeAdv.StateColors[TreeNodeAdv.NodeState.Removed] = Properties.Settings.Default.ColorRemovedProcesses;
|
|
|
|
Thread.CurrentThread.Priority = ThreadPriority.Highest;
|
|
|
|
notifyIcon.ContextMenu = menuIcon;
|
|
notifyIcon.Visible = Properties.Settings.Default.ShowIcon;
|
|
NPMenuItem.Checked = Properties.Settings.Default.NewProcesses;
|
|
TPMenuItem.Checked = Properties.Settings.Default.TerminatedProcesses;
|
|
NSMenuItem.Checked = Properties.Settings.Default.NewServices;
|
|
startedSMenuItem.Checked = Properties.Settings.Default.StartedServices;
|
|
stoppedSMenuItem.Checked = Properties.Settings.Default.StoppedServices;
|
|
DSMenuItem.Checked = Properties.Settings.Default.DeletedServices;
|
|
|
|
NPMenuItem.Click += new EventHandler(CheckedMenuItem_Click);
|
|
TPMenuItem.Click += new EventHandler(CheckedMenuItem_Click);
|
|
NSMenuItem.Click += new EventHandler(CheckedMenuItem_Click);
|
|
startedSMenuItem.Click += new EventHandler(CheckedMenuItem_Click);
|
|
stoppedSMenuItem.Click += new EventHandler(CheckedMenuItem_Click);
|
|
DSMenuItem.Click += new EventHandler(CheckedMenuItem_Click);
|
|
}
|
|
|
|
private void CheckedMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
((MenuItem)sender).Checked = !((MenuItem)sender).Checked;
|
|
}
|
|
|
|
private void serviceP_Updated()
|
|
{
|
|
listServices.List.EndUpdate();
|
|
HighlightedListViewItem.StateHighlighting = true;
|
|
|
|
serviceP.DictionaryAdded += new ServiceProvider.ProviderDictionaryAdded(serviceP_DictionaryAdded);
|
|
serviceP.DictionaryModified += new ServiceProvider.ProviderDictionaryModified(serviceP_DictionaryModified);
|
|
serviceP.DictionaryRemoved += new ServiceProvider.ProviderDictionaryRemoved(serviceP_DictionaryRemoved);
|
|
serviceP.Updated -= new ServiceProvider.ProviderUpdateOnce(serviceP_Updated);
|
|
|
|
if (processP.RunCount >= 1)
|
|
this.Invoke(new MethodInvoker(UpdateCommon));
|
|
}
|
|
|
|
private void processP_Updated()
|
|
{
|
|
processP.DictionaryAdded += new ProcessProvider.ProviderDictionaryAdded(processP_DictionaryAdded);
|
|
processP.DictionaryRemoved += new ProcessProvider.ProviderDictionaryRemoved(processP_DictionaryRemoved);
|
|
processP.Updated -= new ProcessProvider.ProviderUpdateOnce(processP_Updated);
|
|
|
|
if (processP.RunCount >= 1)
|
|
this.Invoke(new MethodInvoker(UpdateCommon));
|
|
}
|
|
|
|
private void UpdateCommon()
|
|
{
|
|
timerMessages.Enabled = true;
|
|
treeProcesses.RefreshItems();
|
|
}
|
|
|
|
private void HackerWindow_Load(object sender, EventArgs e)
|
|
{
|
|
Program.UpdateWindows();
|
|
|
|
timerFire.Interval = RefreshInterval;
|
|
timerFire.Enabled = true;
|
|
timerFire_Tick(null, null);
|
|
|
|
//listProcesses_SelectionChanged(null, null);
|
|
|
|
//newResultsWindowMenuItem.Click += new EventHandler(PerformSearch);
|
|
//literalSearchMenuItem.Click += new EventHandler(PerformSearch);
|
|
//regexSearchMenuItem.Click += new EventHandler(PerformSearch);
|
|
//stringScanMenuItem.Click += new EventHandler(PerformSearch);
|
|
//heapScanMenuItem.Click += new EventHandler(PerformSearch);
|
|
|
|
listControls.Add(treeProcesses.Tree);
|
|
listControls.Add(listServices);
|
|
|
|
GenericViewMenu.AddMenuItems(copyProcessMenuItem.MenuItems, treeProcesses.Tree);
|
|
GenericViewMenu.AddMenuItems(copyServiceMenuItem.MenuItems, listServices.List, null);
|
|
|
|
treeProcesses.ContextMenu = menuProcess;
|
|
listServices.ContextMenu = menuService;
|
|
|
|
processP.Interval = RefreshInterval;
|
|
treeProcesses.Provider = processP;
|
|
processP.Updated += new ProcessProvider.ProviderUpdateOnce(processP_Updated);
|
|
processP.Enabled = true;
|
|
|
|
HighlightedListViewItem.HighlightingDuration = Properties.Settings.Default.HighlightingDuration;
|
|
HighlightedListViewItem.StateHighlighting = false;
|
|
listServices.List.BeginUpdate();
|
|
serviceP.Interval = RefreshInterval;
|
|
listServices.Provider = serviceP;
|
|
serviceP.DictionaryAdded += new ServiceProvider.ProviderDictionaryAdded(serviceP_DictionaryAdded_Process);
|
|
serviceP.DictionaryModified += new ServiceProvider.ProviderDictionaryModified(serviceP_DictionaryModified_Process);
|
|
serviceP.DictionaryRemoved += new ServiceProvider.ProviderDictionaryRemoved(serviceP_DictionaryRemoved_Process);
|
|
serviceP.Updated += new ServiceProvider.ProviderUpdateOnce(serviceP_Updated);
|
|
serviceP.Enabled = true;
|
|
|
|
statusText.Text = "Waiting...";
|
|
|
|
LoadSettings();
|
|
|
|
// load symbols on a separate thread
|
|
Thread t = new Thread(new ThreadStart(delegate
|
|
{
|
|
foreach (ProcessModule module in Process.GetCurrentProcess().Modules)
|
|
{
|
|
this.BeginInvoke(new MethodInvoker(delegate
|
|
{
|
|
statusIcon.Icon = null;
|
|
statusText.Text = "Loading symbols for " + module.ModuleName + "...";
|
|
}));
|
|
|
|
try
|
|
{
|
|
if (!module.FileName.ToLower().EndsWith(".exe"))
|
|
Symbols.LoadSymbolsFromLibrary(module.FileName, module.BaseAddress.ToInt32());
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
QueueMessage("Could not load symbols for " + module.ModuleName + ": " + ex.Message, null);
|
|
}
|
|
}
|
|
|
|
this.BeginInvoke(new MethodInvoker(delegate
|
|
{
|
|
statusIcon.Icon = null;
|
|
statusText.Text = "";
|
|
}));
|
|
}));
|
|
|
|
t.Priority = ThreadPriority.Lowest;
|
|
t.Start();
|
|
}
|
|
|
|
private void HackerWindow_SizeChanged(object sender, EventArgs e)
|
|
{
|
|
if (this.WindowState == FormWindowState.Minimized)
|
|
{
|
|
if (this.NotifyIcon.Visible && Properties.Settings.Default.HideWhenMinimized)
|
|
{
|
|
this.Hide();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|