public void TestCaseWhereTheNetworkWasSplitUpIntoSubnetsUnterTheInfluence()
{
var addr = new IPv4Address(0xDDA69010);
var mask = new IPv4Address(0x55E0951D);
var net = new IPv4Network(addr, mask);
// addr is 1101_1101_1010_0110_1001_0000_0001_0000 = 0xDDA69010
// mask is 0101_0101_1110_0000_1001_0101_0001_1101 = 0x55E0951D
// ------------------------------------------------------------
// cwcd is 1010_1010_0001_1111_0110_1010_1110_0010 = 0xAA1F6AE2
// base is 0101_0101_1010_0000_1001_0000_0001_0000 = 0x55A09010
// fhst is 0101_0101_1010_0000_1001_0000_0001_0010 = 0x55A09012
// bcst is 1111_1111_1011_1111_1111_1010_1111_0010 = 0xFFBFFAF2
// lhst is 1111_1111_1011_1111_1111_1010_1111_0000 = 0xFFBFFAF0
// unraveled base is net 1111_1011_1001_000 host 0_0000_0000_0000_0000
// unraveled base is 0xFB900000
// unraveled first host is 0xFB900001
// unraveled first host is net 1111_1011_1001_000 host 0_0000_0000_0000_0001
// woven first host is 0101_0101_1010_0000_1001_0000_0001_0010
// woven first host is 0x55A09012
Assert.Equal(0x55A09010u, net.BaseAddress.AddressValue);
Assert.Equal(0x55E0951Du, net.SubnetMask.AddressValue);
Assert.Equal(0xAA1F6AE2u, net.CiscoWildcard.AddressValue);
Assert.Equal(0x55A09012u, net.FirstHostAddress.Value.AddressValue);
Assert.Equal(0xFFBFFAF0u, net.LastHostAddress.Value.AddressValue);
Assert.Equal(0xFFBFFAF2u, net.BroadcastAddress.Value.AddressValue);
Assert.Null(net.CidrPrefix);
}
/// <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 void TestMinimizeTunet()
{
var netsMust = new IPv4Network[]
{
new IPv4Network(IPv4Address.Parse("128.130.0.0"), 15),
new IPv4Network(IPv4Address.Parse("192.35.240.0"), 22),
new IPv4Network(IPv4Address.Parse("192.35.244.0"), 24),
new IPv4Network(IPv4Address.Parse("193.170.72.0"), 21),
new IPv4Network(IPv4Address.Parse("193.170.72.0"), 22),
new IPv4Network(IPv4Address.Parse("193.170.76.0"), 23),
new IPv4Network(IPv4Address.Parse("193.170.78.0"), 24),
new IPv4Network(IPv4Address.Parse("193.170.79.0"), 24),
};
List <IPNetwork <IPv4Address> > netsMinimized = Minimize.MinimizeSubnets(netsMust,
(addr, mask) => new IPv4Network(addr, mask));
foreach (IPNetwork <IPv4Address> minNet in netsMinimized)
{
for (IPv4Address addr = minNet.BaseAddress; addr.CompareTo(minNet.LastAddressOfSubnet) <= 0; addr = addr + 1)
{
bool contained = false;
foreach (IPNetwork <IPv4Address> origNet in netsMust)
{
if (origNet.Contains(addr))
{
contained = true;
break;
}
}
if (!contained)
{
Assert.True(false, $"IP address {addr} in minimized net {minNet} not contained in any original net");
}
}
}
foreach (IPNetwork <IPv4Address> origNet in netsMust)
{
for (IPv4Address addr = origNet.BaseAddress; addr.CompareTo(origNet.LastAddressOfSubnet) <= 0; addr = addr + 1)
{
bool contained = false;
foreach (IPNetwork <IPv4Address> minNet in netsMinimized)
{
if (minNet.Contains(addr))
{
contained = true;
break;
}
}
if (!contained)
{
Assert.True(false, $"IP address {addr} in original net {origNet} not contained in any minimized net");
}
}
}
}
public NetworkView(IPv4Network network)
{
this.network = network;
this.network.OnChanged += RefreshWindow;
InitializeComponent();
RefreshWindow();
}
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());
}
internal static int Delete(DeleteConfig !config)
{
RoutingContract.Imp routeConn = ((!)config.routingRef).Acquire();
if (routeConn == null)
{
Console.WriteLine("Could not initialize routing endpoint.");
return(1);
}
routeConn.RecvReady();
IPv4Network destination;
if (IPv4Network.Parse(config.destination, out destination) == false)
{
Console.WriteLine("Could not parse destination address.");
}
Network destNet = ChannelUtils.NetworkToChannelNetwork(destination);
routeConn.SendFindSpecificNetRoute(destNet);
switch receive {
case routeConn.NoRouteFound():
Console.WriteLine("No route for destination.");
delete routeConn;
return(-1);
case routeConn.Route(RouteEntry r):
// Do nothing; success.
break;
case routeConn.ChannelClosed():
Console.WriteLine("routeConn channel closed.");
throw new Exception("routeConn channel closed.");
}
routeConn.SendDeleteRoute(destNet);
switch receive {
case routeConn.NoRouteFound():
Console.WriteLine("Unexpected error attempting to delete the route");
break;
case routeConn.OK():
Console.WriteLine("Route successfully deleted");
break;
case routeConn.ChannelClosed():
Console.WriteLine("routeConn channel closed");
throw new Exception("routeConn channel closed");
}
delete routeConn;
return(0);
}
public RouteEntry(IPv4Network network,
IPv4 gateway,
IPv4 ifaddr,
uint metric,
uint tag)
{
this.network = network;
this.gateway = gateway;
this.ifaddr = ifaddr;
this.metric = metric;
this.tag = tag;
}
public RouteEntry(IPv4 host,
IPv4 gateway,
IPv4 ifaddr,
uint metric,
uint tag)
{
this.network = new IPv4Network(host, IPv4.BitCount);
this.gateway = gateway;
this.ifaddr = ifaddr;
this.metric = metric;
this.tag = tag;
}
/// <summary>
/// Get route for specific destination network.
/// </summary>
/// <returns>Specific route if it is present,
/// <c>null</c> otherwise. </returns>
public RouteEntry LookupSpecific(IPv4Network destination)
{
using (routesLock.Lock()) {
foreach (RouteEntry e in routes.Values)
{
if (e.Network == destination)
{
return(e);
}
}
}
return(null);
}
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 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);
}
public void TestSubnetMaskConstruction()
{
var addr = new IPv4Address(0x12345678u);
var net = new IPv4Network(addr, 11);
Assert.Equal(0x12200000u, net.BaseAddress.AddressValue);
Assert.Equal(0xFFE00000u, net.SubnetMask.AddressValue);
Assert.Equal(0x001FFFFFu, net.CiscoWildcard.AddressValue);
Assert.Equal(0x12200001u, net.FirstHostAddress.Value.AddressValue);
Assert.Equal(0x123FFFFEu, net.LastHostAddress.Value.AddressValue);
Assert.Equal(0x123FFFFFu, net.BroadcastAddress.Value.AddressValue);
Assert.Equal(11, net.CidrPrefix.Value);
}
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));
}
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 void TestNonCidrPrefixConstruction()
{
var addr = new IPv4Address(0x12345678u);
var mask = new IPv4Address(0xFF0000FFu);
var net = new IPv4Network(addr, mask);
Assert.Equal(0x12000078u, net.BaseAddress.AddressValue);
Assert.Equal(0xFF0000FFu, net.SubnetMask.AddressValue);
Assert.Equal(0x00FFFF00u, net.CiscoWildcard.AddressValue);
Assert.Equal(0x12000178u, net.FirstHostAddress.Value.AddressValue);
Assert.Equal(0x12FFFE78u, net.LastHostAddress.Value.AddressValue);
Assert.Equal(0x12FFFF78u, net.BroadcastAddress.Value.AddressValue);
Assert.Null(net.CidrPrefix);
}
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);
}
NetStack2.RouteEntry FindNetRoute(IPv4Network dest)
{
HostConfiguration h = IP.GetHostConfiguration();
IPv4Network nwrk = dest;
NetStack2.RouteEntry re =
h.RoutingTable.Lookup(nwrk);
if (re != null)
{
return(re);
}
else
{
throw new Exception("FindNetRoute");
}
}
/*
* RouteEntry[] GetRoutingTable()
* {
* HostConfiguration h = IP.GetHostConfiguration();
* RouteEntry[] retval =
* new RouteEntry[h.RoutingTable.Count];
* int i = 0;
*
* foreach (NetStack2.RouteEntry r in h.RoutingTable) {
* retval[i] = ConvertRouteEntry(r);
* i++;
* }
*
* return retval;
* }
*/
void AddRoute(IPv4Network dest, uint gateway, uint ifaddr)
{
HostConfiguration h = IP.GetHostConfiguration();
IPv4Network destination = dest;
if (h.RoutingTable.AddRoute(
new NetStack2.RouteEntry(destination,
new IPv4(gateway),
new IPv4(ifaddr))))
{
return;
}
else
{
throw new Exception("AddRoute");
}
}
void DeleteRoute(IPv4Network dest)
{
HostConfiguration h = IP.GetHostConfiguration();
IPv4Network destNet = dest;
NetStack2.RouteEntry re =
h.RoutingTable.LookupSpecific(destNet);
if (re == null)
{
throw new Exception("DeleteRoute");
}
else
{
h.RoutingTable.DeleteRoute(re);
}
}
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());
}
private void AddInterfaceRoutes(InterfaceIPConfiguration !ipConfig)
{
//
// Add subnet route
//
IPv4Network subnet = new IPv4Network(ipConfig.Address,
ipConfig.NetMask);
routingTable.AddRoute(
new RouteEntry(subnet,
ipConfig.Address,
ipConfig.Address,
RouteEntry.DirectlyConnectedMetric,
RouteEntry.InterfaceRouteTag)
);
//
// Add route to gateway
//
routingTable.AddRoute(
new RouteEntry(ipConfig.Gateway,
ipConfig.Address,
ipConfig.Address,
RouteEntry.DirectlyConnectedMetric,
RouteEntry.InterfaceRouteTag)
);
//
// Add default route if none exists
//
if (routingTable.Lookup(IPv4Network.Default) == null)
{
routingTable.AddRoute(
new RouteEntry(IPv4Network.Default,
ipConfig.Gateway,
ipConfig.Address,
RouteEntry.DefaultRouteMetric,
RouteEntry.InterfaceRouteTag)
);
}
}
public RouteEntry(IPv4Network network,
IPv4 gateway,
IPv4 ifaddr)
: this(network, gateway, ifaddr, DefaultRouteMetric, 0)
{
}
public AddNetworkDialog(IPv4Network baseNetwork)
{
InitializeComponent();
this.network = baseNetwork;
SourceAddressBox.Text = baseNetwork.AllPossibleAddresses.First().ToString();
}
public void TryParse_should_parse_ipv4_network(string ip, int cidr)
{
IPv4Network.TryParse($"{ip}/{cidr}", out var network).Should().BeTrue();
network.NetworkAddress.Should().BeEquivalentTo(IPAddress.Parse(ip));
network.NetworkCidr.Should().Be((byte)cidr);
}
internal static int Add(AddConfig !config)
{
IPv4 gateway;
RoutingContract.Imp routeConn = ((!)config.routingRef).Acquire();
if (routeConn == null)
{
Console.WriteLine("Could not initialize routing endpoint.");
return(1);
}
routeConn.RecvReady();
if (IPv4.Parse(config.gateway, out gateway) == false)
{
Console.WriteLine("Could not parse gateway address.");
delete routeConn;
return(-1);
}
try {
// NOTE: for some reason the compiler doesn't
// realize that ifaddr will definitely be assigned if
// we survive the if/switch-receive sequence. Work
// around that by initializing.
IPv4 ifaddr = new IPv4(0);
if (config.ifAddress == null)
{
routeConn.SendFindHostRoute((uint)gateway);
switch receive {
case routeConn.Route(RouteEntry r):
ifaddr = new IPv4(r.ifaddr);
break;
case routeConn.NoRouteFound():
Console.WriteLine("No route to gateway.");
delete routeConn;
return(-1);
break;
case routeConn.ChannelClosed():
Console.WriteLine("routeConn channel closed.");
throw new Exception("routeConn channel closed.");
}
}
else if (IPv4.Parse(config.ifAddress, out ifaddr) == false)
{
Console.WriteLine("Could not parse interface address.");
delete routeConn;
return(-1);
}
IPContract.Imp ipConn = ((!)config.ipRef).Acquire();
if (ipConn == null)
{
Console.WriteLine("Could not initialize IP endpoint.");
delete routeConn;
return(-1);
}
try {
bool isLocal;
ipConn.SendIsLocalAddress((uint)ifaddr);
ipConn.RecvIsLocal(out isLocal);
if (!isLocal)
{
Console.WriteLine("Proposed interface address is not bound to an interface.");
delete routeConn;
return(-1);
}
}
finally {
delete ipConn;
ipConn = null;
}
IPv4Network destination;
if (IPv4Network.Parse(config.destination, out destination) == false)
{
Console.WriteLine("Could not parse destination address.");
delete routeConn;
return(-1);
}
NetStack.Contracts.Network nwrk = new NetStack.Contracts.Network();
nwrk.network = (uint)destination.Network;
nwrk.netmask = (uint)destination.NetMask;
routeConn.SendAddRoute(nwrk, (uint)gateway, (uint)ifaddr);
switch receive {
case routeConn.Err():
Console.WriteLine("Route could not be added -- it may already exist.");
break;
case routeConn.OK():
Console.WriteLine("Route added successfully");
break;
case routeConn.ChannelClosed():
throw new Exception("routeConn channel closed");
}
}
catch (Exception e) {
Console.WriteLine("Exception: {0}", e);
}
delete routeConn;
return(0);
}
