748 lines
29 KiB
C#
748 lines
29 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Deployment.Application;
|
|
using System.Windows.Forms;
|
|
using System.Globalization;
|
|
using System.Resources;
|
|
using System.Xml;
|
|
using System.Drawing;
|
|
using System.Media;
|
|
using System.Reflection;
|
|
using System.Text.RegularExpressions;
|
|
|
|
|
|
namespace EduNetworkBuilder
|
|
{
|
|
public enum PacketStatus {
|
|
processing, //It is inside a device. It needs to be routed, masqueraded, or whatever
|
|
input, //It is hitting the interface/nic of a device.
|
|
output, //It is leaving a device. Make sure the mac address is what it should be & that we are going out the right link
|
|
waiting_for_arp, //It is in the output chain, has been procesed, but is waiting for an arp packet to give it the dest MAC
|
|
moving, //It is traveling along a link. We increment the distance it has gone and re-draw the packet.
|
|
encapsulated, //It has been put inside another packet.
|
|
finished_ok,//The packet has finished and is ready to be removed from the network
|
|
finished_failed, //The packet is finished (failed) and is ready to be removed from the network.
|
|
finished //There was an appropriate reason this packet finished. It stopped
|
|
}
|
|
public enum VLANTagType { Tagged, Untagged, Forbidden }
|
|
public enum LinkType { normal, wireless, broken }
|
|
public enum PacketType { none, ping_request, ping_answer, arp_request, arp_answer, dhcp_request, dhcp_answer, vpn_packet, tun_packet }
|
|
public enum ResponseToPacket { none, accept, masq, drop, reject }
|
|
public enum DebugLevel { none=0, info=1, routing=2, switching=4, natting=8, filtering=16, debug=32 , packet=64, all=127}
|
|
public enum NetworkComponentType { none, router, net_switch, net_hub, laptop, pc, server, wap ,
|
|
wrouter, wbridge, wrepeater, link, firewall, ip_phone, printer, copier, microwave, fluorescent, cellphone, tablet }
|
|
public enum NicType { none, lo, eth, wlan, wan, vpn, tun, management_interface, port, wport }
|
|
public enum IPAddressType { ip, gw, route, ip_only }
|
|
public enum nb_direction { none, to_src, to_dst }
|
|
public enum GeneralComponentType { none, link, device }
|
|
public enum NBSoundType { none, success, saved_ok, saved_failed }
|
|
public enum RTFWindowContents { help, about, release_notes }
|
|
public enum NetTestType { NeedsLocalIPTo, NeedsDefaultGW, NeedsLinkToDevice, NeedsRouteToNet,
|
|
NeedsUntaggedVLAN, NeedsTaggedVLAN, NeedsForbiddenVLAN,
|
|
SuccessfullyPings, SuccessfullyPingsAgain, SuccessfullyArps, SuccessfullyDHCPs, HelpRequest, ReadContextHelp, FailedPing,
|
|
DHCPServerEnabled,
|
|
LockAll, LockIP, LockRoute, LockNic, LockDHCP, LockGateway,
|
|
LockVLANsOnHost, LockNicVLAN, LockInterfaceVLAN, LockVLANNames,
|
|
}
|
|
public enum NetTestVerbosity { none, basic, hints, full }
|
|
public enum LBContents { routes, messages, dhcp, puzzles }
|
|
public enum HelpTopics {
|
|
None, DHCP, DHCPServer, Firewall, Gateway, Help, IPAddress, Link, Subnet, Ping,
|
|
VPN, Hub, Switch, ARP, StaticRoute, Subnetting, WhenToSubnet, ComparingAddresses, MACAddress,
|
|
Network, Packet, NIC, Interface, Router, PacketCorruption, GeneralWireless, WirelessSSID, WirelessKey,
|
|
WirelessAP, WirelessRouter, WirelessRepeater, WirelessBridge, VLAN
|
|
}
|
|
public enum FirewallRuleType { Allow, Drop }
|
|
public enum PuzzleNames
|
|
{
|
|
Level0_IP, Level1_NoGateway, Level0_NeedsLink, Level0_NoSwitch, Level1_BadDHCP, Level1_BadGateway,
|
|
Level0_SimpleDHCP, Level1_BadIP, Level0_Help, Level0_Ping, Level0_HubVsSwitch,
|
|
Level0_PacketCorruption1, Level0_PacketCorruption2, Level1_AddingDevices,
|
|
Level1_MidDHCP, Level1_OneNetTwoSubnets, Level1_DuplicateIPs, Level0_NetworkLoop, Level1_DuplicateMAC,
|
|
Level2_FirewallDemo, Level1_OneNetTwoSubnets2, Level2_VPN_Demo, Level2_Bad_VPN_IP, Level2_Bad_Encryption,
|
|
Level2_Bad_Route, Level2_Blast_From_Past, Level2_Not_Working, Level2_Build_A_VPN, Level2_Connect_The_Dots,
|
|
Level2_VPN_woes, Level2_FirewallTest2,
|
|
Level3_BlackHole, Level3_Busted, Level3_Middle_Man_Out, Level3_PhoneyNetwork, Level3_VPNify, Level3_EncryptionTroubles,
|
|
Level3_NowhereToGo, Level3_GrandCentralStation, Level3_Dead, Level0_NetworkLoop2, Level0_BrokenLink,
|
|
Level3_TwoDHCPServers,
|
|
Level4_DualWans, Level4_SinglesLife, Level4_SmallSubnets, Level4_OneRoute, Level4_RouterReplacement,
|
|
Level4_InternalSubnetting, Level4_Internalhemorrhage,
|
|
Level5_WirelessRouters, Level5_WirelessDevices, Level5_WirelessBridge, Level5_WirelessRepeater, Level5_WirelessRepeater2,
|
|
Level5_WirelessAccessPoint, Level5_WirelessCorruption, Level5_Failed, Level5_LostPacket, Level5_HereComesTrouble,
|
|
Level6_VLAN_Intro, Level6_VLAN_Intro2, Level6_Intro3_LockedOut, Level6_ForbiddenVLAN, Level6_TaggedBetweenSwitches,
|
|
Level6_VLANRouting, Level6_VLANRouting2, level6_UntaggedAndDHCP, Level6_SorryBoss, Level6_VLANFrustrations,
|
|
Level6_TwoAccessPoints, Level6_VlanRouting3, Level6_ConnectTheLaptop, Level6_CleanSlate, Level6_WhereFrom,
|
|
Level6_NeedVLANs, Level6_SwitchedUp,
|
|
|
|
}
|
|
public enum DebugPausePoint { none=0, packet_create=1, packet_kill=2,
|
|
packet_in=4, packet_out=8, packet_duplicate=16, all=63,
|
|
dump=256, pause=512}
|
|
|
|
|
|
[Serializable]
|
|
public struct HostNicID //This holds a unique identifier for a network card. Links use this to know what it is connected to
|
|
{
|
|
public int HostID;
|
|
public int NicID;
|
|
public string HostName;
|
|
public string NicName;
|
|
public HostNicID(int host, int nic, string hostname, string nicname)
|
|
{
|
|
HostID = host;
|
|
NicID = nic;
|
|
HostName = hostname;
|
|
NicName = nicname;
|
|
}
|
|
public HostNicID(XmlNode theNode)
|
|
{
|
|
HostID = 0;
|
|
NicID = 0;
|
|
HostName = "";
|
|
NicName = "";
|
|
foreach (XmlNode Individual in theNode.ChildNodes)
|
|
{
|
|
XmlNodeType myNodetype = Individual.NodeType;
|
|
if (myNodetype == XmlNodeType.Element)
|
|
{
|
|
switch (Individual.Name.ToLower())
|
|
{
|
|
case "hostid":
|
|
int.TryParse(Individual.InnerText, out HostID);
|
|
break;
|
|
case "nicid":
|
|
int.TryParse(Individual.InnerText, out NicID);
|
|
break;
|
|
case "hostname":
|
|
HostName = Individual.InnerText;
|
|
break;
|
|
case "nicname":
|
|
NicName = Individual.InnerText;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void Save(XmlWriter writer, string tag)
|
|
{
|
|
writer.WriteStartElement(tag);
|
|
writer.WriteElementString("hostid", HostID.ToString());
|
|
writer.WriteElementString("nicid", NicID.ToString());
|
|
writer.WriteElementString("hostname", HostName);
|
|
writer.WriteElementString("nicname", NicName);
|
|
writer.WriteEndElement();
|
|
}
|
|
public string HostNicIDString
|
|
{
|
|
get { return HostID.ToString()+"-"+NicID.ToString(); }
|
|
}
|
|
public bool Equals(HostNicID toCheck)
|
|
{
|
|
if (HostID != toCheck.HostID) return false;
|
|
if (NicID != toCheck.NicID) return false;
|
|
if (HostName != toCheck.HostName) return false;
|
|
if (NicName != toCheck.NicName) return false;
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
[Serializable]
|
|
public struct IPConnectionEntry
|
|
{
|
|
public IPAddress destIP; //where we are sending the packet to. We expect a response to come from here
|
|
public PacketType What; //ping, dhcp, etc
|
|
public ResponseToPacket Response; //accept, masq
|
|
public IPAddress internalIP; //Used if we are masquerading
|
|
public IPConnectionEntry(IPAddress dest, PacketType what, ResponseToPacket response)
|
|
{
|
|
destIP = dest;
|
|
What = what;
|
|
Response = response;
|
|
internalIP = null;
|
|
}
|
|
public IPConnectionEntry(IPAddress dest, PacketType what, ResponseToPacket response, IPAddress internal_ip)
|
|
{
|
|
destIP = dest;
|
|
What = what;
|
|
Response = response;
|
|
internalIP = internal_ip;
|
|
}
|
|
}
|
|
|
|
public class PingTestStatus
|
|
{
|
|
public string Source;
|
|
public string Dest;
|
|
public bool Succeeded = false;
|
|
}
|
|
|
|
[Serializable]
|
|
public struct ArpEntry
|
|
{
|
|
public string MACAddress;
|
|
public string IPAddr;
|
|
public HostNicID NicOnWhichItIsFound;
|
|
public ArpEntry(string mac, string ip, HostNicID thenic)
|
|
{
|
|
MACAddress = mac;
|
|
IPAddr = ip;
|
|
NicOnWhichItIsFound = thenic;
|
|
}
|
|
}
|
|
|
|
public class PuzzleInfo
|
|
{
|
|
public string PuzzleName;
|
|
public string PuzzleTitle;
|
|
public string PuzzleDescription;
|
|
public List<string> PuzzleTags = new List<string>();
|
|
public int Level=0;
|
|
public double SortOrder=0;
|
|
public void Load(XmlNode TheNode, string Name)
|
|
{
|
|
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 "message":
|
|
PuzzleDescription = Individual.InnerText;
|
|
break;
|
|
case "title":
|
|
PuzzleTitle = Individual.InnerText;
|
|
break;
|
|
case "tag":
|
|
PuzzleTags.Add(Individual.InnerText);
|
|
break;
|
|
case "level":
|
|
PuzzleTags.Add("Level_" + Individual.InnerText);
|
|
int.TryParse(Individual.InnerText, out Level);
|
|
break;
|
|
case "sortorder":
|
|
double.TryParse(Individual.InnerText, out SortOrder);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class FirewallRule
|
|
{
|
|
public string Source;
|
|
public string Destination;
|
|
public FirewallRuleType Action;
|
|
|
|
public FirewallRule(string source, string dest, FirewallRuleType action)
|
|
{
|
|
Source = source;
|
|
Destination = dest;
|
|
Action = action;
|
|
}
|
|
|
|
public FirewallRule(XmlNode theNode)
|
|
{
|
|
foreach (XmlNode Individual in theNode.ChildNodes)
|
|
{
|
|
XmlNodeType myNodetype = Individual.NodeType;
|
|
if (myNodetype == XmlNodeType.Element)
|
|
{
|
|
switch (Individual.Name.ToLower())
|
|
{
|
|
case "source":
|
|
Source = Individual.InnerText;
|
|
break;
|
|
case "destination":
|
|
Destination = Individual.InnerText;
|
|
break;
|
|
case "action":
|
|
Action = NB.ParseEnum<FirewallRuleType>(Individual.InnerText);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Save(XmlWriter writer, string tag)
|
|
{
|
|
writer.WriteStartElement(tag);
|
|
writer.WriteElementString("source", Source);
|
|
writer.WriteElementString("destination", Destination);
|
|
writer.WriteElementString("action", Action.ToString());
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
|
|
class NB
|
|
{
|
|
|
|
public static string BroadcastMACString = "FF:FF:FF:FF:FF:FF"; //The broadcast MAC address
|
|
public static string BroadcastIPString = "255.255.255.255"; //the generic broadcast IP address
|
|
public static string ZeroIPString = "0.0.0.0";
|
|
public static string LoopbackIPString = "127.0.0.1";
|
|
public static int LinkStep = 8;//The percentage of the link we move at each "tick"
|
|
public static int PacketPixelSize = 16; //The size of the packet pixel
|
|
public static int PacketVersionNum = 2; //2 uses the new stuff. Anything else uses the old stuff
|
|
public const int GridSize = 10;
|
|
public static string[,] LanguageChoices = { { NB.Translate("NB_NBEn"), "en" }, { NB.Translate("NB_NBFr"), "fr" } };
|
|
public static int WirelessMaxUnsuccessfulLink = 120; //The link will connect, but the packet will drop
|
|
public static int WirelessMaxSuccessfulLink = 100; //Packets will drop after this distance
|
|
public static int WirelessReconnectDistance = 70; //Try to find a closer AP if we are this far out.
|
|
public static int UntaggedVLAN = -1; //If the packet is not tagged.
|
|
public static int MaxPacketsBeforeOptimizing = 50;
|
|
|
|
/// <summary>
|
|
/// Find the global random number generator.
|
|
/// </summary>
|
|
/// <returns>A valid random number generator</returns>
|
|
public static Random GetRandom()
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return new Random();
|
|
if (myWin.GameRandomGen == null) return new Random();
|
|
return myWin.GameRandomGen;
|
|
}
|
|
/// <summary>
|
|
/// Find the global random number generator.
|
|
/// </summary>
|
|
/// <returns>A valid random number generator</returns>
|
|
public static CultureInfo GetCulture()
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
CultureInfo CI=null;
|
|
if (myWin != null)
|
|
{
|
|
CI = myWin.GetCulture();
|
|
}
|
|
if(CI == null || myWin == null)
|
|
{
|
|
string CL = Properties.Settings.Default.ChosenLanguage;
|
|
CI = CultureInfo.CreateSpecificCulture(CL);
|
|
}
|
|
return CI;
|
|
}
|
|
/// <summary>
|
|
/// Find the global random number generator.
|
|
/// </summary>
|
|
/// <returns>A valid random number generator</returns>
|
|
public static ResourceManager GetResource()
|
|
{
|
|
ResourceManager myresource = null;
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin != null)
|
|
{
|
|
myresource = myWin.GetResource();
|
|
}
|
|
if(myresource == null || myWin == null)
|
|
{
|
|
System.Reflection.Assembly MyAssembly;
|
|
MyAssembly = Assembly.GetCallingAssembly();
|
|
myresource = new ResourceManager("EduNetworkBuilder.Resources.languages.edustrings", MyAssembly);
|
|
}
|
|
return myresource;
|
|
}
|
|
|
|
public static Point GetSnapped(Point Location)
|
|
{
|
|
int x = (Location.X / NB.GridSize) * NB.GridSize;
|
|
int y = (Location.Y / NB.GridSize) * NB.GridSize;
|
|
Point newlocation = new Point(x, y);
|
|
return newlocation;
|
|
}
|
|
|
|
public static Network GetNetwork()
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return null;
|
|
if (myWin.GameRandomGen == null) return null;
|
|
return myWin.myNetwork;
|
|
}
|
|
public static void MarkToUpdate()
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return;
|
|
myWin.NeedsUpdate = true;
|
|
}
|
|
|
|
public static int nextPacketID()
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return 1; //return something.
|
|
return myWin.nextPacketID();
|
|
}
|
|
|
|
public static BuilderWindow GetBuilderWin()
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return null;
|
|
return myWin;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return a translated string in the current chosen language
|
|
/// </summary>
|
|
/// <param name="key">The key for the item we are translating</param>
|
|
/// <returns>A string of the translated information</returns>
|
|
public static string Translate(string key)
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null)
|
|
{
|
|
ResourceManager RM = GetResource();
|
|
CultureInfo CI = GetCulture();
|
|
string answer="";
|
|
answer = RM.GetString(key, CI);
|
|
if (answer == null) return "";
|
|
return answer;
|
|
}
|
|
return myWin.Translate(key);
|
|
}
|
|
|
|
public static string GetHelpTopicKey(HelpTopics What)
|
|
{
|
|
return "H_" + What.ToString() + "_Key";
|
|
}
|
|
public static string GetHelpTopicTitle(HelpTopics What)
|
|
{
|
|
return "H_" + What.ToString() + "_Title";
|
|
}
|
|
|
|
public static DebugPausePoint GetDebugPauseSetting()
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return DebugPausePoint.none;
|
|
if (myWin.GameRandomGen == null) return DebugPausePoint.none;
|
|
return myWin.DebugSetting;
|
|
}
|
|
|
|
public static PuzzleInfo GetPuzzleInfoFromName(string PuzzleName)
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return null;
|
|
return myWin.PuzzleInfoFromName(PuzzleName);
|
|
}
|
|
|
|
public static string LeftPad(string what, int amount=-1)
|
|
{
|
|
int UseAmount = 10;
|
|
if (amount != -1) UseAmount = amount;
|
|
string format = "{0," + (0 - UseAmount).ToString() + "}";
|
|
string mystring = string.Format(format, what);
|
|
return mystring;
|
|
}
|
|
|
|
public static void ChangeLanguage()
|
|
{
|
|
//Find the window. If it exists, use /set the language setting there. If not, use / set the default.
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
string lang = Properties.Settings.Default.ChosenLanguage;
|
|
if (lang == "") lang = "en";
|
|
|
|
string StartingItem = "";
|
|
for (int i = 0; i < LanguageChoices.GetLength(0); i++)
|
|
{
|
|
if (lang == LanguageChoices[i, 1])
|
|
{
|
|
StartingItem = LanguageChoices[i, 0];
|
|
}
|
|
}
|
|
|
|
|
|
//we need to choose a language:
|
|
Form LanguageForm = new Form();
|
|
LanguageForm.Text = NB.Translate("NB_ChangeLang1");
|
|
Label lblText = new Label();
|
|
lblText.Location = new Point(5, 5);
|
|
lblText.AutoSize = true;
|
|
lblText.Text = NB.Translate("NB_ChangeLang2");
|
|
LanguageForm.Icon = Properties.Resources.NBIco;
|
|
|
|
ComboBox cbQuestions = new ComboBox();
|
|
cbQuestions.Location = new Point(lblText.Location.X + lblText.Width + 10, lblText.Location.Y);
|
|
cbQuestions.Width = 60;
|
|
for (int i = 0; i < LanguageChoices.GetLength(0); i++ )
|
|
{
|
|
cbQuestions.Items.Add(LanguageChoices[i,0]);
|
|
}
|
|
if(cbQuestions.Items.Contains(StartingItem))
|
|
{
|
|
cbQuestions.SelectedItem = StartingItem;
|
|
}
|
|
else
|
|
cbQuestions.SelectedIndex = 0;
|
|
|
|
LanguageForm.Width = cbQuestions.Location.X + cbQuestions.Width + 70;
|
|
LanguageForm.Height = 90;
|
|
LanguageForm.AutoSize = true;
|
|
|
|
Button btnAccept = new Button();
|
|
btnAccept.Location = new Point(cbQuestions.Location.X, cbQuestions.Location.Y + cbQuestions.Height + 10);
|
|
btnAccept.Text = NB.Translate("_OK");
|
|
btnAccept.Click += (s, g) => { Button b = (Button)s; Form f = (Form)b.Parent; f.Close(); };
|
|
|
|
LanguageForm.Controls.Add(lblText);
|
|
LanguageForm.Controls.Add(cbQuestions);
|
|
LanguageForm.Controls.Add(btnAccept);
|
|
|
|
LanguageForm.ShowDialog();
|
|
if (cbQuestions.SelectedIndex >= 0)
|
|
{
|
|
Properties.Settings.Default.LanguageHasBeenChosen = true;
|
|
string mychoice = LanguageChoices[cbQuestions.SelectedIndex, 1];
|
|
if (myWin == null)
|
|
{
|
|
Properties.Settings.Default.ChosenLanguage = mychoice;
|
|
//Properties.Settings.Default.Save(); //We do this when we exit. No need to save it right this instant.
|
|
}
|
|
else
|
|
{
|
|
myWin.ChosenLanguage = mychoice;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static void PlaySound(NBSoundType What)
|
|
{
|
|
SoundPlayer sndClick;
|
|
switch (What)
|
|
{
|
|
case NBSoundType.none:
|
|
break;
|
|
case NBSoundType.success:
|
|
sndClick = new SoundPlayer(Properties.Resources.wavBellDing);
|
|
sndClick.Play();
|
|
break;
|
|
case NBSoundType.saved_failed:
|
|
sndClick = new SoundPlayer(Properties.Resources.noBeep);
|
|
sndClick.Play();
|
|
break;
|
|
case NBSoundType.saved_ok:
|
|
sndClick = new SoundPlayer(Properties.Resources.click);
|
|
sndClick.Play();
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
public static List<string> GetPuzzleTags()
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return null;
|
|
return myWin.GetPuzzleTags();
|
|
}
|
|
|
|
public static bool PuzzleLevelHasUnsolved(string LevelName)
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return false;
|
|
return myWin.PuzzleLevelHasUnsolved(LevelName);
|
|
}
|
|
|
|
public static List<string> GetPuzzleNames()
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return null;
|
|
return myWin.GetPuzzleNames();
|
|
}
|
|
|
|
public static void LoadNetworkFromResource(string resource)
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return;
|
|
myWin.LoadNetworkFromResource(resource);
|
|
}
|
|
|
|
public static void SetProgress(double HowFar, double total)
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return;
|
|
myWin.SetProgress(HowFar, total);
|
|
}
|
|
|
|
public static void UpdateMessages()
|
|
{
|
|
BuilderWindow myWin = (BuilderWindow)Application.OpenForms["BuilderWindow"];
|
|
if (myWin == null) return;
|
|
myWin.UpdateMessages();
|
|
}
|
|
|
|
public static int GetUniqueIdentifier()
|
|
{
|
|
Network myNet = GetNetwork();
|
|
if(myNet == null)
|
|
{
|
|
//We should never get here. If so, we are in a bad sort of way.
|
|
Random rnd = GetRandom();
|
|
return rnd.Next(1,100);
|
|
}
|
|
return myNet.GetUniqueIdentifier();
|
|
}
|
|
|
|
public static void Delay(int amount)
|
|
{
|
|
System.Threading.Thread.Sleep(amount);
|
|
}
|
|
|
|
public static T ParseEnum<T>(string value)
|
|
{
|
|
// Do not initialize this variable here.
|
|
return (T)Enum.Parse(typeof(T), value, true);
|
|
}
|
|
|
|
public static T TryParseEnum<T>(string value, T Default )
|
|
{
|
|
if (!Enum.IsDefined(typeof(T), value))
|
|
return Default;
|
|
|
|
return (T)Enum.Parse(typeof(T), value);
|
|
}
|
|
|
|
public static GeneralComponentType GetComponentType(NetworkComponent What)
|
|
{
|
|
GeneralComponentType theType = GeneralComponentType.none;
|
|
if(What.GetType().ToString() == "EduNetworkBuilder.NetworkDevice")
|
|
theType = GeneralComponentType.device;
|
|
if (What.GetType().ToString() == "EduNetworkBuilder.NetworkLink")
|
|
theType = GeneralComponentType.link;
|
|
return theType;
|
|
}
|
|
|
|
public static void ReadContextHelp(HelpTopics What)
|
|
{
|
|
RTFWindow tForm = null;
|
|
//make a new window if needed
|
|
foreach(Form myfrm in Application.OpenForms)
|
|
{
|
|
if(myfrm.Name == NB.Translate("NB_RdCtxtHelp"))
|
|
{
|
|
//We have a context window
|
|
tForm = (RTFWindow)myfrm;
|
|
break;
|
|
}
|
|
}
|
|
if(tForm == null)
|
|
{
|
|
//We do not have one yet. Make a new one
|
|
tForm = new RTFWindow(RTFWindowContents.help);
|
|
tForm.Name = NB.Translate("NB_RdCtxtHelp");
|
|
}
|
|
//load help
|
|
tForm.Show();
|
|
//Jump to the correct location
|
|
if(tForm != null)
|
|
{
|
|
tForm.JumpToSelection(What);
|
|
}
|
|
}
|
|
|
|
public static string GenerateMACAddress()
|
|
{
|
|
var sBuilder = new StringBuilder();
|
|
var random = GetRandom();
|
|
int number;
|
|
byte b;
|
|
for (int i = 0; i < 6; i++)
|
|
{
|
|
number = random.Next(0, 255);
|
|
b = Convert.ToByte(number);
|
|
if (i == 0)
|
|
{
|
|
b = setBit(b, 6); //--> set locally administered
|
|
b = unsetBit(b, 7); // --> set unicast
|
|
}
|
|
sBuilder.Append(number.ToString("X2"));
|
|
}
|
|
string mac= sBuilder.ToString().ToUpper();
|
|
if (MAC_Exists(mac))
|
|
return GenerateMACAddress(); //If it already exists, generate another
|
|
return mac;
|
|
}
|
|
|
|
public static bool MAC_Exists(string MAC)
|
|
{
|
|
Network myNet = GetNetwork();
|
|
if(myNet == null) return false;
|
|
return myNet.MAC_Exists(MAC);
|
|
}
|
|
|
|
public static List<string> arp(UInt32 IP)
|
|
{
|
|
List<string> arps = new List<string>();
|
|
Network myNet = GetNetwork();
|
|
if (myNet == null) return arps;
|
|
return myNet.arp(IP);
|
|
}
|
|
|
|
private static byte setBit(byte b, int BitNumber)
|
|
{
|
|
if (BitNumber < 8 && BitNumber > -1)
|
|
{
|
|
return (byte)(b | (byte)(0x01 << BitNumber));
|
|
}
|
|
else
|
|
{
|
|
throw new InvalidOperationException(
|
|
string.Format(NB.Translate("NB_BitError"), BitNumber.ToString()));
|
|
}
|
|
}
|
|
|
|
private static byte unsetBit(byte b, int BitNumber)
|
|
{
|
|
if (BitNumber < 8 && BitNumber > -1)
|
|
{
|
|
return (byte)(b | (byte)(0x00 << BitNumber));
|
|
}
|
|
else
|
|
{
|
|
throw new InvalidOperationException(
|
|
string.Format(NB.Translate("NB_BitError"), BitNumber.ToString()));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Randomize a list
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of list to return</typeparam>
|
|
/// <param name="list">The list to randomize</param>
|
|
/// <returns>a new list that is randomized</returns>
|
|
public static List<T> Randomize<T>(List<T> list)
|
|
{
|
|
|
|
List<T> randomizedList = new List<T>(list);
|
|
Random rnd = GetRandom();
|
|
int n = randomizedList.Count;
|
|
int counter = 0;
|
|
T value;
|
|
while (n > 1)
|
|
{
|
|
n--;
|
|
int k = rnd.Next(n + 1);
|
|
value = randomizedList[k];
|
|
randomizedList[k] = randomizedList[n];
|
|
randomizedList[n] = value;
|
|
counter++;
|
|
if (counter > 10)
|
|
{
|
|
counter = 0;
|
|
}
|
|
}
|
|
return randomizedList;
|
|
}
|
|
|
|
}
|
|
}
|