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]); }