public void DHCPv4RelayAgentSubnetResolver_AreValuesValid_Valid()
{
Random random = new Random();
String validMaskValue = ((Byte)random.Next(10, 20)).ToString();
IPv4SubnetMask subnetMask = new IPv4SubnetMask(new IPv4SubnetMaskIdentifier(Convert.ToInt32(validMaskValue)));
IPv4Address address = random.GetIPv4NetworkAddress(subnetMask);
var mock = new Mock <ISerializer>(MockBehavior.Strict);
mock.Setup(x => x.Deserialze <String>(validMaskValue)).Returns(subnetMask.GetSlashNotation().ToString());
mock.Setup(x => x.Deserialze <String>(address.ToString())).Returns(address.ToString());
DHCPv4RelayAgentSubnetResolver resolver = new DHCPv4RelayAgentSubnetResolver();
var input = new Dictionary <string, string>()
{
{ nameof(DHCPv4RelayAgentSubnetResolver.Mask), validMaskValue },
{ nameof(DHCPv4RelayAgentSubnetResolver.NetworkAddress), address.ToString() },
};
Boolean result = resolver.ArePropertiesAndValuesValid(input, mock.Object);
Assert.True(result);
}
public void DHCPv4RelayAgentSubnetResolver_ApplyValues()
{
Random random = new Random();
String validMaskValue = ((Byte)random.Next(1, 32)).ToString();
String validNetworkAddressValue = random.GetIPv4Address().ToString();
IPv4SubnetMask subnetMask = new IPv4SubnetMask(new IPv4SubnetMaskIdentifier(Convert.ToInt32(validMaskValue)));
IPv4Address address = IPv4Address.FromString(validNetworkAddressValue);
var mock = new Mock <ISerializer>(MockBehavior.Strict);
mock.Setup(x => x.Deserialze <String>(validMaskValue)).Returns(subnetMask.GetSlashNotation().ToString());
mock.Setup(x => x.Deserialze <String>(validNetworkAddressValue)).Returns(address.ToString());
DHCPv4RelayAgentSubnetResolver resolver = new DHCPv4RelayAgentSubnetResolver();
var input = new Dictionary <string, string>()
{
{ nameof(DHCPv4RelayAgentSubnetResolver.Mask), validMaskValue },
{ nameof(DHCPv4RelayAgentSubnetResolver.NetworkAddress), validNetworkAddressValue },
};
resolver.ApplyValues(input, mock.Object);
Assert.Equal(subnetMask, resolver.Mask);
Assert.Equal(address, resolver.NetworkAddress);
}
/// <summary>
/// Interaktionslogik für invalide Eingaben
/// </summary>
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
try
{
if (SourceAddressBox.Text == "")
{
throw new Exception("Bitte eine IP-Adresse eintragen!");
}
if (AddresCountBox.Text.Length == 0)
{
throw new Exception("Bitte Größe eintragen!");
}
var address = new IPv4Address(SourceAddressBox.Text);
var newNetwork = new IPv4Network(address, IPv4SubnetMask.ByAddressCount(int.Parse(AddresCountBox.Text)));
newNetwork.Description = this.DescriptionBox.Text;
if (network is not null)
{
this.network.AddSubnet(newNetwork);
}
else
{
AppStore.Instance.MainNetwork = newNetwork;
}
AppStore.Instance.Refresh();
this.Close();
}
catch (Exception exception)
{
Exception_TextBlock.Text = exception.Message.ToString();
}
}
public DHCPv4ScopeAddressProperties(
IPv4Address start,
IPv4Address end,
IEnumerable <IPv4Address> excluded,
TimeSpan?renewalTime = null,
TimeSpan?preferredLifetime = null,
TimeSpan?leaseTime = null,
Byte?maskLength = null,
Boolean?reuseAddressIfPossible = null,
AddressAllocationStrategies?addressAllocationStrategy = null,
Boolean?supportDirectUnicast = null,
Boolean?acceptDecline = null,
Boolean?informsAreAllowd = null
) : base(start, end, excluded, reuseAddressIfPossible, addressAllocationStrategy, supportDirectUnicast, acceptDecline, informsAreAllowd)
{
Mask = (maskLength == null || maskLength == 0) ? null : new IPv4SubnetMask(new IPv4SubnetMaskIdentifier(maskLength.Value));
RenewalTime = renewalTime;
PreferredLifetime = preferredLifetime;
LeaseTime = leaseTime;
if (leaseTime.HasValue || renewalTime.HasValue || preferredLifetime.HasValue)
{
UseDynamicRewnewTime = false;
}
}
public void Constructor_Failed_AddressNotNetwork(String rawNetwork, String rawMask)
{
IPv4Address address = IPv4Address.FromString(rawNetwork);
IPv4SubnetMask mask = IPv4SubnetMask.FromString(rawMask);
Assert.ThrowsAny <Exception>(() =>
new IPv4Route(address, mask));
}
public static IPv4Address GetIPv4AddressWithinSubnet(this Random random, IPv4SubnetMask mask, IPv4Address networkAddress)
{
Int32 maxAddressInSubnet = mask.GetAmountOfPossibleAddresses();
IPv4Address result = networkAddress + random.Next(1, maxAddressInSubnet);
return(result);
}
public void CanCalculateHostAddress()
{
var address = new IPv4Address("192.168.10.5");
var mask = new IPv4SubnetMask("255.255.252.0");
var subnet = new IPv4Network(address, mask);
Assert.Equal("192.168.8.1", subnet.FirstAddress.ToString());
}
public void IPv4SubnetMask_IsIPAdressANetworkAddress(String subnetMaskInput, String addressInput, Boolean expectedResult)
{
IPv4SubnetMask mask = IPv4SubnetMask.FromString(subnetMaskInput);
IPv4Address address = IPv4Address.FromString(addressInput);
Boolean actual = mask.IsIPAdressANetworkAddress(address);
Assert.Equal(expectedResult, actual);
}
private void Button_Click_3(object sender, RoutedEventArgs e)
{
var address = IPv4Address.Random();
var mask = IPv4SubnetMask.Random();
var view = new NetworkView(new IPv4Network(address, mask));
view.Show();
}
public void DHCPv4RelayAgentSubnetResolver_AreValuesValid_MissingKeys()
{
Random random = new Random();
String validMaskValue = random.GetAlphanumericString(30);
String validNetworkAddressValue = random.GetAlphanumericString(30);
IPv4SubnetMask subnetMask = random.GetSubnetmask();
IPv4Address address = (random.GetIPv4NetworkAddress(subnetMask)) - 1;
var mock = new Mock <ISerializer>(MockBehavior.Strict);
mock.Setup(x => x.Deserialze <IPv4SubnetMask>(validMaskValue)).Returns(subnetMask);
mock.Setup(x => x.Deserialze <IPv4Address>(validNetworkAddressValue)).Returns(address);
DHCPv4RelayAgentSubnetResolver resolver = new DHCPv4RelayAgentSubnetResolver();
List <Dictionary <String, String> > invalidInputs = new List <Dictionary <string, string> >
{
null,
new Dictionary <string, string>(),
new Dictionary <string, string>()
{
{ random.GetAlphanumericString(10), random.GetAlphanumericString(10) }
},
new Dictionary <string, string>()
{
{ nameof(DHCPv4RelayAgentSubnetResolver.Mask), random.GetAlphanumericString(10) },
},
new Dictionary <string, string>()
{
{ nameof(DHCPv4RelayAgentSubnetResolver.Mask), random.GetAlphanumericString(10) },
{ nameof(DHCPv4RelayAgentSubnetResolver.NetworkAddress), random.GetAlphanumericString(10) },
},
new Dictionary <string, string>()
{
{ nameof(DHCPv4RelayAgentSubnetResolver.Mask), validMaskValue },
{ nameof(DHCPv4RelayAgentSubnetResolver.NetworkAddress), random.GetAlphanumericString(10) },
},
new Dictionary <string, string>()
{
{ nameof(DHCPv4RelayAgentSubnetResolver.Mask), random.GetAlphanumericString(10) },
{ nameof(DHCPv4RelayAgentSubnetResolver.NetworkAddress), validNetworkAddressValue },
},
new Dictionary <string, string>()
{
{ nameof(DHCPv4RelayAgentSubnetResolver.Mask), validMaskValue },
{ nameof(DHCPv4RelayAgentSubnetResolver.NetworkAddress), validNetworkAddressValue },
},
};
foreach (var item in invalidInputs)
{
Boolean result = resolver.ArePropertiesAndValuesValid(item, mock.Object);
Assert.False(result);
}
}
public void DHCPv4RelayAgentSubnetResolver_PacketMeetsConditions()
{
Random random = new Random();
Int32 maskIdentifier = random.Next(20, 24);
IPv4SubnetMask mask = new IPv4SubnetMask(new IPv4SubnetMaskIdentifier(maskIdentifier));
IPv4Address addresses = random.GetIPv4NetworkAddress(mask);
Mock <ISerializer> serializer = new Mock <ISerializer>(MockBehavior.Strict);
serializer.Setup(x => x.Deserialze <String>(mask.GetSlashNotation().ToString())).Returns(mask.GetSlashNotation().ToString());
serializer.Setup(x => x.Deserialze <String>(addresses.ToString())).Returns(addresses.ToString());
DHCPv4RelayAgentSubnetResolver resolver = new DHCPv4RelayAgentSubnetResolver();
Dictionary <String, String> values = new Dictionary <String, String>()
{
{ nameof(DHCPv4RelayAgentSubnetResolver.NetworkAddress), addresses.ToString() },
{ nameof(DHCPv4RelayAgentSubnetResolver.Mask), mask.GetSlashNotation().ToString() },
};
resolver.ApplyValues(values, serializer.Object);
Int32 trys = random.Next(20, 30);
for (int i = 0; i < trys; i++)
{
Boolean shouldPass = false;
IPv4Address gwAddress = IPv4Address.Empty;
if (random.NextDouble() > 0.5)
{
gwAddress = random.GetIPv4AddressWithinSubnet(mask, addresses);
shouldPass = true;
}
else
{
if (random.NextDouble() > 0.5)
{
gwAddress = random.GetIPv4AddressOutWithSubnet(mask, addresses);
}
}
DHCPv4Packet packet = new DHCPv4Packet(
new IPv4HeaderInformation(random.GetIPv4Address(), random.GetIPv4Address()),
random.NextBytes(6),
(UInt32)random.Next(),
IPv4Address.Empty,
gwAddress,
IPv4Address.Empty
);
Boolean actual = resolver.PacketMeetsCondition(packet);
Assert.Equal(shouldPass, actual);
}
}
public static IPv4Address GetIPv4NetworkAddress(this Random random, IPv4SubnetMask mask)
{
IPv4Address start = random.GetIPv4Address();
Byte[] rawResult = ByteHelper.AndArray(start.GetBytes(), mask.GetBytes());
IPv4Address result = IPv4Address.FromByteArray(rawResult);
return(result);
}
public void Constructor(String rawNetwork, String rawMask)
{
IPv4Address address = IPv4Address.FromString(rawNetwork);
IPv4SubnetMask mask = IPv4SubnetMask.FromString(rawMask);
IPv4Route route = new IPv4Route(address, mask);
Assert.Equal(mask, route.SubnetMask);
Assert.Equal(address, route.Network);
}
public void CanRemoveAddresses()
{
var address = new IPv4Address("192.168.10.5");
var mask = new IPv4SubnetMask("255.255.252.0");
var subnet = new IPv4Network(address, mask);
var address1 = new IPv4Address("192.168.10.7");
subnet.AddAddress(address1);
subnet.RemoveAddress(new IPv4Address("192.168.10.7"));
Assert.DoesNotContain(address1, subnet.GivenAddresses);
}
private void Button_Click_4(object sender, RoutedEventArgs e)
{
var address = new IPv4Address("192.168.10.4");
var mask = new IPv4SubnetMask("255.255.255.0");
var network = new IPv4Network(address, mask);
network.AddAddress(new IPv4Address("192.168.10.9"));
network.AddAddress(new IPv4Address("192.168.10.10"));
AppStore.Instance.MainNetwork = network;
System.IO.File.WriteAllText(@"C:\Users\Flo\Desktop\Network.json", JsonSerializer.Serialize(AppStore.Instance.MainNetwork));
}
private void alleNetzwerke_Click(object sender, RoutedEventArgs e)
{
var address = new IPv4Address(IPBox.Text);
var mask = new IPv4SubnetMask(MaskBox.Text);
var subnet = new IPv4Network(address, mask);
IPListe.Items.Clear();
foreach (var item in subnet.AllPossibleAddresses.Take(100000))
{
IPListe.Items.Add(item);
}
}
public void IPv4SubnetMask_FromByteArray(Byte[] input, Boolean parsable)
{
if (parsable == false)
{
Assert.ThrowsAny <Exception>(() => IPv4SubnetMask.FromByteArray(input));
return;
}
IPv4SubnetMask mask = IPv4SubnetMask.FromByteArray(input);
Byte[] actual = mask.GetBytes();
Assert.Equal(input, actual);
}
public void ThrowsExceptionWhenAddingWrongNNetworks()
{
var address = new IPv4Address("192.168.10.5");
var mask = new IPv4SubnetMask("255.255.252.0");
var network = new IPv4Network(address, mask);
Assert.ThrowsAny <Exception>(() => network.AddSubnet(null));
Assert.ThrowsAny <Exception>(() => network.AddSubnet(new IPv4Network(new IPv4Address("1.1.1.1"), new IPv4SubnetMask("0.0.0.0"))));
var subnet = new IPv4Network(new IPv4Address("192.168.10.5"), new IPv4SubnetMask("255.255.254.0"));
network.AddSubnet(subnet);
Assert.ThrowsAny <Exception>(() => network.AddSubnet(subnet));
}
public static IPv4Address GetIPv4AddressOutWithSubnet(this Random random, IPv4SubnetMask mask, IPv4Address networkAddress)
{
Boolean upperBoundaries = random.NextDouble() > 0.5;
if (upperBoundaries == true)
{
Int32 maxAddressInSubnet = mask.GetAmountOfPossibleAddresses();
return(networkAddress + maxAddressInSubnet + random.Next(10, 300));
}
else
{
return(networkAddress - random.Next(10, 300));
}
}
public DHCPv4ScopeAddressProperties(
IPv4Address start,
IPv4Address end,
IEnumerable <IPv4Address> excluded,
DynamicRenewTime rewnewTime,
Byte?maskLength = null,
Boolean?reuseAddressIfPossible = null,
AddressAllocationStrategies?addressAllocationStrategy = null,
Boolean?supportDirectUnicast = null,
Boolean?acceptDecline = null,
Boolean?informsAreAllowd = null
) : base(start, end, excluded, reuseAddressIfPossible, addressAllocationStrategy, supportDirectUnicast, acceptDecline, informsAreAllowd, rewnewTime)
{
Mask = (maskLength == null || maskLength == 0) ? null : new IPv4SubnetMask(new IPv4SubnetMaskIdentifier(maskLength.Value));
}
public void ThrowsExceptionWhenAddingWrongAddresses()
{
var address = new IPv4Address("192.168.10.5");
var mask = new IPv4SubnetMask("255.255.252.0");
var subnet = new IPv4Network(address, mask);
Assert.ThrowsAny <Exception>(() => subnet.AddAddress(new IPv4Address("192.168.8.0")));
Assert.ThrowsAny <Exception>(() => subnet.AddAddress(new IPv4Address("192.0.0.0")));
Assert.ThrowsAny <Exception>(() => subnet.AddAddress(null));
var address1 = new IPv4Address("192.168.10.7");
subnet.AddAddress(address1);
Assert.ThrowsAny <Exception>(() => subnet.AddAddress(address1));
}
public void CanAddAddresses()
{
var address = new IPv4Address("192.168.10.5");
var mask = new IPv4SubnetMask("255.255.252.0");
var network = new IPv4Network(address, mask);
var address1 = new IPv4Address("192.168.10.7");
var address2 = new IPv4Address("192.168.10.8");
network.AddAddress(address1);
network.AddAddress(address2);
Assert.Contains(address1, network.GivenAddresses);
Assert.Contains(address2, network.GivenAddresses);
}
public Boolean ArePropertiesAndValuesValid(IDictionary <String, String> valueMapper, ISerializer serializer)
{
try
{
if (valueMapper.ContainsKeys(new[] { nameof(NetworkAddress), nameof(Mask) }) == false)
{
return(false);
}
var address = IPv4Address.FromString(serializer.Deserialze <String>(valueMapper[nameof(NetworkAddress)]));
var mask = new IPv4SubnetMask(new IPv4SubnetMaskIdentifier(Convert.ToInt32(serializer.Deserialze <String>(valueMapper[nameof(Mask)]))));
return(mask.IsIPAdressANetworkAddress(address));
}
catch (Exception)
{
return(false);
}
}
public void DHCPv4RelayAgentSubnetResolver_PacketMeetsConditions2(
String networkAddressInput,
String maskInput,
String relayAgentAddressInput,
Boolean shouldPass
)
{
Random random = new Random();
IPv4SubnetMask mask = IPv4SubnetMask.FromString(maskInput);
IPv4Address networkAddress = IPv4Address.FromString(networkAddressInput);
String inputAddressValue = random.GetAlphanumericString(10);
String inputMaskValue = random.GetAlphanumericString(10);
Mock <ISerializer> serializer = new Mock <ISerializer>(MockBehavior.Strict);
serializer.Setup(x => x.Deserialze <String>(mask.GetSlashNotation().ToString())).Returns(mask.GetSlashNotation().ToString());
serializer.Setup(x => x.Deserialze <String>(networkAddress.ToString())).Returns(networkAddress.ToString());
DHCPv4RelayAgentSubnetResolver resolver = new DHCPv4RelayAgentSubnetResolver();
Dictionary <String, String> values = new Dictionary <String, String>()
{
{ nameof(DHCPv4RelayAgentSubnetResolver.NetworkAddress), networkAddress.ToString() },
{ nameof(DHCPv4RelayAgentSubnetResolver.Mask), mask.GetSlashNotation().ToString() },
};
resolver.ApplyValues(values, serializer.Object);
IPv4Address gwAddress = IPv4Address.FromString(relayAgentAddressInput);
DHCPv4Packet packet = new DHCPv4Packet(
new IPv4HeaderInformation(random.GetIPv4Address(), random.GetIPv4Address()),
random.NextBytes(6),
(UInt32)random.Next(),
IPv4Address.Empty,
gwAddress,
IPv4Address.Empty
);
Boolean actual = resolver.PacketMeetsCondition(packet);
Assert.Equal(shouldPass, actual);
}
public void CanCalculateAllPossibleAddresses()
{
var address = new IPv4Address("192.168.10.5");
var mask = new IPv4SubnetMask("255.255.252.0");
var network = new IPv4Network(address, mask);
Assert.Equal(1022, network.AllPossibleAddresses.Count());
network.AddAddress(new IPv4Address("192.168.10.7"));
network.AddAddress(new IPv4Address("192.168.10.8"));
Assert.Equal(1020, network.AllPossibleAddresses.Count());
var subnet = new IPv4Network(new IPv4Address("192.168.10.5"), new IPv4SubnetMask("255.255.254.0"));
subnet.AddAddress(new IPv4Address("192.168.11.204"));
network.AddSubnet(subnet);
Assert.Equal(511, network.AllPossibleAddresses.Count());
}
public void IPv4SubnetMask_FromIdentifier()
{
Dictionary <Int32, Byte> mapper = new Dictionary <int, byte>
{
{ 0, 0 },
{ 1, 128 },
{ 2, 192 },
{ 3, 224 },
{ 4, 240 },
{ 5, 248 },
{ 6, 252 },
{ 7, 254 },
{ 8, 255 },
};
for (int maskIdentifier = 0; maskIdentifier <= 32; maskIdentifier++)
{
IPv4SubnetMask mask = new IPv4SubnetMask(new IPv4SubnetMaskIdentifier(maskIdentifier));
Byte[] result = mask.GetBytes();
Int32 index = maskIdentifier % 8;
Int32 arrayIndex = maskIdentifier / 8;
if (maskIdentifier == 32)
{
for (int i = 0; i < 4; i++)
{
Assert.Equal(255, result[i]);
}
continue;
}
for (int j = 0; j < arrayIndex; j++)
{
Assert.Equal(255, result[j]);
}
Assert.Equal(mapper[index], result[arrayIndex]);
}
}
public static DHCPv4PacketRouteListOption FromByteArray(Byte[] data, Int32 offset)
{
if (data == null || data.Length < offset + 10)
{
throw new ArgumentException(nameof(data));
}
Byte length = data[offset + 1];
Int32 routeAmount = length / 8;
Int32 index = offset + 2;
IPv4Route[] routes = new IPv4Route[routeAmount];
for (int i = 0; i < routeAmount; i++, index += 8)
{
IPv4Address network = IPv4Address.FromByteArray(data, index);
IPv4SubnetMask mask = IPv4SubnetMask.FromByteArray(data, index + 4);
routes[i] = new IPv4Route(network, mask);
}
return(new DHCPv4PacketRouteListOption(data[offset], routes));
}
internal override void OverrideProperties(DHCPv4ScopeAddressProperties range)
{
base.OverrideProperties(range);
if (range.LeaseTime.HasValue == true)
{
this.LeaseTime = range.LeaseTime;
}
if (range.PreferredLifetime.HasValue == true)
{
this.PreferredLifetime = range.PreferredLifetime.Value;
}
if (range.RenewalTime.HasValue == true)
{
this.RenewalTime = range.RenewalTime.Value;
}
if (range.Mask != null)
{
this.Mask = new IPv4SubnetMask(new IPv4SubnetMaskIdentifier(range.Mask.GetSlashNotation()));
}
}
public void CanInvert(string subnet, string expected)
{
Assert.Equal(expected, IPv4SubnetMask.Invert(new IPv4SubnetMask(subnet)).ToString());
}
public void ThrowsByBitCountException(int bitCount)
{
Assert.ThrowsAny <Exception>(() => IPv4SubnetMask.ByBitCount(bitCount));
}
