1243 lines
45 KiB
C#
1243 lines
45 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Drawing;
|
|
using System.Windows.Forms;
|
|
using System.Xml;
|
|
using System.IO;
|
|
using System.Text.RegularExpressions;
|
|
|
|
|
|
namespace EduNetworkBuilder
|
|
{
|
|
/// <summary>
|
|
/// This is a whole network. LAN, WAN, Internet; everything combined
|
|
/// </summary>
|
|
public class Network
|
|
{
|
|
public string PuzzleName="";
|
|
public int myHeight = 1024;
|
|
public int myWidth = 1024;
|
|
public int Level = 0;
|
|
public double SortOrder = 0;
|
|
public bool ShowLabels = false;
|
|
public LanguageStrings NetMessage;
|
|
public LanguageStrings NetTitle;
|
|
List<NetworkComponent> NetComponents = new List<NetworkComponent>();
|
|
//should have background image
|
|
Image TheNetImage = new Bitmap(1024, 1024);
|
|
public int itemsize = 100; //The size of network components
|
|
PictureBox myPBox=null;
|
|
private int UniqueIdentifier = 100; //This gets used for all sorts of things. is auto-incremented every time someone asks for one
|
|
private List<Packet> myPackets = new List<Packet>();
|
|
private List<PacketMessage> myMessages = new List<PacketMessage>();
|
|
private bool _isDirty = false;
|
|
private IPAddress lastAddress = new IPAddress("0.0.0.0/24");
|
|
public string NetworkFilename = "";
|
|
public List<NetTest> NetTests = new List<NetTest>();
|
|
private bool AlreadyDisplayedMessage = false;
|
|
public NetTestVerbosity HintsToDisplay = NetTestVerbosity.none;
|
|
public NetTestVerbosity StartingHelpLevel = NetTestVerbosity.none;
|
|
public bool PuzzleIsSolved = true; //only set to false if we load a puzzle
|
|
public List<HelpTopics> SuggestedReadings = new List<HelpTopics>();
|
|
private DateTime NetworkStartTime = DateTime.Now;
|
|
private bool AlreadyChosenTimeout = false;
|
|
private int DefaultTimeout = 10;
|
|
private int NumberOfSecondsForTimeout = 10;
|
|
|
|
public Network(string Name)
|
|
{
|
|
TheNetImage = new Bitmap(myWidth, myHeight);
|
|
PuzzleName = Name;
|
|
NetMessage = new LanguageStrings("message");
|
|
NetTitle = new LanguageStrings("title");
|
|
}
|
|
|
|
private bool isDirty()
|
|
{
|
|
if (_isDirty) return true;
|
|
foreach (NetworkComponent nc in NetComponents)
|
|
{
|
|
if (nc.IsDirty) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
public void ClearComponents()
|
|
{
|
|
NetComponents.Clear();
|
|
}
|
|
public void ClearPackets()
|
|
{
|
|
myPackets.Clear();
|
|
}
|
|
public void ClearMessages()
|
|
{
|
|
myMessages.Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load the file from a xml resource
|
|
/// </summary>
|
|
public void Load()
|
|
{
|
|
Load(@"C:\Users\tyoung\Desktop\Test.enbx");
|
|
}
|
|
|
|
public void Load(string filename)
|
|
{
|
|
NetworkFilename = filename;
|
|
XmlDocument xmlDoc = new XmlDocument();
|
|
PuzzleName = Path.GetFileNameWithoutExtension(filename);
|
|
if (File.Exists(filename))
|
|
{
|
|
xmlDoc.Load(filename);
|
|
Load(xmlDoc,PuzzleName);
|
|
}
|
|
}
|
|
|
|
public void Load(XmlNode TheNode, string Name)
|
|
{
|
|
_isDirty = true;
|
|
NetworkDevice newND;
|
|
NetworkLink newNL;
|
|
int newUnique=-1;
|
|
PuzzleName = Name;
|
|
foreach (XmlNode Individual in TheNode.ChildNodes)
|
|
{
|
|
XmlNodeType myNodetype = Individual.NodeType;
|
|
if (myNodetype == XmlNodeType.Element)
|
|
{
|
|
switch (Individual.Name.ToLower())
|
|
{
|
|
case "edunetworkbuilder":
|
|
case "network":
|
|
Load(Individual,PuzzleName);
|
|
break;
|
|
case "showlabels":
|
|
bool.TryParse(Individual.InnerText, out ShowLabels);
|
|
break;
|
|
case "itemsize":
|
|
int.TryParse(Individual.InnerText, out itemsize);
|
|
break;
|
|
case "height":
|
|
int.TryParse(Individual.InnerText, out myHeight);
|
|
break;
|
|
case "width":
|
|
int.TryParse(Individual.InnerText, out myWidth);
|
|
break;
|
|
case "uniqueidentifier":
|
|
int.TryParse(Individual.InnerText, out UniqueIdentifier);
|
|
newUnique = UniqueIdentifier;
|
|
break;
|
|
case "link":
|
|
newNL = new NetworkLink(Individual);
|
|
NetComponents.Add(newNL);
|
|
break;
|
|
case "device":
|
|
newND = new NetworkDevice(Individual);
|
|
NetComponents.Add(newND);
|
|
break;
|
|
case "nettest":
|
|
NetTest nt = new NetTest(Individual);
|
|
NetTests.Add(nt);
|
|
break;
|
|
case "tag":
|
|
HelpTopics tempHelpTopic = NB.TryParseEnum<HelpTopics>(Individual.InnerText, HelpTopics.None);
|
|
if (tempHelpTopic != HelpTopics.None)
|
|
{
|
|
SuggestedReadings.Add(tempHelpTopic);
|
|
}
|
|
break;
|
|
case "level":
|
|
int.TryParse(Individual.InnerText, out Level);
|
|
//Tags.Add("Level_" + Individual.InnerText);
|
|
break;
|
|
case "sortorder":
|
|
double.TryParse(Individual.InnerText, out SortOrder);
|
|
break;
|
|
case "startinghelplevel":
|
|
StartingHelpLevel = NB.ParseEnum<NetTestVerbosity>(Individual.InnerText);
|
|
HintsToDisplay = StartingHelpLevel;
|
|
break;
|
|
default:
|
|
if(Regex.IsMatch(Individual.Name.ToLower(),"message"))
|
|
{
|
|
NetMessage.Add(Individual);
|
|
}
|
|
else
|
|
if (Regex.IsMatch(Individual.Name.ToLower(), "title"))
|
|
{
|
|
NetTitle.Add(Individual);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
DoAllVerifyLinks();
|
|
DoAllAutoJoin();
|
|
if (NetMessage.GetText() != "" && !AlreadyDisplayedMessage)
|
|
{
|
|
//We have a message loaded on this network. Display it
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin != null)
|
|
{
|
|
myWin.OpenNetHelpWindow();
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show(NetMessage.GetText(), NetTitle.GetText(), MessageBoxButtons.OK);
|
|
}
|
|
AlreadyDisplayedMessage = true;
|
|
}
|
|
if(NetTests.Count > 0)
|
|
PuzzleIsSolved = false; //When we load the puzzle.
|
|
|
|
if (newUnique != -1)
|
|
UniqueIdentifier = newUnique;
|
|
}
|
|
|
|
|
|
public void Save()
|
|
{
|
|
Save(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "Test.enbx"));
|
|
}
|
|
|
|
public void Save(string filename)
|
|
{
|
|
NetworkFilename = filename;
|
|
XmlWriterSettings settings = new XmlWriterSettings();
|
|
settings.Indent = true;
|
|
settings.NewLineOnAttributes = true;
|
|
XmlWriter writer = XmlWriter.Create(filename, settings);
|
|
|
|
//Now we write the file:
|
|
writer.WriteStartDocument();
|
|
writer.WriteStartElement("EduNetworkBuilder");
|
|
writer.WriteComment("This is a network file for EduNetworkBuilder.");
|
|
Save(writer);
|
|
writer.WriteEndElement();
|
|
writer.WriteEndDocument();
|
|
writer.Flush();
|
|
writer.Close();
|
|
}
|
|
|
|
|
|
public void Save(XmlWriter writer)
|
|
{
|
|
//Save the language name
|
|
//save the number of items
|
|
//Save all the items
|
|
writer.WriteStartElement("Network");
|
|
NetMessage.Save(writer);
|
|
NetTitle.Save(writer);
|
|
writer.WriteElementString("height", myHeight.ToString());
|
|
writer.WriteElementString("width", myWidth.ToString());
|
|
writer.WriteElementString("itemsize", itemsize.ToString());
|
|
writer.WriteElementString("showlabels", ShowLabels.ToString());
|
|
writer.WriteElementString("level", Level.ToString());
|
|
writer.WriteElementString("sortorder", SortOrder.ToString());
|
|
writer.WriteElementString("uniqueidentifier", UniqueIdentifier.ToString());
|
|
writer.WriteElementString("startinghelplevel", StartingHelpLevel.ToString());
|
|
//Save all the devices
|
|
for (int loop = 0; loop < NetComponents.Count; loop++)
|
|
{
|
|
if (NB.GetComponentType(NetComponents[loop]) == GeneralComponentType.device)
|
|
NetComponents[loop].Save(writer);
|
|
}
|
|
//Then save the links
|
|
for (int loop = 0; loop < NetComponents.Count; loop++)
|
|
{
|
|
if (NB.GetComponentType(NetComponents[loop]) == GeneralComponentType.link)
|
|
NetComponents[loop].Save(writer);
|
|
}
|
|
foreach(NetTest nt in NetTests)
|
|
{
|
|
nt.Save(writer);
|
|
}
|
|
foreach(HelpTopics HT in SuggestedReadings)
|
|
{
|
|
writer.WriteElementString("tag",HT.ToString());
|
|
}
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
public void UpdateDeviceSizes()
|
|
{
|
|
NetworkDevice nd;
|
|
foreach (NetworkComponent NC in NetComponents)
|
|
{
|
|
if (NB.GetComponentType(NC) == GeneralComponentType.device)
|
|
{
|
|
nd = (NetworkDevice)NC;
|
|
nd.SetSize(itemsize);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool MAC_Exists(string MAC)
|
|
{
|
|
foreach (NetworkComponent nc in NetComponents)
|
|
{
|
|
if (nc.HasMac(MAC)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void RegisterDisplayArea(PictureBox What)
|
|
{
|
|
myPBox = What;
|
|
}
|
|
|
|
public Point clickedPos(Point pixelClickedOn)
|
|
{
|
|
if (myPBox == null) return new Point(-1, -1);
|
|
double deltaX = (double)TheNetImage.Width / myPBox.Width;
|
|
double deltaY = (double)TheNetImage.Height / myPBox.Height;
|
|
Point Dest = new Point((int)(pixelClickedOn.X * deltaX), (int)(pixelClickedOn.Y * deltaY));
|
|
if (Dest.X > TheNetImage.Width) Dest = new Point(TheNetImage.Width, Dest.Y);
|
|
if (Dest.Y > TheNetImage.Height) Dest = new Point(Dest.X, TheNetImage.Height);
|
|
if (Dest.X <0) Dest = new Point(0, Dest.Y);
|
|
if (Dest.Y <0) Dest = new Point(Dest.X, 0);
|
|
|
|
return Dest;
|
|
}
|
|
|
|
public Point clickedPosCentered(Point pixelClickedOn)
|
|
{
|
|
Point NetPoint = clickedPos(pixelClickedOn);
|
|
int shift = (itemsize / 2);
|
|
Point Dest = new Point((int)(NetPoint.X - shift), (int)(NetPoint.Y - shift));
|
|
if (Dest.X + itemsize > TheNetImage.Width) Dest = new Point(TheNetImage.Width - itemsize, Dest.Y);
|
|
if (Dest.Y + itemsize > TheNetImage.Height) Dest = new Point(Dest.X, TheNetImage.Height - itemsize);
|
|
if (Dest.X < 0) Dest = new Point(0, Dest.Y);
|
|
if (Dest.Y < 0) Dest = new Point(Dest.X, 0);
|
|
return Dest;
|
|
}
|
|
|
|
public NetworkDevice ItemAtPosition(Point NetworkLocation)
|
|
{
|
|
NetworkDevice tDevice;
|
|
foreach (NetworkComponent tItem in NetComponents)
|
|
{
|
|
if (tItem.GetType().ToString() == "EduNetworkBuilder.NetworkDevice")
|
|
{
|
|
tDevice = (NetworkDevice)tItem;
|
|
if (tDevice.AtLocation(NetworkLocation))
|
|
return tDevice;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public NetworkDevice ItemFromName(string hostname)
|
|
{
|
|
NetworkDevice tDevice;
|
|
foreach (NetworkComponent tItem in NetComponents)
|
|
{
|
|
if (tItem.GetType().ToString() == "EduNetworkBuilder.NetworkDevice")
|
|
{
|
|
tDevice = (NetworkDevice)tItem;
|
|
if (tDevice.hostname == hostname)
|
|
return tDevice;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public bool HasItemCalled(string itemname)
|
|
{
|
|
NetworkDevice tDevice;
|
|
foreach(NetworkComponent tItem in NetComponents)
|
|
{
|
|
if(tItem.GetType().ToString() == "EduNetworkBuilder.NetworkDevice")
|
|
{
|
|
tDevice = (NetworkDevice)tItem;
|
|
if (tDevice.hostname == itemname) return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
public NetworkComponent AddItem(NetworkComponentType WhatType, Point location)
|
|
{
|
|
if (WhatType == NetworkComponentType.none) return null; //Do not put none in
|
|
if (WhatType == NetworkComponentType.link) return null; //We need to add links another way
|
|
string basename = WhatType.ToString();
|
|
int count=0;
|
|
while (HasItemCalled(basename + count))
|
|
count++;
|
|
|
|
Point newlocation = NB.GetSnapped(location);
|
|
|
|
NetworkComponent NewItem = new NetworkDevice(WhatType, basename + count, newlocation);
|
|
((NetworkDevice)NewItem).SetSize(itemsize);
|
|
|
|
NetComponents.Add(NewItem);
|
|
TestForCompletion(true);
|
|
myPBox.Invalidate(); //redraw the screen
|
|
return NewItem;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Search throuh all the network components and delete any links that are attacked to the specified nic.
|
|
/// </summary>
|
|
/// <param name="NicStr"></param>
|
|
public void RemoveLinksToNic(HostNicID NicID)
|
|
{
|
|
for(int looper=NetComponents.Count()-1; looper >=0; looper--)
|
|
{
|
|
if(NetComponents[looper].GetType().ToString() == "EduNetworkBuilder.NetworkLink")
|
|
{
|
|
NetworkLink nLink = (NetworkLink)NetComponents[looper];
|
|
if (nLink.HasLink(NicID))
|
|
{
|
|
nLink.Destroy();
|
|
NetComponents.RemoveAt(looper);
|
|
_isDirty = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public NetworkComponent AddItem(NetworkComponent ToAdd)
|
|
{
|
|
NetComponents.Add(ToAdd);
|
|
TestForCompletion(true);
|
|
return ToAdd;
|
|
}
|
|
public List<string> UnavailableNics()
|
|
{
|
|
NetworkLink myLink;
|
|
List<string> usedList = new List<string>();
|
|
foreach (NetworkComponent NC in NetComponents)
|
|
{
|
|
if (NC.GetType().ToString() == "EduNetworkBuilder.NetworkLink")
|
|
{
|
|
myLink = (NetworkLink)NC;
|
|
usedList.AddRange(myLink.UsedNicIDStrings());
|
|
}
|
|
}
|
|
return usedList;
|
|
}
|
|
|
|
public void RemoveComponent(NetworkComponent tItem)
|
|
{
|
|
for (int i = NetComponents.Count -1; i >= 0; i--)
|
|
{
|
|
if (NetComponents[i] == tItem)
|
|
NetComponents.RemoveAt(i);
|
|
// NetComponents.Remove(tItem);
|
|
}
|
|
tItem.Destroy();
|
|
_isDirty = true;
|
|
}
|
|
|
|
public void StoreLastIP(IPAddress ip)
|
|
{
|
|
lastAddress = ip;
|
|
}
|
|
|
|
public IPAddress RetrieveLastIP()
|
|
{
|
|
return lastAddress;
|
|
}
|
|
|
|
public List<string> GetTestMessages(string host)
|
|
{
|
|
string tString;
|
|
List<string> tMessages = new List<string>();
|
|
foreach(NetTest nt in NetTests)
|
|
{
|
|
if(nt.sHost == host && !nt.TestComplete())
|
|
{
|
|
tString = nt.GetDescription(HintsToDisplay);
|
|
if(tString != "")
|
|
tMessages.Add(tString);
|
|
}
|
|
}
|
|
return tMessages;
|
|
}
|
|
public List<string> GetIncompleteTestDestinations(string Source, bool forPing=true)
|
|
{
|
|
List<string> tDests = new List<string>();
|
|
foreach (NetTest nt in NetTests)
|
|
{
|
|
if (nt.sHost == Source && !nt.TestComplete())
|
|
{
|
|
if (forPing && (nt.TheTest == NetTestType.FailedPing || nt.TheTest == NetTestType.SuccessfullyPings))
|
|
tDests.Add(nt.dHost);
|
|
if (!forPing && nt.TheTest == NetTestType.SuccessfullyArps)
|
|
tDests.Add(nt.dHost);
|
|
}
|
|
}
|
|
return tDests;
|
|
}
|
|
|
|
public void TestForCompletion(bool report_as_done)
|
|
{
|
|
NetworkDevice TmpDevice;
|
|
bool PreviouslyUnsolved = !PuzzleIsSolved; //Only if we have an unsolved puzzle
|
|
int PuzzleCount = 0;
|
|
|
|
foreach (NetworkComponent nc in NetComponents)
|
|
{
|
|
if (NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
TmpDevice = (NetworkDevice)nc;
|
|
if (TmpDevice.BackgroundColor != Color.Empty)
|
|
{
|
|
TmpDevice.BackgroundColor = Color.Empty;
|
|
TmpDevice.IsDirty = true;
|
|
}
|
|
}
|
|
}
|
|
foreach (NetTest nt in NetTests)
|
|
{
|
|
if (nt.ColorItemsIfNeeded(HintsToDisplay != NetTestVerbosity.none)) //only change the color if we are not "none"
|
|
PuzzleCount++;
|
|
}
|
|
if (report_as_done && PuzzleCount == 0 && PreviouslyUnsolved)
|
|
{
|
|
//The puzzle was just solved
|
|
MarkAsSolved();
|
|
}
|
|
}
|
|
|
|
public void Print(PaintEventArgs e)
|
|
{
|
|
//we have the whole thing to print, and the display image already done
|
|
TestForCompletion(false);
|
|
if(isDirty() || _isDirty)
|
|
{
|
|
TheNetImage= new Bitmap(TheNetImage.Width, TheNetImage.Height);
|
|
//re-generate the image
|
|
//Do all the links first
|
|
foreach(NetworkComponent NC in NetComponents)
|
|
{
|
|
if (NC.GetType().ToString() == "EduNetworkBuilder.NetworkLink")
|
|
NC.Print(TheNetImage, false);
|
|
}
|
|
//Now, do all the devices
|
|
foreach (NetworkComponent NC in NetComponents)
|
|
{
|
|
if (NC.GetType().ToString() == "EduNetworkBuilder.NetworkDevice")
|
|
NC.Print(TheNetImage, ShowLabels);
|
|
}
|
|
}
|
|
if (myPackets.Count > 0)
|
|
{
|
|
Image tempNetImage = new Bitmap(TheNetImage);
|
|
foreach(Packet pkt in myPackets)
|
|
{
|
|
pkt.Print(tempNetImage); //Print all the packets over the network image
|
|
}
|
|
e.Graphics.DrawImage(tempNetImage, 0, 0, myPBox.Width, myPBox.Height);
|
|
tempNetImage.Dispose();
|
|
}
|
|
else
|
|
{
|
|
e.Graphics.DrawImage(TheNetImage, 0, 0, myPBox.Width, myPBox.Height);
|
|
}
|
|
_isDirty = false;
|
|
}
|
|
|
|
public void InvalidateEverything()
|
|
{
|
|
foreach(NetworkComponent nc in NetComponents)
|
|
{
|
|
nc.IsDirty = true;
|
|
}
|
|
}
|
|
|
|
public List<string> arp(UInt32 IP)
|
|
{
|
|
List<string> arps = new List<string>();
|
|
List<string> tlist;
|
|
foreach (NetworkComponent nc in NB.Randomize(NetComponents))
|
|
{
|
|
tlist = nc.arp(IP);
|
|
if (tlist.Count() > 0)
|
|
{
|
|
foreach (string mac in tlist)
|
|
{
|
|
arps.Add(mac);
|
|
}
|
|
}
|
|
}
|
|
return arps;
|
|
}
|
|
public int GetUniqueIdentifier()
|
|
{
|
|
return UniqueIdentifier++;
|
|
}
|
|
|
|
public void SortNetComponents()
|
|
{
|
|
NetComponents.Sort((x, y) => x.hostname.CompareTo(y.hostname));
|
|
}
|
|
|
|
public NetworkDevice HostMatchingHostNicID(HostNicID ToFind)
|
|
{
|
|
NetworkDevice tDevice;
|
|
//We cheat. the first portion of the host/nic ID is the host_id so we just find that
|
|
foreach (NetworkComponent nc in NetComponents)
|
|
{
|
|
if (NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
if (nc.GetUniqueIdentifier == ToFind.HostID)
|
|
{
|
|
tDevice = (NetworkDevice)nc;
|
|
return tDevice;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
/// <summary>
|
|
/// Search all the devices and make sure the one device is the only one that has the specified IP
|
|
/// </summary>
|
|
/// <param name="ToFind">The IP address to find</param>
|
|
/// <param name="Source">The device that has it</param>
|
|
/// <returns></returns>
|
|
public bool HasUniqueIP(IPAddress ToFind, NetworkDevice Source)
|
|
{
|
|
NetworkDevice ND;
|
|
foreach (NetworkComponent nc in NetComponents)
|
|
{
|
|
if (NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
ND = (NetworkDevice)nc;
|
|
if(ND != Source) //Skip the source
|
|
{
|
|
if (ND.HasIPAddress(ToFind))
|
|
return false; //Something has that IP
|
|
}
|
|
}
|
|
}
|
|
return true; //We did not find any device with that IP
|
|
}
|
|
|
|
public bool ItemIsCritical(string host)
|
|
{
|
|
foreach(NetTest nt in NetTests)
|
|
{
|
|
if (nt.dHost == host) return true;
|
|
if (nt.sHost == host) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool ItemIsCritical(HostNicID host)
|
|
{
|
|
NetworkDevice ND = GetDeviceFromID(host);
|
|
if (ND == null) return false; //cannot find it
|
|
foreach (NetTest nt in NetTests)
|
|
{
|
|
if (nt.dHost == ND.hostname) return true;
|
|
if (nt.sHost == ND.hostname) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool ItemIsLocked(string host, string dest, NetTestType WhatToCheck)
|
|
{
|
|
foreach (NetTest nt in NetTests)
|
|
{
|
|
if(nt.sHost == host)
|
|
{
|
|
if (nt.TheTest == NetTestType.LockAll)
|
|
return true;
|
|
if (WhatToCheck == nt.TheTest && dest == nt.dHost)
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void MarkAsSolved()
|
|
{
|
|
PuzzleIsSolved = true;
|
|
if (PuzzleName != "" && PuzzleName != null)
|
|
{
|
|
if (Properties.Settings.Default.ScoreList == null)
|
|
Properties.Settings.Default.ScoreList = new System.Collections.Specialized.StringCollection();
|
|
if (!Properties.Settings.Default.ScoreList.Contains(PuzzleName))
|
|
{
|
|
Properties.Settings.Default.ScoreList.Add(PuzzleName);
|
|
Properties.Settings.Default.Save();
|
|
}
|
|
}
|
|
DialogResult answer = MessageBox.Show("Solved! Would you like to open the puzzle box to go to the next puzzle? 'No' will let you continue to play with this one.","Solved",MessageBoxButtons.YesNo);
|
|
if(answer == DialogResult.Yes)
|
|
{
|
|
ListBoxWindow LBW = new ListBoxWindow();
|
|
LBW.ShowDialog();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// See if we have any tests that are supposed to check for packet arrival.
|
|
/// </summary>
|
|
/// <param name="packet_type">The type of packet that arrived</param>
|
|
/// <param name="sHost">The host it originated from</param>
|
|
/// <param name="dHost">The machine it went to</param>
|
|
public void NotePacketArrived(PacketType packet_type, NetworkDevice source, IPAddress sIP, IPAddress dIP)
|
|
{
|
|
string sHost = ReverseDNSLookup(source, sIP);
|
|
string dHost = ReverseDNSLookup(source, dIP);
|
|
foreach (NetTest nt in NetTests)
|
|
{
|
|
if (nt.TheTest == NetTestType.SuccessfullyArps && packet_type == PacketType.arp_answer && sHost == nt.sHost && dHost == nt.dHost)
|
|
nt.SetDone();
|
|
if (nt.TheTest == NetTestType.SuccessfullyDHCPs && packet_type == PacketType.dhcp_answer && sHost == nt.sHost && dHost == nt.dHost)
|
|
nt.SetDone();
|
|
if (nt.TheTest == NetTestType.SuccessfullyPings && packet_type == PacketType.ping_answer && sHost == nt.sHost && dHost == nt.dHost)
|
|
nt.SetDone();
|
|
if (nt.TheTest == NetTestType.SuccessfullyPings && packet_type == PacketType.ping_answer && sHost == nt.sHost && dHost == null && dIP != null && dIP.BroadcastAddress == dIP.GetIP && dIP.GetIPString == nt.dHost)
|
|
nt.SetDone();
|
|
}
|
|
}
|
|
|
|
public bool NoteActionDone(NetTestType theTest, string sHost, string dHost)
|
|
{
|
|
bool OldVal = false;
|
|
IPAddress sourceIP;
|
|
string sourceIPstring;
|
|
IPAddress destIP;
|
|
string destIPstring;
|
|
foreach (NetTest nt in NetTests)
|
|
{
|
|
sourceIP = new IPAddress(sHost);
|
|
sourceIPstring = ReverseDNSLookup(null, sourceIP); //this will either be an ip address or the host name
|
|
destIP = new IPAddress(dHost);
|
|
destIPstring = ReverseDNSLookup(null, destIP); //this will either be an ip address or the host name
|
|
if ((nt.TheTest == NetTestType.HelpRequest || nt.TheTest == NetTestType.FailedPing || nt.TheTest == NetTestType.ReadContextHelp) &&
|
|
(sHost == nt.sHost || sourceIPstring == nt.sHost) &&
|
|
(dHost == nt.dHost || destIPstring == nt.dHost))
|
|
{
|
|
OldVal = nt.TaskWasDone;
|
|
nt.SetDone();
|
|
if (nt.TaskWasDone != OldVal)
|
|
return true;
|
|
}
|
|
if (nt.TheTest == NetTestType.HelpRequest && sHost == "" && dHost == nt.dHost && dHost == "?Button")
|
|
{
|
|
OldVal = nt.TaskWasDone;
|
|
nt.SetDone();
|
|
if (nt.TaskWasDone != OldVal)
|
|
return true;
|
|
}
|
|
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public List<string> NetworkCardForHostList(string hostname, bool OnlyUnused = true, bool OnlyLinkable = false, NicType fromNIC = NicType.none)
|
|
{
|
|
List<string> theList = new List<string>();
|
|
NetworkDevice tDevice;
|
|
foreach (NetworkComponent nc in NetComponents)
|
|
{
|
|
if (nc.GetType().ToString() == "EduNetworkBuilder.NetworkDevice")
|
|
{
|
|
if(nc.hostname == hostname)
|
|
{
|
|
tDevice = (NetworkDevice)nc;
|
|
theList.AddRange(tDevice.NetworkCardStrings(OnlyUnused,OnlyLinkable, fromNIC));
|
|
}
|
|
}
|
|
}
|
|
return theList;
|
|
}
|
|
|
|
public List<string> GetMessageStrings()
|
|
{
|
|
List<string> themessages = new List<string>();
|
|
foreach (PacketMessage msg in myMessages)
|
|
{
|
|
themessages.AddRange(msg.GetMessagesSummary());
|
|
}
|
|
return themessages;
|
|
}
|
|
public int CountMessages()
|
|
{
|
|
return myMessages.Count();
|
|
}
|
|
public PacketMessage GetMessageAtIndex(int index)
|
|
{
|
|
if (index < 0 || index > myMessages.Count()) return null;
|
|
return myMessages[index];
|
|
}
|
|
|
|
public void addPacket(Packet toadd)
|
|
{
|
|
if(toadd != null && !myPackets.Contains(toadd))
|
|
myPackets.Add(toadd);
|
|
}
|
|
|
|
public int CountPackets(PacketType WhatType)
|
|
{
|
|
int count = 0;
|
|
foreach (Packet pkt in myPackets)
|
|
{
|
|
if (pkt.MyType == WhatType)
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
public void ProcessPacketsOnce()
|
|
{
|
|
foreach(Packet tpackets in myPackets.ToList())
|
|
{
|
|
if(tpackets != null)
|
|
tpackets.ProcessTick();
|
|
if (tpackets.DebugOn)
|
|
Console.WriteLine("Debugging");
|
|
}
|
|
for(int loop=myPackets.Count -1; loop >=0; loop--)
|
|
{
|
|
//we delete if it has finished.
|
|
if (myPackets[loop].DebugOn)
|
|
Console.WriteLine("Debugging");
|
|
if (myPackets[loop].TickTTL < 1) //If the packet has been around too long, get rid of it
|
|
{
|
|
myPackets[loop].AddMessage(DebugLevel.info, "Packet Tick Counter reached. Did the packet go into an infinite loop?");
|
|
myPackets[loop].PrepareToDelete();
|
|
myPackets.RemoveAt(loop);
|
|
}
|
|
else if (myPackets[loop].ready_to_delete)
|
|
{
|
|
myPackets[loop].PrepareToDelete();
|
|
myPackets.RemoveAt(loop);
|
|
}
|
|
}
|
|
GC.Collect();//Try to clean up memory.
|
|
myPackets = NB.Randomize(myPackets);
|
|
}
|
|
|
|
/// <summary>
|
|
/// This checks to see if there is any reason we should stop processing the packets
|
|
/// </summary>
|
|
/// <returns>true if we should continue, false if we should pause</returns>
|
|
public bool ProcessingShouldContinue()
|
|
{
|
|
TimeSpan Duration = DateTime.Now - NetworkStartTime;
|
|
NB.SetProgress(Duration.TotalSeconds, NumberOfSecondsForTimeout);
|
|
if (Duration.TotalSeconds > NumberOfSecondsForTimeout)
|
|
{
|
|
Console.WriteLine("Total seconds = " + Duration.TotalSeconds.ToString() + " Stopping.");
|
|
foreach (Packet pkt in myPackets)
|
|
{
|
|
pkt.Tracking.AddMessage(DebugLevel.packet, "Network", "The packet timed out.");
|
|
pkt.Tracking.Status = "The packet timed out and was dropped.";
|
|
pkt.MyStatus = PacketStatus.finished_failed;
|
|
pkt.PrepareToDelete();
|
|
}
|
|
ClearPackets();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void RegisterTimeOfArrival()
|
|
{
|
|
TimeSpan Duration = DateTime.Now - NetworkStartTime;
|
|
int MaxTime = (int)Duration.TotalSeconds + 2;
|
|
if(!AlreadyChosenTimeout)
|
|
{
|
|
NumberOfSecondsForTimeout = MaxTime * 2;
|
|
AlreadyChosenTimeout = true;
|
|
}
|
|
}
|
|
|
|
public void ProcessPackets()
|
|
{
|
|
AlreadyChosenTimeout = false; //we do this at the beginning of processing
|
|
NumberOfSecondsForTimeout = DefaultTimeout;
|
|
NetworkStartTime = DateTime.Now;
|
|
while(myPackets.Count > 0)
|
|
{
|
|
ProcessPacketsOnce();
|
|
if (!ProcessingShouldContinue())
|
|
{
|
|
|
|
//we need to break out for some reason
|
|
myPBox.Refresh();
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
myPBox.Refresh();
|
|
NB.Delay(5);
|
|
}
|
|
}
|
|
//remove any IP connection tracking info
|
|
NetworkDevice ND;
|
|
foreach(NetworkComponent nc in NetComponents)
|
|
{
|
|
if(NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
ND = (NetworkDevice)nc;
|
|
ND.ClearIPConnectionInfo();
|
|
}
|
|
}
|
|
DebugPausePoint WhatIsSet = NB.GetDebugPauseSetting();
|
|
if(WhatIsSet != 0)
|
|
{
|
|
Console.WriteLine("----All Done----");
|
|
}
|
|
TestForCompletion(true); //Now, report on the progress if we solved something in the middle of the packets going out
|
|
AlreadyChosenTimeout = false;
|
|
NB.SetProgress(0, NumberOfSecondsForTimeout);
|
|
}
|
|
|
|
public void AddMessage(PacketMessage toAdd)
|
|
{
|
|
//Only add this if it has not already been added
|
|
if(myMessages.IndexOf(toAdd) <0 )
|
|
{
|
|
myMessages.Add(toAdd);
|
|
}
|
|
}
|
|
|
|
public NetworkComponent GetComponentFromID(int TheID)
|
|
{
|
|
foreach(NetworkComponent nc in NetComponents)
|
|
{
|
|
if(nc.GetUniqueIdentifier == TheID)
|
|
{
|
|
return nc;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public NetworkLink GetLinkFromID(int TheID)
|
|
{
|
|
NetworkComponent nc = GetComponentFromID(TheID);
|
|
if (nc == null) return null;
|
|
if (nc.GetType().ToString() == "EduNetworkBuilder.NetworkLink")
|
|
return (NetworkLink)nc;
|
|
return null;
|
|
}
|
|
public NetworkDevice GetDeviceFromID(int ID)
|
|
{
|
|
NetworkComponent nc = GetComponentFromID(ID);
|
|
if (nc == null) return null;
|
|
if (nc.GetType().ToString() == "EduNetworkBuilder.NetworkDevice")
|
|
return (NetworkDevice)nc;
|
|
return null;
|
|
}
|
|
|
|
public NetworkDevice GetDeviceFromID(HostNicID LinkedNic)
|
|
{
|
|
return GetDeviceFromID(LinkedNic.HostID);
|
|
}
|
|
|
|
public NetworkDevice GetDeviceFromName(string DeviceName)
|
|
{
|
|
NetworkComponent nc = ItemFromName(DeviceName);
|
|
if (nc == null) return null;
|
|
if (NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
return (NetworkDevice)nc;
|
|
return null;
|
|
}
|
|
|
|
public List<string> GetHostnames(bool EvenNonNetworked = false)
|
|
{
|
|
List<string> tList = new List<string>();
|
|
NetworkDevice ND;
|
|
foreach(NetworkComponent NC in NetComponents)
|
|
{
|
|
if(NB.GetComponentType(NC) == GeneralComponentType.device)
|
|
{
|
|
ND = (NetworkDevice)NC;
|
|
if (!EvenNonNetworked && (ND.GetNetType() == NetworkComponentType.microwave || ND.GetNetType() == NetworkComponentType.fluorescent))
|
|
continue;
|
|
tList.Add(ND.hostname);
|
|
}
|
|
}
|
|
tList.Sort();
|
|
return tList;
|
|
}
|
|
|
|
public List<string> GetSubnets()
|
|
{
|
|
List<string> tList = new List<string>();
|
|
NetworkDevice ND;
|
|
List<string> subnets;
|
|
foreach (NetworkComponent NC in NetComponents)
|
|
{
|
|
if (NB.GetComponentType(NC) == GeneralComponentType.device)
|
|
{
|
|
ND = (NetworkDevice)NC;
|
|
subnets = ND.SubnetList();
|
|
foreach(string subnet in subnets)
|
|
{
|
|
if (!tList.Contains(subnet))
|
|
tList.Add(subnet);
|
|
}
|
|
}
|
|
}
|
|
tList.Sort();
|
|
return tList;
|
|
}
|
|
|
|
public List<string> GetBroadcasts()
|
|
{
|
|
List<string> tList = new List<string>();
|
|
NetworkDevice ND;
|
|
List<string> subnets;
|
|
foreach (NetworkComponent NC in NetComponents)
|
|
{
|
|
if (NB.GetComponentType(NC) == GeneralComponentType.device)
|
|
{
|
|
ND = (NetworkDevice)NC;
|
|
subnets = ND.BroadcastList();
|
|
foreach (string subnet in subnets)
|
|
{
|
|
if (!tList.Contains(subnet))
|
|
tList.Add(subnet);
|
|
}
|
|
}
|
|
}
|
|
tList.Sort();
|
|
return tList;
|
|
}
|
|
public void MarkAsLinked(HostNicID LinkedNic, int LinkID)
|
|
{
|
|
NetworkDevice nd = GetDeviceFromID(LinkedNic);
|
|
//If the host exists, now mark the nic
|
|
if(nd != null)
|
|
{
|
|
NetworkCard nic = nd.NicFromID(LinkedNic);
|
|
if(nic != null)
|
|
nic.ConnectedLink = LinkID;
|
|
}
|
|
}
|
|
public void MarkAsUnlinked(HostNicID LinkedNic, int LinkID)
|
|
{
|
|
NetworkDevice nd = GetDeviceFromID(LinkedNic);
|
|
//If the host exists, now mark the nic
|
|
if (nd != null)
|
|
{
|
|
NetworkCard nic = nd.NicFromID(LinkedNic);
|
|
if ((nic != null && nic.ConnectedLink == LinkID) || LinkID == -1)
|
|
{
|
|
nic.ConnectedLink = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
public IPAddress DNSLookup(NetworkDevice source, string toFind)
|
|
{
|
|
|
|
foreach(NetworkComponent nc in NB.Randomize(NetComponents))
|
|
{
|
|
NetworkDevice nd;
|
|
if(NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
nd = (NetworkDevice)nc;
|
|
if(nd.hostname == toFind)
|
|
{
|
|
IPAddress found = nd.BestIPForThis(source);
|
|
return found;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public string ReverseDNSLookup(NetworkDevice source, IPAddress toFind)
|
|
{
|
|
if (source != null && source.HasIPAddress(toFind))
|
|
return source.hostname; //if the host is 127.0.0.1 or something.
|
|
foreach (NetworkComponent nc in NB.Randomize(NetComponents))
|
|
{
|
|
NetworkDevice nd;
|
|
if (NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
nd = (NetworkDevice)nc;
|
|
if (nd.HasIPAddress(toFind))
|
|
return nd.hostname;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public bool DeviceIsOverDamaging(LinkType myLink, Point location)
|
|
{
|
|
NetworkDevice ND;
|
|
int countDistance = 25;
|
|
double HowFar;
|
|
foreach(NetworkComponent NC in NetComponents)
|
|
{
|
|
if (NB.GetComponentType(NC) == GeneralComponentType.device)
|
|
{
|
|
ND = (NetworkDevice)NC;
|
|
if(myLink == LinkType.wireless && ND.GetNetType() == NetworkComponentType.microwave)
|
|
{
|
|
HowFar = distance(location, ND.myLocation());
|
|
//Console.WriteLine("position=" + HowFar.ToString());
|
|
if (HowFar < countDistance)
|
|
if (HowFar < countDistance)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
if (myLink != LinkType.wireless && ND.GetNetType() == NetworkComponentType.fluorescent)
|
|
{
|
|
HowFar = distance(location, ND.myLocation());
|
|
//Console.WriteLine("position=" + HowFar.ToString());
|
|
if (HowFar < countDistance)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public double distance(Point start, Point dest)
|
|
{
|
|
return Math.Sqrt(Math.Pow((start.X - dest.X),2) + Math.Pow((start.Y - dest.Y),2)) / 5; //use grid size...
|
|
}
|
|
|
|
public double distance(NetworkDevice start, NetworkDevice dest)
|
|
{
|
|
if (start == null || dest == null) return 0;
|
|
return distance(start.myLocation(), dest.myLocation());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the closest wireless device we can connect to
|
|
/// </summary>
|
|
/// <param name="start"></param>
|
|
/// <returns></returns>
|
|
public NetworkCard BestWirelessLinkForDevice(NetworkCard start)
|
|
{
|
|
NetworkDevice starting = GetDeviceFromID(start.myID);
|
|
NetworkCard found = null;
|
|
NetworkDevice checking = null;
|
|
double l_distance = 10000;
|
|
if (starting == null) return null;
|
|
NetworkCard answer=null;
|
|
foreach(NetworkComponent nc in NetComponents)
|
|
{
|
|
if(NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
checking = (NetworkDevice)nc;
|
|
if (checking == starting) continue;
|
|
answer = checking.HasWPortSSIDKey(start.SSID, start.EncryptionKey);
|
|
if(answer != null)
|
|
{
|
|
double tdist = distance(starting, checking);
|
|
if(tdist < l_distance && tdist < NB.WirelessMaxUnsuccessfulLink)
|
|
{
|
|
l_distance = tdist;
|
|
found = answer;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
|
|
/****************************************
|
|
* Do On All Devices
|
|
* **************************************/
|
|
public void DoAllDHCP()
|
|
{
|
|
NetworkDevice nd;
|
|
foreach (NetworkComponent nc in NetComponents)
|
|
{
|
|
if(NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
nd = (NetworkDevice)nc;
|
|
nd.DHCPRequestFromHere();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool DoAllVerifyLinks()
|
|
{
|
|
NetworkLink nl;
|
|
bool didanything = false;
|
|
NetworkComponent nc;
|
|
for (int i = NetComponents.Count -1; i >= 0; i-- )
|
|
{
|
|
nc = NetComponents[i];
|
|
if (NB.GetComponentType(nc) == GeneralComponentType.link)
|
|
{
|
|
nl = (NetworkLink)nc;
|
|
didanything = nl.VerifyLinkIntegrity() || didanything;
|
|
}
|
|
}
|
|
return didanything;
|
|
}
|
|
|
|
public bool DoAllAutoJoin()
|
|
{
|
|
bool didanything = false;
|
|
NetworkDevice nd;
|
|
foreach (NetworkComponent nc in NetComponents.ToList())
|
|
{
|
|
if (NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
nd = (NetworkDevice)nc;
|
|
didanything = nd.AutoJoinWireless() || didanything;
|
|
}
|
|
}
|
|
|
|
return didanything;
|
|
}
|
|
|
|
public void DoAllClearArp()
|
|
{
|
|
NetworkDevice nd;
|
|
foreach (NetworkComponent nc in NetComponents)
|
|
{
|
|
if (NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
nd = (NetworkDevice)nc;
|
|
nd.ClearArps();
|
|
}
|
|
}
|
|
}
|
|
public void DoAllPing(IPAddress destination)
|
|
{
|
|
NetworkDevice nd;
|
|
foreach (NetworkComponent nc in NetComponents)
|
|
{
|
|
if (NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
nd = (NetworkDevice)nc;
|
|
nd.PingFromHere(destination);
|
|
}
|
|
}
|
|
}
|
|
public void DoAllClearIPs()
|
|
{
|
|
NetworkDevice nd;
|
|
foreach (NetworkComponent nc in NetComponents)
|
|
{
|
|
if (NB.GetComponentType(nc) == GeneralComponentType.device)
|
|
{
|
|
nd = (NetworkDevice)nc;
|
|
nd.ClearIPs();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|