private void CheckValid(IPAddress ipaDestination, IPAddress ipaNextHop, Subnetmask bSubnetMask)
{
if (ipaDestination.AddressFamily != ipaNextHop.AddressFamily || ipaDestination.AddressFamily != bSubnetMask.AddressFamily)
{
throw new ArgumentException("Cannot mix up addresses of a different type into one routing entry.");
}
}
private void CalculateIPv4SubnetAction()
{
IsDetailsVisible = false;
string[] subnet = Subnet.Trim().Split('/');
string subnetmask = subnet[1];
// Convert CIDR to subnetmask
if (subnetmask.Length < 3)
{
subnetmask = Subnetmask.GetFromCidr(int.Parse(subnet[1])).Subnetmask;
}
SubnetInfo subnetInfo = Models.Network.Subnet.CalculateIPv4Subnet(IPAddress.Parse(subnet[0]), IPAddress.Parse(subnetmask));
DetailsNetworkAddress = subnetInfo.NetworkAddress;
DetailsBroadcast = subnetInfo.Broadcast;
DetailsSubnetmask = subnetInfo.Subnetmask;
DetailsCIDR = subnetInfo.CIDR;
DetailsIPAddresses = subnetInfo.IPAddresses;
DetailsFirstIPAddress = subnetInfo.HostFirstIP;
DetailsLastIPAddress = subnetInfo.HostLastIP;
DetailsHosts = subnetInfo.Hosts;
IsDetailsVisible = true;
SubnetHistory = new List <string>(HistoryListHelper.Modify(SubnetHistory, Subnet, SettingsManager.Current.Application_HistoryListEntries));
}
private bool Match(IPAddress ipa1, IPAddress ipa2, Subnetmask sWildcard)
{
if (ipa2 == null || ipa1 == null)
{
return(true); //Any
}
if (ipa1.AddressFamily != ipa2.AddressFamily)
{
return(false); //Wrong address type.
}
if (sWildcard == null)
{
return(ipa1.Equals(ipa2)); //No wildcard
}
if (ipa1.AddressFamily != sWildcard.AddressFamily)
{
return(false); //Wrong address type.
}
byte[] bAddress1 = ipa1.GetAddressBytes();
byte[] bAddress2 = ipa2.GetAddressBytes();
byte[] bWildcard = sWildcard.MaskBytes;
bool bMatch = true;
for (int iC1 = 0; iC1 < bAddress1.Length; iC1++)
{
if ((bAddress1[iC1] & (~bWildcard[iC1])) != (bAddress2[iC1] & (~bWildcard[iC1])))
{
bMatch = false;
}
}
return(bMatch);
}
private void CalculateIPv4SubnetAction()
{
IsDetailsVisible = false;
string[] subnet = Subnet.Trim().Split('/');
string subnetmask = subnet[1];
// Convert CIDR to subnetmask
if (subnetmask.Length < 3)
{
subnetmask = Subnetmask.GetFromCidr(int.Parse(subnet[1])).Subnetmask;
}
SubnetInfo subnetInfo = Models.Network.Subnet.CalculateIPv4Subnet(IPAddress.Parse(subnet[0]), IPAddress.Parse(subnetmask));
DetailsNetworkAddress = subnetInfo.NetworkAddress;
DetailsBroadcast = subnetInfo.Broadcast;
DetailsSubnetmask = subnetInfo.Subnetmask;
DetailsCIDR = subnetInfo.CIDR;
DetailsIPAddresses = subnetInfo.IPAddresses;
DetailsFirstIPAddress = subnetInfo.HostFirstIP;
DetailsLastIPAddress = subnetInfo.HostLastIP;
DetailsHosts = subnetInfo.Hosts;
IsDetailsVisible = true;
AddSubnetToHistory(Subnet);
}
/// <summary>
/// Returns the classfull subnet mask of a given IPv4 network
/// </summary>
/// <param name="ipa">The network to get the classfull subnetmask for</param>
/// <returns>The classfull subnet mask of a given IPv4 network</returns>
public static Subnetmask GetClassfullSubnetMask(IPAddress ipa)
{
if (ipa.AddressFamily != AddressFamily.InterNetwork)
{
throw new ArgumentException("Only IPv4 addresses are supported for classfull address calculations.");
}
IPv4AddressClass ipv4Class = GetClass(ipa);
Subnetmask sm = new Subnetmask();
if (ipv4Class == IPv4AddressClass.A)
{
sm.MaskBytes[0] = 255;
}
if (ipv4Class == IPv4AddressClass.B)
{
sm.MaskBytes[0] = 255;
sm.MaskBytes[1] = 255;
}
if (ipv4Class == IPv4AddressClass.C)
{
sm.MaskBytes[0] = 255;
sm.MaskBytes[1] = 255;
sm.MaskBytes[2] = 255;
}
return(sm);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (DesignerProperties.GetIsInDesignMode(new DependencyObject()))
{
return("-/-");
}
if (!(value is Tuple <IPAddress, IPAddress>[] ipAddresses))
{
return("-/-");
}
var result = string.Empty;
foreach (var ipAddr in ipAddresses)
{
if (!string.IsNullOrEmpty(result))
{
result += Environment.NewLine;
}
result += ipAddr.Item1.ToString() + "/" + Subnetmask.ConvertSubnetmaskToCidr(ipAddr.Item2);
}
return(result);
}
public override TrafficSplitterRule Create(NameValueItem nviConfigurationRoot)
{
IPAddressRule ipaRule = new IPAddressRule();
ipaRule.Action = ConvertToAction(nviConfigurationRoot.GetChildsByName("action")[0]);
if (nviConfigurationRoot.ContainsChildItem("address"))
{
ipaRule.Address = IPAddress.Parse(nviConfigurationRoot["address"][0].Value);
}
if (nviConfigurationRoot.ContainsChildItem("wildcard"))
{
ipaRule.Wildcard = Subnetmask.Parse(nviConfigurationRoot["wildcard"][0].Value);
}
if (nviConfigurationRoot.ContainsChildItem("destinationAddress"))
{
ipaRule.Destination = IPAddress.Parse(nviConfigurationRoot["destinationAddress"][0].Value);
}
if (nviConfigurationRoot.ContainsChildItem("sourceAddress"))
{
ipaRule.Source = IPAddress.Parse(nviConfigurationRoot["sourceAddress"][0].Value);
}
if (nviConfigurationRoot.ContainsChildItem("destinationWildcard"))
{
ipaRule.DestinationWildcard = Subnetmask.Parse(nviConfigurationRoot["destinationWildcard"][0].Value);
}
if (nviConfigurationRoot.ContainsChildItem("sourceWildcard"))
{
ipaRule.SourceWildcard = Subnetmask.Parse(nviConfigurationRoot["sourceWildcard"][0].Value);
}
return(ipaRule);
}
private async void AddProfileAction()
{
MetroDialogSettings settings = AppearanceManager.MetroDialog;
settings.AffirmativeButtonText = Application.Current.Resources["String_Button_Add"] as string;
settings.NegativeButtonText = Application.Current.Resources["String_Button_Cancel"] as string;
string name = await dialogCoordinator.ShowInputAsync(this, Application.Current.Resources["String_Header_AddProfile"] as string, Application.Current.Resources["String_EnterNameForProfile"] as string, settings);
if (string.IsNullOrEmpty(name))
{
return;
}
string configSubnetmask = ConfigSubnetmaskOrCidr;
if (ConfigEnableStaticIPAddress && ConfigSubnetmaskOrCidr.StartsWith("/"))
{
configSubnetmask = Subnetmask.GetFromCidr(int.Parse(ConfigSubnetmaskOrCidr.TrimStart('/'))).Subnetmask;
}
NetworkInterfaceProfileInfo profile = new NetworkInterfaceProfileInfo
{
Name = name,
EnableStaticIPAddress = ConfigEnableStaticIPAddress,
IPAddress = ConfigIPAddress,
Gateway = ConfigGateway,
Subnetmask = configSubnetmask,
EnableStaticDNS = ConfigEnableStaticDNS,
PrimaryDNSServer = ConfigPrimaryDNSServer,
SecondaryDNSServer = ConfigSecondaryDNSServer
};
NetworkInterfaceProfileManager.AddProfile(profile);
}
/// <summary>
/// Creates a new instance of this class.
/// </summary>
public RoutingEntry()
{
ipaDestination = IPAddress.Any;
ipaNextHop = IPAddress.Any;
iMetric = 0;
bSubnetMask = new Subnetmask();
reoOwner = RoutingEntryOwner.Unknown;
}
private async void StartSplit()
{
DisplayStatusMessage = false;
IsSplitRunning = true;
SplitResult.Clear();
string[] subnetSplit = Subnet.Trim().Split('/');
string newSubnetmaskOrCidr = NewSubnetmaskOrCIDR.TrimStart('/');
// Validate the user input and display warning
double cidr = subnetSplit[1].Length < 3 ? double.Parse(subnetSplit[1]) : Subnetmask.ConvertSubnetmaskToCidr(subnetSplit[1]);
double newCidr = newSubnetmaskOrCidr.Length < 3 ? double.Parse(newSubnetmaskOrCidr) : Subnetmask.ConvertSubnetmaskToCidr(newSubnetmaskOrCidr);
if (65535 < (Math.Pow(2, (32 - cidr)) / Math.Pow(2, (32 - newCidr))))
{
MetroDialogSettings settings = AppearanceManager.MetroDialog;
settings.AffirmativeButtonText = LocalizationManager.GetStringByKey("String_Button_Continue");
settings.NegativeButtonText = LocalizationManager.GetStringByKey("String_Button_Cancel");
settings.DefaultButtonFocus = MessageDialogResult.Affirmative;
if (await dialogCoordinator.ShowMessageAsync(this, LocalizationManager.GetStringByKey("String_Header_AreYouSure"), LocalizationManager.GetStringByKey("String_TheProcessCanTakeUpSomeTimeAndResources"), MessageDialogStyle.AffirmativeAndNegative, settings) != MessageDialogResult.Affirmative)
{
CancelSplit = false;
IsSplitRunning = false;
return;
}
}
// Convert CIDR to subnetmask
string subnetmask = Subnetmask.GetFromCidr((int)cidr).Subnetmask;
string newSubnetmask = Subnetmask.GetFromCidr((int)newCidr).Subnetmask;
// Add history
AddSubnetToHistory(Subnet);
AddNewSubnetmaskOrCIDRToHistory(NewSubnetmaskOrCIDR);
cancellationTokenSource = new CancellationTokenSource();
try
{
foreach (SubnetInfo subnetInfo in await Models.Network.Subnet.SplitIPv4SubnetAsync(IPAddress.Parse(subnetSplit[0]), IPAddress.Parse(subnetmask), IPAddress.Parse(newSubnetmask), cancellationTokenSource.Token))
{
SplitResult.Add(subnetInfo);
}
}
catch (OperationCanceledException)
{
StatusMessage = LocalizationManager.GetStringByKey("String_CanceledByUser");
DisplayStatusMessage = true;
}
CancelSplit = false;
IsSplitRunning = false;
}
public async void ApplyNetworkInterfaceConfig()
{
IsConfigurationRunning = true;
DisplayStatusMessage = false;
string subnetmask = ConfigSubnetmaskOrCidr;
// CIDR to subnetmask
if (ConfigEnableStaticIPAddress && subnetmask.StartsWith("/"))
{
subnetmask = Subnetmask.GetFromCidr(int.Parse(subnetmask.TrimStart('/'))).Subnetmask;
}
// If primary and secondary DNS are empty --> autoconfiguration
if (ConfigEnableStaticDNS && string.IsNullOrEmpty(ConfigPrimaryDNSServer) && string.IsNullOrEmpty(ConfigSecondaryDNSServer))
{
ConfigEnableDynamicDNS = true;
}
// When primary DNS is empty, swap it with secondary (if not empty)
if (ConfigEnableStaticDNS && string.IsNullOrEmpty(ConfigPrimaryDNSServer) && !string.IsNullOrEmpty(ConfigSecondaryDNSServer))
{
ConfigPrimaryDNSServer = ConfigSecondaryDNSServer;
ConfigSecondaryDNSServer = string.Empty;
}
NetworkInterfaceConfig config = new NetworkInterfaceConfig
{
Name = SelectedNetworkInterface.Name,
EnableStaticIPAddress = ConfigEnableStaticIPAddress,
IPAddress = ConfigIPAddress,
Subnetmask = subnetmask,
Gateway = ConfigGateway,
EnableStaticDNS = ConfigEnableStaticDNS,
PrimaryDNSServer = ConfigPrimaryDNSServer,
SecondaryDNSServer = ConfigSecondaryDNSServer
};
try
{
Models.Network.NetworkInterface networkInterface = new Models.Network.NetworkInterface();
networkInterface.UserHasCanceled += NetworkInterface_UserHasCanceled;
await networkInterface.ConfigureNetworkInterfaceAsync(config);
ReloadNetworkInterfacesAction();
}
catch (Exception ex)
{
StatusMessage = ex.Message;
DisplayStatusMessage = true;
}
finally
{
IsConfigurationRunning = false;
}
}
/// <summary>
/// Creates a new instance of this rule
/// </summary>
public IPAddressRule()
{
ipaDestination = null;
ipaSource = null;
smSourceWildcard = null;
smDestinationWildcard = null;
ipaAddress = null;
smWildcard = null;
}
/// <summary>
/// Creates a new instance of this class.
/// </summary>
public RIPUpdate()
{
afiAddressFamilyIdentifier = RIPEntryAddressFamily.IPv4;
bRouteTag = new byte[2];
smSubnetMask = new Subnetmask();
ipaNextHop = IPAddress.Any;
ipaAddress = IPAddress.Any;
iMetric = 0;
}
/// <summary>
/// Creates a new instance of this class with the given properties.
/// </summary>
/// <param name="ipaDestination">The destination IP</param>
/// <param name="ipaNextHop">The next hop's IP</param>
/// <param name="iMetric">The metric</param>
/// <param name="bSubnetMask">The subnetmask of the destination</param>
/// <param name="reoOwner">The owner of this route</param>
public RoutingEntry(IPAddress ipaDestination, IPAddress ipaNextHop, int iMetric, Subnetmask bSubnetMask, RoutingEntryOwner reoOwner)
{
CheckValid(ipaDestination, ipaNextHop, bSubnetMask);
this.ipaDestination = ipaDestination;
this.ipaNextHop = ipaNextHop;
this.iMetric = iMetric;
this.bSubnetMask = bSubnetMask;
this.reoOwner = reoOwner;
}
/// <summary>
/// Creates a new instance of this class with the given params
/// </summary>
/// <param name="ipaAddress">The IP address</param>
/// <param name="smMask">The subnetmask</param>
/// <param name="ipaGateway">The gateway address</param>
/// <param name="ipaDNSServer">The DNS server address</param>
public DHCPPoolItem(IPAddress ipaAddress, Subnetmask smMask, IPAddress ipaGateway, IPAddress ipaDNSServer)
{
this.ipaAddress = ipaAddress;
this.smMask = smMask;
this.ipaGateway = ipaGateway;
this.ipaDNSServer = ipaDNSServer;
macLeasedTo = MACAddress.Empty;
strHostname = "";
tsLeaseDuration = new TimeSpan(0, 0, 0, 0);
}
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
// if Validation.HasError is true...
if ((bool)values[0] || (bool)values[1])
{
return(false);
}
var subnet = values[2] as string;
var newSubnetmaskOrCidr = values[3] as string;
// Catch null exceptions...
if (string.IsNullOrEmpty(subnet) || string.IsNullOrEmpty(newSubnetmaskOrCidr))
{
return(false);
}
// Get the cidr to compare...
var subnetData = subnet.Split('/');
var ipAddress = IPAddress.Parse(subnetData[0]);
var subnetmaskOrCidr = subnetData[1];
int cidr;
// ReSharper disable once SwitchStatementMissingSomeCases
switch (ipAddress.AddressFamily)
{
case System.Net.Sockets.AddressFamily.InterNetwork when subnetmaskOrCidr.Length < 3:
cidr = int.Parse(subnetmaskOrCidr);
break;
case System.Net.Sockets.AddressFamily.InterNetwork:
cidr = Subnetmask.ConvertSubnetmaskToCidr(IPAddress.Parse(subnetmaskOrCidr));
break;
default:
cidr = int.Parse(subnetmaskOrCidr);
break;
}
int newCidr;
// Support subnetmask like 255.255.255.0
if (Regex.IsMatch(newSubnetmaskOrCidr, RegexHelper.SubnetmaskRegex))
{
newCidr = System.Convert.ToByte(Subnetmask.ConvertSubnetmaskToCidr(IPAddress.Parse(newSubnetmaskOrCidr)));
}
else
{
newCidr = System.Convert.ToByte(newSubnetmaskOrCidr.TrimStart('/'));
}
// Compare
return(newCidr > cidr);
}
/// <summary>
/// Creates a new instance of this class
/// </summary>
public OSPFHelloMessage()
{
nNetmask = new Subnetmask();
iHelloInterval = 0;
bPriority = 0;
iDeadInterval = 30;
ipaDesignatedRouter = IPAddress.Any;
ipaBackupDesignatedRouter = IPAddress.Any;
lipaNeighbours = new List <IPAddress>();
ospfOptions = new OSPFOptionsField();
}
/// <summary>
/// Converts an array of name value items to an array of subnetmasks
/// </summary>
/// <param name="strString">The name value item which should be converted</param>
/// <returns>An array of subnetmasks</returns>
public static Subnetmask[] ConvertToSubnetmask(NameValueItem[] strString)
{
Subnetmask[] sam = new Subnetmask[strString.Length];
for (int iC1 = 0; iC1 < strString.Length; iC1++)
{
sam[iC1] = Subnetmask.Parse(strString[iC1].Value);
}
return(sam);
}
/// <summary>
/// Creates a new instance of this class with the given properties.
/// </summary>
/// <param name="afiAddressFamilyIdentifier">The address family identifier</param>
/// <param name="bRouteTag">The route tag for RIPv2, a byte array of length two</param>
/// <param name="smMask">The subnetmask for RIPv2</param>
/// <param name="ipaNextHop">The IPAddress of the next hop for RIPv2</param>
/// <param name="ipaAddress">The IPAddress of the destination</param>
/// <param name="iMetric">The metric</param>
public RIPUpdate(RIPEntryAddressFamily afiAddressFamilyIdentifier, byte[] bRouteTag, Subnetmask smMask, IPAddress ipaNextHop, IPAddress ipaAddress, uint iMetric)
{
this.afiAddressFamilyIdentifier = afiAddressFamilyIdentifier;
if (bRouteTag.Length != 2)
{
throw new ArgumentException("Invalid route tag. Must be a byte-array of len two");
}
this.bRouteTag = bRouteTag;
this.smSubnetMask = smMask;
this.ipaNextHop = ipaNextHop;
this.ipaAddress = ipaAddress;
this.iMetric = iMetric;
}
/// <summary>
/// Creates a new instance of this class by parsing the given data beginning from the given start index.
/// </summary>
/// <param name="bData">The data to parse</param>
/// <param name="iStartIndex">The index to start parsing from</param>
public SummaryLSA(byte[] bData, int iStartIndex)
: this()
{
byte[] bMaskData = new byte[4];
for (int iC1 = iStartIndex; iC1 < 4; iC1++)
{
bMaskData[iC1 - iStartIndex] = bData[iStartIndex];
}
smNetmask = new Subnetmask(bMaskData);
for (int iC1 = iStartIndex + 4; iC1 < bData.Length; iC1 += 4)
{
lItems.Add(new SummaryLSAItem(bData, iC1));
}
}
/// <summary>
/// Creates a new instance of this class by parsing the given data starting at the given index
/// </summary>
/// <param name="bData">The data to parse</param>
/// <param name="iStartIndex">The index to start parsing</param>
public ASExternalLSA(byte[] bData, int iStartIndex)
: this()
{
byte[] bMaskData = new byte[4];
for (int iC1 = iStartIndex; iC1 < 4; iC1++)
{
bMaskData[iC1 - iStartIndex] = bData[iStartIndex];
}
smNetmask = new Subnetmask(bMaskData);
for (int iC1 = iStartIndex + 12; iC1 < bData.Length; iC1 += 12)
{
lItems.Add(new ASExternalItem(bData, iC1));
}
}
/// <summary>
/// Compiles a filter string to a kernel level WinPcap filter
/// </summary>
/// <param name="strFilterString">The filter expression to compile</param>
/// <param name="bOptimize">A bool indicating if the expression should be atomatically optimized</param>
/// <param name="smMask">The subnetmask to use for this expression. This subnetmask is only important for IP multicast or broadcast probes.</param>
/// <returns>The compiled WinPcap filter</returns>
public WinPcapFilter CompileFilter(string strFilterString, bool bOptimize, Subnetmask smMask)
{
if (iptrOpenDevice == IntPtr.Zero)
{
throw new Exception("No device is currently open");
}
WinPcapFilter.WinPcapFilterStruct wpcStruct = new WinPcapFilter.WinPcapFilterStruct();
if (pcap_compile(iptrOpenDevice, ref wpcStruct, strFilterString, bOptimize ? 1 : 0, smMask.IntNotation) != 0)
{
throw new Exception("An error occured while trying to compile the filter: " + pcap_geterr(iptrOpenDevice));
}
return(new WinPcapFilter(strFilterString, wpcStruct, smMask));
}
private void RemoveEntry(IPAddress ipaNextHop, IPAddress ipaDestinatoin, Subnetmask smMask, int iMetric)
{
RoutingEntry reFound = null;
foreach (RoutingEntry re in RoutingEntries)
{
if (re.NextHop.Equals(ipaNextHop) && re.Destination.Equals(ipaDestinatoin) && re.Subnetmask.Equals(smMask))
{
reFound = re;
}
}
if (reFound != null)
{
RemoveEntry(reFound);
}
}
private async void StartSplit()
{
DisplayStatusMessage = false;
IsSplitRunning = true;
SplitResult.Clear();
string[] subnetSplit = Subnet.Trim().Split('/');
string subnetmask = subnetSplit[1];
// Convert CIDR to subnetmask
if (subnetmask.Length < 3)
{
subnetmask = Subnetmask.GetFromCidr(int.Parse(subnetSplit[1])).Subnetmask;
}
string newSubnetmask = NewSubnetmaskOrCIDR.TrimStart('/');
if (newSubnetmask.Length < 3)
{
newSubnetmask = Subnetmask.GetFromCidr(int.Parse(newSubnetmask)).Subnetmask;
}
// Add history
SubnetHistory = new List <string>(HistoryListHelper.Modify(SubnetHistory, Subnet, SettingsManager.Current.Application_HistoryListEntries));
NewSubnetmaskOrCIDRHistory = new List <string>(HistoryListHelper.Modify(NewSubnetmaskOrCIDRHistory, NewSubnetmaskOrCIDR, SettingsManager.Current.Application_HistoryListEntries));
cancellationTokenSource = new CancellationTokenSource();
try
{
foreach (SubnetInfo subnetInfo in await Models.Network.Subnet.SplitIPv4SubnetAsync(IPAddress.Parse(subnetSplit[0]), IPAddress.Parse(subnetmask), IPAddress.Parse(newSubnetmask), cancellationTokenSource.Token))
{
SplitResult.Add(subnetInfo);
}
}
catch (OperationCanceledException)
{
StatusMessage = Application.Current.Resources["String_CanceledByUser"] as string;
DisplayStatusMessage = true;
}
CancelSplit = false;
IsSplitRunning = false;
}
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
// if Validation.HasError is true...
if ((bool)values[0] || (bool)values[1])
{
return(false);
}
string subnet = values[2] as string;
string newSubnetmaskOrCIDR = values[3] as string;
// Catch null exceptions...
if (string.IsNullOrEmpty(subnet) || string.IsNullOrEmpty(newSubnetmaskOrCIDR))
{
return(false);
}
// Get the cidr to compare...
string subnetmaskOrCIDR = subnet.Split('/')[1];
int cidr;
if (subnetmaskOrCIDR.Length < 3)
{
cidr = int.Parse(subnetmaskOrCIDR);
}
else
{
cidr = Subnetmask.ConvertSubnetmaskToCidr(IPAddress.Parse(subnetmaskOrCIDR));
}
newSubnetmaskOrCIDR = newSubnetmaskOrCIDR.TrimStart('/');
int newCidr;
if (newSubnetmaskOrCIDR.Length < 3)
{
newCidr = int.Parse(newSubnetmaskOrCIDR);
}
else
{
newCidr = Subnetmask.ConvertSubnetmaskToCidr(IPAddress.Parse(newSubnetmaskOrCIDR));
}
// Compare
return(newCidr > cidr);
}
/// <summary>
/// Creates a pool from the given parameters
/// </summary>
/// <param name="ipaStart">The start address of the pool range</param>
/// <param name="ipaEnd">The end address of the pool range</param>
/// <param name="ipi">The IP idnterface to which this pool should be associated</param>
/// <param name="iAddrCounter">The index of the address of the interface to use if the interface has multiple IP addresses assigned</param>
protected virtual void CreatePool(IPAddress ipaStart, IPAddress ipaEnd, IPInterface ipi, int iAddrCounter)
{
if (ipaStart.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork || ipaEnd.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork)
{
throw new ArgumentException("Only IPv4 is supported at the moment");
}
DHCPPool dhPool = GetPoolForInterface(ipi);
IPAddress[] ipRange = IPAddressAnalysis.GetIPRange(ipaStart, ipaEnd);
foreach (IPAddress ipa in ipRange)
{
IPInterface ipiInterface = ipi;
IPAddress ipAddress = ipa;
IPAddress ipGateway;
Subnetmask smMask = ipi.Subnetmasks[iAddrCounter];
IPAddress ipDnsServer = IPAddress.Any;
if (ipaGateway == null)
{
ipGateway = ipi.IpAddresses[iAddrCounter];
}
else
{
ipGateway = ipaGateway;
}
if (ipaDNSServer == null)
{
ipDnsServer = ipi.IpAddresses[iAddrCounter];
}
else
{
ipDnsServer = ipaDNSServer;
}
if (dhPool.GetItemForAddress(ipAddress) == null)
{
DHCPPoolItem dhPoolItem = new DHCPPoolItem(ipAddress, smMask, ipGateway, ipDnsServer);
AddPoolItem(dhPoolItem, dhPool, ipi);
}
}
}
private void CalculateIPv4SubnetAction()
{
string subnetmask = SubnetmaskOrCidr;
if (SubnetmaskOrCidr.StartsWith("/"))
{
subnetmask = Subnetmask.GetFromCidr(int.Parse(SubnetmaskOrCidr.TrimStart('/'))).Subnetmask;
}
SubnetInfo subnetInfo = Subnet.CalculateIPv4Subnet(IPAddress.Parse(IPv4Address), IPAddress.Parse(subnetmask));
DetailsNetworkAddress = subnetInfo.NetworkAddress;
DetailsBroadcast = subnetInfo.Broadcast;
DetailsSubnetmask = subnetInfo.Subnetmask;
DetailsCIDR = subnetInfo.CIDR;
DetailsTotalIPs = subnetInfo.TotalIPs;
DetailsHostIPRange = string.Format("{0} - {1}", subnetInfo.HostFirstIP, subnetInfo.HostLastIP);
DetailsHostIPs = subnetInfo.HostIPs;
IsDetailsVisible = true;
}
/// <summary>
/// Creates a new instance of this class by parsing the given data
/// </summary>
/// <param name="bData">The data to pase</param>
public OSPFHelloMessage(byte[] bData)
{
byte[] bTmpBytes = new byte[4];
for (int iC1 = 0; iC1 < 4; iC1++)
{
bTmpBytes[iC1] = bData[iC1];
}
nNetmask = new Subnetmask(bTmpBytes);
iHelloInterval = (bData[5] << 8) + bData[6];
ospfOptions = new OSPFOptionsField(bData[6]);
bPriority = bData[7];
iDeadInterval = ((int)bData[8] << 24) + ((int)bData[9] << 16) + ((int)bData[10] << 8) + bData[11];
for (int iC1 = 12; iC1 < 16; iC1++)
{
bTmpBytes[iC1 - 12] = bData[iC1];
}
ipaDesignatedRouter = new IPAddress(bTmpBytes);
for (int iC1 = 16; iC1 < 20; iC1++)
{
bTmpBytes[iC1 - 16] = bData[iC1];
}
ipaBackupDesignatedRouter = new IPAddress(bTmpBytes);
lipaNeighbours = new List <IPAddress>();
for (int iC2 = 20; iC2 < bData.Length; iC2 += 4)
{
for (int iC1 = iC2; iC1 < iC2 + 4; iC1++)
{
bTmpBytes[iC1 - iC2] = bData[iC1];
}
lipaNeighbours.Add(new IPAddress(bTmpBytes));
}
}
/// <summary>
/// Updates an RIP Entry
/// </summary>
/// <param name="ipaNextHop"></param>
/// <param name="ipaDestinatoin"></param>
/// <param name="smMask"></param>
/// <param name="iMetric"></param>
/// <returns>Bool indicating if something changed</returns>
private bool UpdateEntry(IPAddress ipaNextHop, IPAddress ipaDestinatoin, Subnetmask smMask, int iMetric)
{
bool bFound = false;
bool bChanged = true;
foreach (RoutingEntry re in RoutingEntries)
{
if (re.Destination.Equals(ipaDestinatoin) && re.Subnetmask.Equals(smMask))
{
if (iMetric != re.Metric || !re.NextHop.Equals(ipaNextHop))
{
bChanged = true;
if (iMetric < 16)
{
re.Metric = iMetric;
}
else
{
re.Metric = 65535;
Holddown(ipaDestinatoin);
}
re.NextHop = ipaNextHop;
InvokeEntryUpdated(re);
}
bFound = true;
}
}
if (!bFound)
{
bChanged = true;
RoutingEntry re = new RoutingEntry(ipaDestinatoin, ipaNextHop, iMetric, smMask, RoutingEntryOwner.RIP);
AddRoutingEntry(re);
}
return(bChanged);
}
/// <summary>
/// Creates a new instance of this class by parsing the given data.
/// </summary>
/// <param name="bData">The data to parse.</param>
public RIPUpdate(byte[] bData)
{
afiAddressFamilyIdentifier = (RIPEntryAddressFamily)((bData[0] << 8) + bData[1]);
bRouteTag = new byte[2];
bRouteTag[0] = bData[2];
bRouteTag[1] = bData[3];
byte[] bAddressBytes = new byte[4];
bAddressBytes[0] = bData[4];
bAddressBytes[1] = bData[5];
bAddressBytes[2] = bData[6];
bAddressBytes[3] = bData[7];
ipaAddress = new IPAddress(bAddressBytes);
smSubnetMask = new Subnetmask();
smSubnetMask.MaskBytes[0] = bData[8];
smSubnetMask.MaskBytes[1] = bData[9];
smSubnetMask.MaskBytes[2] = bData[10];
smSubnetMask.MaskBytes[3] = bData[11];
bAddressBytes[0] = bData[12];
bAddressBytes[1] = bData[13];
bAddressBytes[2] = bData[14];
bAddressBytes[3] = bData[15];
ipaNextHop = new IPAddress(bAddressBytes);
iMetric = (uint)((bData[16] << 24) + (bData[17] << 16) + (bData[18] << 8) + bData[19]);
}
