public Panel UpdateView(IPv4Address address)
{
Panel.Controls.Clear();
_views = new FieldView[] {
new IPv4AddressFieldView("Address", address),
new TextFieldView("Class", address.AddressClass.ToString()),
new TextFieldView("Public?", address.BelongsToPublicPool.ToString()),
new IPv4AddressFieldView("Mask", address.Mask),
new IPv4AddressFieldView("Subnet", address.Subnet),
new IPv4AddressFieldView("Broadcast", address.Broadcast),
new IPv4AddressFieldView("First host", address.FirstHostAddress),
new IPv4AddressFieldView("Last host", address.LastHostAddress),
new TextFieldView("Max host amount", address.MaxHostAmount.ToString()),
new TextFieldView("Is host?", address.IsHostAddress.ToString()),
};
int lastY = 0;
foreach (var field in _views)
{
var view = field.CreateView();
view.Location = new Point(0, lastY);
lastY += view.Height + MarginBetweenViews;
Panel.Controls.Add(view);
}
return(Panel);
}
protected static DHCPv4ScopeAddressProperties GetScopeAddressProperties(IScopeChangeCommand request) =>
request.AddressProperties.DynamicRenewTime == null ?
new DHCPv4ScopeAddressProperties
(
IPv4Address.FromString(request.AddressProperties.Start),
IPv4Address.FromString(request.AddressProperties.End),
request.AddressProperties.ExcludedAddresses.Select(x => IPv4Address.FromString(x)),
leaseTime: request.AddressProperties.LeaseTime,
renewalTime: request.AddressProperties.RenewalTime,
preferredLifetime: request.AddressProperties.PreferredLifetime,
reuseAddressIfPossible: request.AddressProperties.ReuseAddressIfPossible,
addressAllocationStrategy: (Core.Scopes.ScopeAddressProperties <DHCPv4ScopeAddressProperties, IPv4Address> .AddressAllocationStrategies?)request.AddressProperties.AddressAllocationStrategy,
supportDirectUnicast: request.AddressProperties.SupportDirectUnicast,
acceptDecline: request.AddressProperties.AcceptDecline,
informsAreAllowd: request.AddressProperties.InformsAreAllowd,
maskLength: request.AddressProperties.MaskLength
) : new DHCPv4ScopeAddressProperties
(
IPv4Address.FromString(request.AddressProperties.Start),
IPv4Address.FromString(request.AddressProperties.End),
request.AddressProperties.ExcludedAddresses.Select(x => IPv4Address.FromString(x)),
GetDynamicRenewTime(request.AddressProperties.DynamicRenewTime),
reuseAddressIfPossible: request.AddressProperties.ReuseAddressIfPossible,
addressAllocationStrategy: (Core.Scopes.ScopeAddressProperties <DHCPv4ScopeAddressProperties, IPv4Address> .AddressAllocationStrategies?)request.AddressProperties.AddressAllocationStrategy,
supportDirectUnicast: request.AddressProperties.SupportDirectUnicast,
acceptDecline: request.AddressProperties.AcceptDecline,
informsAreAllowd: request.AddressProperties.InformsAreAllowd,
maskLength: request.AddressProperties.MaskLength
);
/// <summary>
/// Fills up the routing table
/// </summary>
void FillRoutingTable()
{
// network;netmask;interface
for (int i = 0; i < routingTableString.Count; i++)
{
string[] line = routingTableString[i].Split(';');
IPv4Address network;
IPv4Address netmask;
string intName = "";
try
{
network = new IPv4Address(line[0]);
netmask = new IPv4Address(line[1]);
intName = line[2];
IPv4InterfacePair pair = new IPv4InterfacePair();
pair.network = network;
pair.netMask = netmask;
pair.interfaceName = intName;
}
catch (IPv4Exception e)
{
Debug.LogError(String.Format("IPv4 error reading routing table line: '{0}'", routingTableString[i]));
Debug.LogError(e.ToString());
}
catch (IPv4InterfaceException e)
{
Debug.LogError(String.Format("InterfacePair error reading routing table line: '{0}'", routingTableString[i]));
Debug.LogError(e.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 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);
}
/// <summary>
/// Simple constructor for the IGMP header that initializes the member fields.
/// </summary>
public IgmpHeader()
: base()
{
igmpVersionType = IgmpMembershipQuery;
igmpMaxResponseTime = 0;
igmpChecksum = 0;
igmpGroupAddress = IPv4Address.Any;
}
/// <summary>
/// Parse a DNS A resource record from the given stream.
/// </summary>
/// <param name="Name">The DNS name.</param>
/// <param name="Stream">A stream of bytes.</param>
public A(String Name,
Stream Stream)
: base(Name, TypeId, Stream)
{
this._IPv4Address = new IPv4Address(Stream);
}
public void DHCPv4ScopeAddressProperties_FailedConstructor_StartGreaterThanEnd()
{
Random random = new Random();
IPv4Address end = random.GetIPv4Address();
IPv4Address start = random.GetIPv4AddressGreaterThan(end);
Assert.ThrowsAny <Exception>(() => new DHCPv4ScopeAddressProperties(start, end, Array.Empty <IPv4Address>()));
}
public void TestAnd(uint expected, uint left, uint right)
{
var expectedAddress = new IPv4Address(expected);
var leftAddress = new IPv4Address(left);
var rightAddress = new IPv4Address(right);
Assert.Equal(expectedAddress, leftAddress & rightAddress);
}
protected override void initFields()
{
base.initFields();
mSenderMAC = new HW.Network.MACAddress(mRawData, 22);
mSenderIP = new IPv4Address(mRawData, 28);
mTargetMAC = new HW.Network.MACAddress(mRawData, 32);
mTargetIP = new IPv4Address(mRawData, 38);
}
public void HandleInform_InformsAreAllowed()
{
Random random = new Random();
IPv4Address clientAddress = IPv4Address.FromString("192.168.178.10");
IPv4HeaderInformation headerInformation =
new IPv4HeaderInformation(clientAddress, IPv4Address.FromString("192.168.178.1"));
Byte[] clientMacAdress = random.NextBytes(6);
DHCPv4Packet requestPacket = new DHCPv4Packet(
headerInformation, clientMacAdress, (UInt32)random.Next(),
IPv4Address.Empty, IPv4Address.Empty, clientAddress,
DHCPv4PacketFlags.Unicast,
new DHCPv4PacketMessageTypeOption(DHCPv4MessagesTypes.Inform)
);
Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> > scopeResolverMock =
new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict);
var resolverInformations = new CreateScopeResolverInformation
{
Typename = nameof(DHCPv4RelayAgentSubnetResolver),
};
Mock <IScopeResolver <DHCPv4Packet, IPv4Address> > resolverMock = new Mock <IScopeResolver <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict);
scopeResolverMock.Setup(x => x.InitializeResolver(resolverInformations)).Returns(resolverMock.Object);
Guid scopeId = random.NextGuid();
DHCPv4RootScope rootScope = GetRootScope(scopeResolverMock);
rootScope.Load(new List <DomainEvent> {
new DHCPv4ScopeEvents.DHCPv4ScopeAddedEvent(
new DHCPv4ScopeCreateInstruction
{
AddressProperties = new DHCPv4ScopeAddressProperties(
IPv4Address.FromString("192.168.178.1"),
IPv4Address.FromString("192.168.178.255"),
new List <IPv4Address> {
IPv4Address.FromString("192.168.178.1")
},
informsAreAllowd: true
),
ResolverInformation = resolverInformations,
Name = "Testscope",
Id = scopeId,
})
});
DHCPv4Packet result = rootScope.HandleInform(requestPacket);
CheckAcknowledgePacket(clientAddress, result);
CheckEventAmount(1, rootScope);
CheckHandeledEvent(0, InformErros.NoError, requestPacket, result, rootScope);
}
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 Setup()
{
Random random = new();
for (int i = 0; i < Addresses.Length; i++)
{
Addresses[i] = new IPv4Address(random.Next()).ToString();
}
}
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 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 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 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 IncrementOverflow4()
{
var ipaddress = new IPv4Address("0.0.0.0");
for (int a = 0; a < 256; a++)
{
ipaddress = ipaddress.IncrementOne();
}
Assert.AreEqual(new IPv4Address("0.0.1.0"), ipaddress);
}
/// <summary>
/// Sends a packet with a "ping" message
/// </summary>
/// <param name="ip">Destination IPv4</param>
public void SendPingPacket(string ip)
{
NetInterface firstInterface = interfaceList[0];
// Assemble ping packet
IPv4Address dest = new IPv4Address(ip);
Packet newPacket = new Packet(firstInterface.GetIPAddress(), dest, "ping");
SendPacket(newPacket);
}
public static HW.Network.MACAddress Resolve(IPv4Address ipAddress)
{
ensureCacheExists();
if (cache.ContainsKey(ipAddress.To32BitNumber()) == false)
{
return(null);
}
return(cache[ipAddress.To32BitNumber()]);
}
public void IPv4Adress_IsInBetween(String start, String current, String end, Boolean expectedResult)
{
IPv4Address startAddress = IPv4Address.FromString(start);
IPv4Address currentAddress = IPv4Address.FromString(current);
IPv4Address endAddress = IPv4Address.FromString(end);
Boolean actual = currentAddress.IsBetween(startAddress, endAddress);
Assert.Equal(expectedResult, actual);
}
/// <summary>
/// Create a new DNS A resource record.
/// </summary>
/// <param name="Name">The DNS name.</param>
/// <param name="Class">The DNS class.</param>
/// <param name="TimeToLive">The timestamp when this resource records gets invalidated.</param>
/// <param name="IPv4Address">The IPv4 address of this resource record.</param>
public A(String Name,
DNSQueryClasses Class,
TimeSpan TimeToLive,
IPv4Address IPv4Address)
: base(Name, TypeId, Class, TimeToLive, IPv4Address.ToString())
{
this._IPv4Address = IPv4Address;
}
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 IPv4AddressesAreNotEqual()
{
var a = IPv4Address.Parse("141.24.12.2");
var b = IPv4Address.Parse("127.0.0.1");
Assert.IsFalse(a.Equals(b));
Assert.IsFalse(a == b);
Assert.IsTrue(a != b);
Assert.AreNotEqual(a, b);
}
public void TestFromBytes()
{
Assert.Equal(0x00000000u, IPv4Address.MaybeFromBytes(new byte[] { 0, 0, 0, 0 }).Value.AddressValue);
Assert.Equal(0x01020304u, IPv4Address.MaybeFromBytes(new byte[] { 1, 2, 3, 4 }).Value.AddressValue);
Assert.Equal(0xFFFFFFFFu, IPv4Address.MaybeFromBytes(new byte[] { 255, 255, 255, 255 }).Value.AddressValue);
Assert.Equal(0x12345678u, IPv4Address.MaybeFromBytes(new byte[] { 18, 52, 86, 120 }).Value.AddressValue);
Assert.Equal(0x7F000001u, IPv4Address.MaybeFromBytes(new byte[] { 127, 0, 0, 1 }).Value.AddressValue);
Assert.Null(IPv4Address.MaybeFromBytes(new byte[] { 1, 2, 3 }));
Assert.Null(IPv4Address.MaybeFromBytes(new byte[] { 1, 2, 3, 4, 5 }));
}
static void Main(string[] args)
{
var ip = new IPv4Address("192:0:0:1")
{
Value = 1338961360
};
Console.WriteLine(ip);
Console.ReadLine();
}
public void TestInform_RandomScopeAcceptInforms()
{
Random random = new Random();
IPv4Address start = random.GetIPv4Address();
IPv4Address end = random.GetIPv4AddressGreaterThan(start);
IPv4Address sourceAddress = random.GetIPv4AddressBetween(start, end);
List <Tuple <IPv4Address, IPv4Address> > existingRanges = new List <Tuple <IPv4Address, IPv4Address> >
{
new Tuple <IPv4Address, IPv4Address>(start, end),
};
DHCPv4Packet input = GetInformPacket(random, sourceAddress);
Int32 rootScopeAmount = random.Next(3, 10);
List <DomainEvent> events = new List <DomainEvent>();
for (int i = 0; i < rootScopeAmount; i++)
{
Guid rootScopeId = Guid.NewGuid();
Tuple <IPv4Address, IPv4Address> addressRange = random.GenerateUniqueAddressRange(existingRanges);
events.Add(new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction
{
Id = rootScopeId,
AddressProperties = new DHCPv4ScopeAddressProperties
(addressRange.Item1, addressRange.Item2, Array.Empty <IPv4Address>(), informsAreAllowd: true)
}));
GenerateScopeTree(
random.NextDouble(), random,
rootScopeId, existingRanges, events);
}
Int32 randomScopeIndex = random.Next(0, events.Count);
DHCPv4ScopeAddedEvent corelatedScopeEvent = (DHCPv4ScopeAddedEvent)events[randomScopeIndex];
corelatedScopeEvent.Instructions.AddressProperties = new DHCPv4ScopeAddressProperties
(start, end, Array.Empty <IPv4Address>(), informsAreAllowd: true);
Guid scopeId = corelatedScopeEvent.Instructions.Id;
DHCPv4RootScope rootScope = GetRootScope();
rootScope.Load(events);
DHCPv4Packet result = rootScope.HandleInform(input);
DHCPv4InformHandledEvent domainEvent = TestResult <DHCPv4InformHandledEvent>(
input, result, false, true, scopeId, rootScope);
Assert.Equal(InformErros.NoError, domainEvent.Error);
}
public static IPv4Address AsIPv4Address(this String input)
{
try
{
return(IPv4Address.FromString(input));
}
catch (Exception)
{
return(IPv4Address.Empty);
}
}
/// <summary>
/// Can be used to test pinging to a network address from Cosmos
/// </summary>
/// <param name="dest">IP Address of destination</param>
public static void Ping(IPv4Address dest)
{
IPv4Address source = FindNetwork(dest);
if (source == null)
{
Console.WriteLine("Destination Network Unreachable!!");
return;
}
ICMP.ICMPEchoRequest request = new ICMP.ICMPEchoRequest(source, dest, 0x10, 1);
TCPIP.IPv4OutgoingBuffer.AddPacket(request);
}
public TcpClient(IPv4Address dest, UInt16 port)
{
IPv4Address source = TCPIPStack.FindNetwork(dest);
if( source == null )
{
throw new ArgumentException("Destination host unreachable", "dest");
}
this.connection = new TCPConnection(dest, port, source, NextLocalPort++, 0x5656, TCPConnection.State.SYN_SENT);
this.connection.client = this;
TCPIPStack.tcpSockets.Add(connection);
TCPPacket packet = new TCPPacket(connection, connection.LocalSequenceNumber, 0, 0x02, 8192);
TCPIP.IPv4OutgoingBuffer.AddPacket(packet);
}
public IPv4Subnet(IPv4Address prefix, byte length)
{
if(length > 32) throw new CriticalException("Wrong length " + length);
this.prefix = prefix;
this.length = length;
}
/// <summary>
/// Find the next address of current IPv4 address.
/// </summary>
/// <returns></returns>
public IPv4Address NextAddress()
{
IPv4Address nextAddr;
nextAddr = new IPv4Address(Octet[0].Decimal, Octet[1].Decimal, Octet[2].Decimal, Octet[3].Decimal);
for (int i = nextAddr.Octet.Length - 1; i >= 0; i--)
{
if (nextAddr.Octet[i].Decimal < 255)
{
nextAddr.Octet[i].Decimal++;
break;
}
else
nextAddr.Octet[i].Decimal = 0;
}
return nextAddr;
}
public IPv4EndPoint(IPv4Address addr, UInt16 port)
{
this.ipAddr = addr;
this.port = port;
}
internal static IPv4Address FindRoute(IPv4Address destIP)
{
for (int c = 0; c < ipConfigs.Count; c++)
{
if (ipConfigs[c].DefaultGateway.CompareTo(IPv4Address.Zero) != 0)
{
return ipConfigs[c].DefaultGateway;
}
}
return null;
}
/// <summary>
/// Send a UDP packet to a destination device
/// </summary>
/// <param name="dest">IP address of destination</param>
/// <param name="srcPort">Source port</param>
/// <param name="destPort">Destination port to send data to</param>
/// <param name="data">Data to be sent</param>
public static void SendUDP(IPv4Address dest, UInt16 srcPort, UInt16 destPort, byte[] data)
{
IPv4Address source = FindNetwork(dest);
if (source == null)
{
Console.WriteLine("Destination Network Unreachable!!");
return;
}
UDP.UDPPacket outgoing = new UDP.UDPPacket(source, dest, srcPort, destPort, data);
TCPIP.IPv4OutgoingBuffer.AddPacket(outgoing);
}
internal ARPRequest_EthernetIPv4(HW.Network.MACAddress ourMAC, IPv4Address ourIP, HW.Network.MACAddress targetMAC, IPv4Address targetIP)
: base(1, ourMAC, ourIP, targetMAC, targetIP, 42)
{ }
internal static HW.Network.NetworkDevice FindInterface(IPv4Address sourceIP)
{
return addressMap[sourceIP.To32BitNumber()];
}
/// <summary>
/// Attempts to parse raw data into a structured packet
/// </summary>
/// <param name="buffer">Raw data to parse</param>
/// <param name="packet">Parsed packet</param>
/// <param name="count">The length of the packet in bytes</param>
/// <param name="index">The index into the buffer at which the packet begins</param>
/// <returns>True if parsing was successful, false if it is not.</returns>
internal static bool TryParse(byte[] buffer, int index, int count, out IPv4 packet)
{
try
{
if (count < MinimumParseableBytes)
{
packet = null;
return false;
}
using (var ms = new MemoryStream(buffer, index, count, false))
{
using (var br = new BinaryReader(ms))
{
var versionAndHeaderLen = br.ReadByte();
var version = versionAndHeaderLen >> 4;
var headerLength = versionAndHeaderLen & 0x0F;
var differentiatedServices = br.ReadByte();
var totalLength = ByteOrder.NetworkToHostOrder(br.ReadUInt16());
var id = ByteOrder.NetworkToHostOrder(br.ReadUInt16());
var flagsAndFragOff = new BitVector32(ByteOrder.NetworkToHostOrder(br.ReadUInt16()));
var ttl = br.ReadByte();
var protocol = br.ReadByte();
var headerChecksum = ByteOrder.NetworkToHostOrder(br.ReadUInt16());
var sourceAddress = new IPv4Address(br.ReadBytes(4));
var destAddress = new IPv4Address(br.ReadBytes(4));
if (headerLength == 0 || (headerLength * 32 / 8 > count))
{
// Specified header length is larger than available bytes
packet = null;
return false;
}
byte[] optionsAndPadding;
if (headerLength * 32 / 8 < br.BaseStream.Position)
{
optionsAndPadding = br.ReadBytes(headerLength * 32 / 8 - (int)br.BaseStream.Position);
}
else
{
optionsAndPadding = Array.Empty<byte>();
}
br.BaseStream.Seek(headerLength * 32 / 8, SeekOrigin.Begin);
// TODO: Accept option for IgnoreLength
int payloadLength;
if (true /*IgnoreLength*/)
{
payloadLength = count - (int)br.BaseStream.Position;
}
/*else
{
payloadLength = (totalLength - (headerLength * 32 / 8)
}*/
packet = null;
switch (protocol)
{
case (byte)Protocols.UDP:
{
UDP payload;
if (UDP.TryParse(
buffer,
index + (int)br.BaseStream.Position,
payloadLength,
out payload))
{
packet = new IPv4<UDP> { Payload = payload };
}
}
break;
case (byte)Protocols.ICMP:
{
ICMP payload;
if (ICMP.TryParse(
buffer,
index + (int)br.BaseStream.Position,
payloadLength,
out payload))
{
packet = new IPv4<ICMP> { Payload = payload };
}
}
break;
// TODO: Add TCP when ported over
}
if (packet == null)
{
Generic payload;
Generic.TryParse(buffer, index + (int)br.BaseStream.Position, payloadLength, out payload);
// This can never fail, so I'm not checking the output
packet = new IPv4<Generic> { Payload = payload };
}
packet.Version = version;
packet.HeaderLength = headerLength;
packet.DifferentiatedServices = differentiatedServices;
packet.TotalLength = totalLength;
packet.ID = id;
packet.FlagsAndFragOff = flagsAndFragOff;
packet.TTL = ttl;
packet.Protocol = protocol;
packet.HeaderChecksum = headerChecksum;
packet.SourceAddress = sourceAddress;
packet.DestAddress = destAddress;
packet.OptionsAndPadding = optionsAndPadding;
return true;
}
}
}
catch (Exception)
{
packet = null;
return false;
}
}
public IPv4Config(IPv4Address ip, IPv4Address subnet)
: this(ip, subnet, IPv4Address.Zero)
{}
public void UpdateIPv4Address()
{
try
{
ipAddress = new IPv4Address(txtIPv4Address.Text);
isSelectClass = false;
cmbClass.SelectedIndex = (int)ipAddress.Class;
isSelectClass = !isSelectClass;
isValidIPAddress = true;
ipAddress.SubnetMask = new SubnetMask(cmbSubnetMask.Text);
picIPAddress.Image = Resources.icon_ok_20;
UpdatePropertiesPanel();
UpdateSubnetBitmap();
}
catch
{
picIPAddress.Image = Resources.icon_warning_20;
isValidIPAddress = false;
}
finally
{
UpdateSubnettingButton();
}
}
public IPv4Address NetworkIDAddress()
{
StringBuilder binNetworkIDAddr = new StringBuilder(ToBinaryString());
for (int i = SubnetMask.Prefix; i < 32; i++)
binNetworkIDAddr[i] = '0';
IPv4Address networkIDAddr = new IPv4Address(IPv4Address.ToOctetFromBinaryString(binNetworkIDAddr.ToString()),
SubnetMask, _class);
return networkIDAddr;
}
public IPv4Config(IPv4Address ip, IPv4Address subnet, IPv4Address gw)
{
this.address = ip;
this.subnetMask = subnet;
this.defaultGateway = gw;
}
internal static IPv4Address FindNetwork(IPv4Address destIP)
{
IPv4Address default_gw = null;
for (int c = 0; c < ipConfigs.Count; c++)
{
if ((ipConfigs[c].IPAddress.To32BitNumber() & ipConfigs[c].SubnetMask.To32BitNumber()) ==
(destIP.To32BitNumber() & ipConfigs[c].SubnetMask.To32BitNumber()))
{
return ipConfigs[c].IPAddress;
}
if ((default_gw == null) && (ipConfigs[c].DefaultGateway.CompareTo(IPv4Address.Zero) != 0))
{
default_gw = ipConfigs[c].IPAddress;
}
}
return default_gw;
}
/// <summary>
/// Find the previous address of current IPv4 address.
/// </summary>
/// <returns></returns>
public IPv4Address PreviousAddress()
{
IPv4Address nextAddr;
nextAddr = new IPv4Address(Octet[0].Decimal, Octet[1].Decimal, Octet[2].Decimal, Octet[3].Decimal);
for (int i = nextAddr.Octet.Length - 1; i >= 0; i--)
{
if (nextAddr.Octet[i].Decimal > 0)
{
nextAddr.Octet[i].Decimal--;
break;
}
else
nextAddr.Octet[i].Decimal = 255;
}
return nextAddr;
}
public void UpdateClass()
{
switch (cmbClass.SelectedIndex)
{
case 0:
ipAddress = isSelectClass ? new IPv4Address(IPv4Class.A) : new IPv4Address(txtIPv4Address.Text);
numPrefix.Minimum = 8;
break;
case 1:
ipAddress = isSelectClass ? new IPv4Address(IPv4Class.B) : new IPv4Address(txtIPv4Address.Text);
numPrefix.Minimum = 16;
break;
case 2:
ipAddress = isSelectClass ? new IPv4Address(IPv4Class.C) : new IPv4Address(txtIPv4Address.Text);
numPrefix.Minimum = 24;
break;
default:
break;
}
numPrefix.Value = ipAddress.SubnetMask.Prefix;
txtIPv4Address.Text = ipAddress.Address;
UpdatePropertiesPanel();
UpdateSubnetBitmap();
//Update Subnetmask combobox items
cmbSubnetMask.Items.Clear();
SubnetMask temp = new SubnetMask();
for (int i = SubnetMask.ToPrefix(ipAddress.Class); i < 31; i++)
{
temp.Prefix = i;
cmbSubnetMask.Items.Add(temp.ToString());
}
}
internal static bool IsLocalAddress(IPv4Address destIP)
{
for (int c = 0; c < ipConfigs.Count; c++)
{
if ((ipConfigs[c].IPAddress.To32BitNumber() & ipConfigs[c].SubnetMask.To32BitNumber()) ==
(destIP.To32BitNumber() & ipConfigs[c].SubnetMask.To32BitNumber()))
{
return true;
}
}
return false;
}
