EduNetworkBuilder/EduNetworkBuilder/Network.cs

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");  //Do not translate this string "message"  It is an important word
            NetTitle = new LanguageStrings("title"); //Do not translate this string "title".  It is an important word
        }

        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(NB.Translate("N_MarkAsSolvedDone"),NB.Translate("N_MarkAsSolvedSolved"),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(NB.Translate("N_ProssPackOnceDbug"));
            }
            for(int loop=myPackets.Count -1; loop >=0; loop--)
            {
                //we delete if it has finished.
                if (myPackets[loop].DebugOn)
                    Console.WriteLine(NB.Translate("N_ProssPackOnceDbug"));
                if (myPackets[loop].TickTTL < 1)  //If the packet has been around too long, get rid of it
                {
                    myPackets[loop].AddMessage(DebugLevel.info, NB.Translate("N_ProssPackOnceTickCounter"));
                    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(string.Format(NB.Translate("N_ProssShouldContinSec"), Duration.TotalSeconds.ToString()));
                foreach (Packet pkt in myPackets)
                {
                    pkt.Tracking.AddMessage(DebugLevel.packet, NB.Translate("N_ProssShouldContinNet"), NB.Translate("N_ProssShouldContinTime"));
                    pkt.Tracking.Status = NB.Translate("N_ProssShouldContinTimeout");
                    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(NB.Translate("N_ProssPackDone"));
            }
            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();
                }
            }
        }
    }

}