public void FromByteArray_BooleanOption() { Random random = new Random(); UInt32 transactionId = (UInt32)random.Next(0, 256 * 256 * 256); IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); UInt16 firstIdentifier = 4000; UInt16 secondIdentifier = 4002; DHCPv6Packet packet = new DHCPv6Packet(header, transactionId, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketBooleanOption(firstIdentifier, true), new DHCPv6PacketBooleanOption(secondIdentifier, false), } ); try { DHCPv6PacketOptionFactory.AddOptionType(firstIdentifier, (data) => DHCPv6PacketBooleanOption.FromByteArray(data, 0), true); DHCPv6PacketOptionFactory.AddOptionType(secondIdentifier, (data) => DHCPv6PacketBooleanOption.FromByteArray(data, 0), true); CheckByteRepresentation(packet, header); } finally { DHCPv6PacketOptionFactory.RemoveOptionType(firstIdentifier); DHCPv6PacketOptionFactory.RemoveOptionType(secondIdentifier); } }
public void FromByteArray_IPAddressOption() { Random random = new Random(); UInt32 transactionId = (UInt32)random.Next(0, 256 * 256 * 256); IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); UInt16 identifier = 6000; DHCPv6Packet packet = new DHCPv6Packet(header, transactionId, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketIPAddressOption(DHCPv6PacketOptionTypes.ServerUnicast, IPv6Address.FromString("fe80::1")), new DHCPv6PacketIPAddressOption(identifier, IPv6Address.FromString("fe80::2")), } ); try { DHCPv6PacketOptionFactory.AddOptionType(identifier, (data) => DHCPv6PacketIPAddressOption.FromByteArray(data, 0), true); CheckByteRepresentation(packet, header); } finally { DHCPv6PacketOptionFactory.RemoveOptionType(identifier); } }
private DHCPv6Packet GetPacket(Random random, Byte[] remoteId, Int32 slotId, Int32 portId, Int32 enterpriseId = 0, Boolean includeRelevantOptions = true) { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); var packetOptions = new List <DHCPv6PacketOption> { new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit), }; DHCPv6Packet innerPacket = DHCPv6Packet.AsInner(random.NextUInt16(), DHCPv6PacketTypes.Solicit, packetOptions); DHCPv6Packet innerRelayPacket = DHCPv6RelayPacket.AsInnerRelay(true, 1, random.GetIPv6Address(), random.GetIPv6Address(), new DHCPv6PacketOption[] { new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, new UUIDDUID(random.NextGuid())), includeRelevantOptions == true ? (DHCPv6PacketOption)(new DHCPv6PacketRemoteIdentifierOption((UInt32)enterpriseId, remoteId)) : new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit), includeRelevantOptions == true ? (DHCPv6PacketOption)(new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, GetExpectedByteSequence(slotId, portId))) : new DHCPv6PacketTimeOption(DHCPv6PacketOptionTypes.ElapsedTime, 10, DHCPv6PacketTimeOption.DHCPv6PacketTimeOptionUnits.Minutes) }, innerPacket); DHCPv6Packet outerRelayPacket = DHCPv6RelayPacket.AsOuterRelay(headerInformation, true, 1, random.GetIPv6Address(), random.GetIPv6Address(), new DHCPv6PacketOption[] { new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, random.NextBytes(10)), new DHCPv6PacketRemoteIdentifierOption(9, random.NextBytes(12)) }, innerRelayPacket); return(outerRelayPacket); }
private DHCPv6Packet GetPacket(Random random, Byte[] remoteId, Boolean includeRemoteIdOption = true) { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); var packetOptions = new List <DHCPv6PacketOption> { new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit), }; DHCPv6Packet innerPacket = DHCPv6Packet.AsInner(random.NextUInt16(), DHCPv6PacketTypes.Solicit, packetOptions); DHCPv6Packet innerRelayPacket = DHCPv6RelayPacket.AsInnerRelay(true, 1, random.GetIPv6Address(), random.GetIPv6Address(), new DHCPv6PacketOption[] { new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, random.NextBytes(10)), includeRemoteIdOption == true ? (DHCPv6PacketOption)(new DHCPv6PacketRemoteIdentifierOption(3561, remoteId)) : new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit) }, innerPacket); DHCPv6Packet outerRelayPacket = DHCPv6RelayPacket.AsOuterRelay(headerInformation, true, 1, random.GetIPv6Address(), random.GetIPv6Address(), new DHCPv6PacketOption[] { new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, random.NextBytes(10)), new DHCPv6PacketRemoteIdentifierOption(9, random.NextBytes(12)) }, innerRelayPacket); return(outerRelayPacket); }
public void IsEqual() { IPv6HeaderInformation header1 = new IPv6HeaderInformation( IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2") ); IPv6HeaderInformation header2 = new IPv6HeaderInformation( IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2") ); IPv6HeaderInformation header3 = new IPv6HeaderInformation( IPv6Address.FromString("fe80::2"), IPv6Address.FromString("fe80::1") ); Assert.True(header1.Equals(header1)); Assert.True(header1.Equals(header2)); Assert.True(header2.Equals(header1)); Assert.True(header2.Equals(header2)); Assert.Equal(header1, header2); Assert.Equal(header2, header1); Assert.Equal(header1, header1); Assert.Equal(header2, header2); Assert.False(header1.Equals(header3)); Assert.False(header3.Equals(header1)); Assert.False(header2.Equals(header3)); Assert.False(header3.Equals(header2)); Assert.NotEqual(header1, header3); Assert.NotEqual(header3, header1); Assert.NotEqual(header2, header3); Assert.NotEqual(header3, header2); }
private DHCPv6Packet GetReleasePacket( Random random, out IPv6Address usedAddress, out DUID clientDuid, out UInt32 iaId, Boolean withIdentity, params DHCPv6PacketOption[] options) { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); clientDuid = new UUIDDUID(random.NextGuid()); iaId = random.NextBoolean() == false?random.NextUInt32() : 0; usedAddress = random.GetIPv6Address(); var packetOptions = new List <DHCPv6PacketOption>(options) { new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, clientDuid), }; if (withIdentity == true) { packetOptions.Add(new DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption(iaId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[] { new DHCPv6PacketIdentityAssociationAddressSuboption(usedAddress, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), Array.Empty <DHCPv6PacketSuboption>()) })); } DHCPv6Packet packet = DHCPv6Packet.AsOuter(headerInformation, random.NextUInt16(), DHCPv6PacketTypes.RELEASE, packetOptions); return(packet); }
public void FromByteArray_RelayPacket_SingleRelayPacket() { Random random = new Random(); UInt32 transactionId = (UInt32)random.Next(0, 256 * 256 * 256); IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); DHCPv6Packet innerPacket = DHCPv6Packet.AsInner(transactionId, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit), new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.ReconfigureAccepte), }); DHCPv6RelayPacket relayPacket = DHCPv6RelayPacket.AsOuterRelay( header, true, random.NextByte(), IPv6Address.FromString("fe80::acde"), IPv6Address.FromString("fe80::acdf"), new List <DHCPv6PacketOption> { new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, random.NextBytes(23)), new DHCPv6PacketRemoteIdentifierOption(random.NextUInt32(), random.NextBytes(15)) }, innerPacket); CheckByteRepresentation(relayPacket, header); }
public async Task Handle_ResponseAvaiable() { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation( IPv6Address.FromString("fe80::2"), IPv6Address.FromString("fe80::1")); DHCPv6Packet packet = DHCPv6Packet.AsOuter(headerInformation, 1, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption>()); DHCPv6Packet reseponsePacket = DHCPv6Packet.AsOuter(IPv6HeaderInformation.AsResponse(headerInformation), 1, DHCPv6PacketTypes.ADVERTISE, new List <DHCPv6PacketOption>()); Mock <IDHCPv6LeaseEngine> leaseEngineMock = new Mock <IDHCPv6LeaseEngine>(MockBehavior.Strict); leaseEngineMock.Setup(x => x.HandlePacket(packet)).ReturnsAsync(reseponsePacket).Verifiable(); Mock <IServiceBus> serviceBusMock = new Mock <IServiceBus>(MockBehavior.Strict); serviceBusMock.Setup(x => x.Publish(It.Is <DHCPv6PacketReadyToSendMessage>(y => y.Packet == reseponsePacket))).Returns(Task.CompletedTask).Verifiable(); ValidDHCPv6PacketArrivedMessageHandler handler = new ValidDHCPv6PacketArrivedMessageHandler( serviceBusMock.Object, leaseEngineMock.Object, Mock.Of <ILogger <ValidDHCPv6PacketArrivedMessageHandler> >()); await handler.Handle(new ValidDHCPv6PacketArrivedMessage(packet), CancellationToken.None); leaseEngineMock.Verify(); serviceBusMock.Verify(); }
public void SerializeAndDeserialize() { Random random = new Random(); JsonSerializerSettings settings = new JsonSerializerSettings(); settings.Converters.Add(new IPv6AddressJsonConverter()); settings.Converters.Add(new DHCPv6PacketJsonConverter()); settings.Converters.Add(new IPv6HeaderInformationJsonConverter()); IPv6HeaderInformation header = new IPv6HeaderInformation( random.GetIPv6Address(), random.GetIPv6Address()); DHCPv6Packet input = new DHCPv6Packet(header, random.NextUInt16(), DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, new UUIDDUID(Guid.NewGuid())), new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ServerIdentifer, new UUIDDUID(Guid.NewGuid())), } ); String serialized = JsonConvert.SerializeObject(input, settings); var actual = JsonConvert.DeserializeObject <DHCPv6Packet>(serialized, settings); Assert.Equal(input, actual); }
public void GetInnerPacket_MultipleEncapsulated() { IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); Int32 depth = 10; DHCPv6Packet expectedInnerPacket = DHCPv6Packet.AsInner(1, DHCPv6PacketTypes.REPLY, Array.Empty <DHCPv6PacketOption>()); DHCPv6Packet innerPacket = expectedInnerPacket; for (int i = 0; i < depth; i++) { DHCPv6RelayPacket outerPacket = DHCPv6RelayPacket.AsInnerRelay( true, 1, IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2"), Array.Empty <DHCPv6PacketOption>(), innerPacket); innerPacket = outerPacket; } DHCPv6RelayPacket inputPacket = DHCPv6RelayPacket.AsOuterRelay( header, true, 1, IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2"), Array.Empty <DHCPv6PacketOption>(), innerPacket); DHCPv6Packet actualInnerPacket = inputPacket.GetInnerPacket(); Assert.Equal(expectedInnerPacket, actualInnerPacket); }
public void FromByteArray_IdentityAssociationForPrefixAddressesOption() { Random random = new Random(); UInt32 transactionId = (UInt32)random.Next(0, 256 * 256 * 256); IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); DHCPv6Packet packet = new DHCPv6Packet(header, transactionId, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketIdentityAssociationPrefixDelegationOption( random.NextUInt16(), TimeSpan.FromSeconds(random.Next(0, 36000)), TimeSpan.FromSeconds(random.Next(0, 36000)), new List <DHCPv6PacketSuboption> { new DHCPv6PacketIdentityAssociationPrefixDelegationSuboption( TimeSpan.FromSeconds(random.Next(0, 36000)), TimeSpan.FromSeconds(random.Next(0, 36000)), random.NextByte(), IPv6Address.FromString("fe80::20"), new List <DHCPv6PacketSuboption>() { new DHCPv6PacketStatusCodeSuboption(DHCPv6StatusCodes.Success, "Thanks for using DaAPI") } ) } ), new DHCPv6PacketIPAddressOption(DHCPv6PacketOptionTypes.ServerUnicast, IPv6Address.FromString("fe80::1")), } ); CheckByteRepresentation(packet, header); }
public async Task HandleInvalidPacket() { Random random = new Random(); String dbName = $"{random.Next()}"; var(client, serviceBus) = GetTestClient(dbName); try { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation( IPv6Address.FromString("fe80::2"), IPv6Address.FromString("fe80::1")); DHCPv6Packet packet = DHCPv6RelayPacket.AsOuterRelay(headerInformation, true, 1, IPv6Address.FromString("fe80::3"), IPv6Address.FromString("fe80::4"), Array.Empty <DHCPv6PacketOption>(), DHCPv6Packet.AsInner(1, DHCPv6PacketTypes.ADVERTISE, new List <DHCPv6PacketOption>())); var message = new DHCPv6PacketArrivedMessage(packet); await serviceBus.Publish(message); await Task.Delay(2000); StorageContext initicalContext = DatabaseTestingUtility.GetTestDatabaseContext(dbName); Int32 tries = 10; while (tries-- > 0) { if (initicalContext.DHCPv6PacketEntries.Count() == 1) { break; } await Task.Delay(1000); } Assert.Equal(1, await initicalContext.DHCPv6PacketEntries.AsQueryable().CountAsync()); var firstEntry = await initicalContext.DHCPv6PacketEntries.AsQueryable().FirstAsync(); Assert.NotEqual(Guid.Empty, firstEntry.Id); Assert.False(firstEntry.InvalidRequest); Assert.Equal(packet.GetSize(), firstEntry.RequestSize); Assert.Equal(DHCPv6PacketTypes.ADVERTISE, firstEntry.RequestType); Assert.Equal(nameof(DHCPv6PacketConsistencyFilter), firstEntry.FilteredBy); Assert.True((DateTime.UtcNow - firstEntry.Timestamp).TotalSeconds < 20); Assert.NotEqual(DateTime.MinValue, firstEntry.TimestampDay); Assert.NotEqual(DateTime.MinValue, firstEntry.TimestampWeek); Assert.NotEqual(DateTime.MinValue, firstEntry.TimestampMonth); } finally { await DatabaseTestingUtility.DeleteDatabase(dbName); } }
private void CheckByteRepresentation(DHCPv6Packet input, IPv6HeaderInformation header) { Byte[] rawStream = new Byte[1800]; Int32 writtenBytes = input.GetAsStream(rawStream); Byte[] stream = ByteHelper.CopyData(rawStream, 0, writtenBytes); DHCPv6Packet secondPacket = DHCPv6Packet.FromByteArray(stream, header); Assert.Equal(input, secondPacket); }
public void AsReponse() { IPv6HeaderInformation requestHeader = new IPv6HeaderInformation( IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2") ); IPv6HeaderInformation responseHeader = IPv6HeaderInformation.AsResponse(requestHeader); Assert.Equal(requestHeader.Destionation, responseHeader.Source); Assert.Equal(requestHeader.Source, responseHeader.Destionation); }
public void ConstructPacket_MultipleRelayPackets() { IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); Int32 depth = 10; DHCPv6Packet receivedInnerPacket = DHCPv6Packet.AsInner(1, DHCPv6PacketTypes.Solicit, Array.Empty <DHCPv6PacketOption>()); DHCPv6Packet innerPacket = receivedInnerPacket; List <IPv6Address> expectedLinkAddresses = new List <IPv6Address>(); for (int i = 0; i < depth; i++) { IPv6Address linkAddress = IPv6Address.FromString($"fe{i}::1"); DHCPv6RelayPacket outerPacket = DHCPv6RelayPacket.AsInnerRelay( true, 1, linkAddress, IPv6Address.FromString($"fe{i}::2"), Array.Empty <DHCPv6PacketOption>(), innerPacket); innerPacket = outerPacket; expectedLinkAddresses.Insert(0, linkAddress); } DHCPv6RelayPacket inputPacket = DHCPv6RelayPacket.AsOuterRelay( header, true, 1, IPv6Address.FromString("ff70::1"), IPv6Address.FromString("fe80::2"), Array.Empty <DHCPv6PacketOption>(), innerPacket); expectedLinkAddresses.Insert(0, IPv6Address.FromString("ff70::1")); DHCPv6Packet sendInnerPacket = DHCPv6Packet.AsInner(1, DHCPv6PacketTypes.ADVERTISE, Array.Empty <DHCPv6PacketOption>()); DHCPv6Packet packet = DHCPv6Packet.ConstructPacket(inputPacket, sendInnerPacket); Assert.IsAssignableFrom <DHCPv6RelayPacket>(packet); DHCPv6RelayPacket relayPacket = (DHCPv6RelayPacket)packet; DHCPv6Packet innerUsedPacket = relayPacket.GetInnerPacket(); Assert.Equal(sendInnerPacket, innerUsedPacket); for (int i = 0; i < expectedLinkAddresses.Count; i++) { DHCPv6RelayPacket innerRelayPacket = GetInnerRelayPacket(relayPacket, i); Assert.Equal(innerRelayPacket.LinkAddress, expectedLinkAddresses[i]); Assert.Equal((Byte)(expectedLinkAddresses.Count - i - 1), innerRelayPacket.HopCount); } }
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { IPv6HeaderInformation item = (IPv6HeaderInformation)value; serializer.Serialize(writer, new EeasySerialibleVersionOfIPv6HeaderInformationJsonConverter { Destination = item.Destionation, Source = item.Source, Listener = item.ListenerAddress, });; }
private DHCPv6Packet GetRelayedRenewPacket( Random random, out IPv6Address usedAddress, out DUID clientDuid, out UInt32 iaId, Boolean withIdentity, params DHCPv6PacketOption[] options) { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::1")); DHCPv6Packet innerPacket = GetRenewPacket(random, out usedAddress, out clientDuid, out iaId, withIdentity, options); DHCPv6Packet packet = DHCPv6RelayPacket.AsOuterRelay(headerInformation, true, 1, random.GetIPv6Address(), random.GetIPv6Address(), Array.Empty <DHCPv6PacketOption>(), innerPacket); return(packet); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { var info = serializer.Deserialize <EeasySerialibleVersionOfIPv6HeaderInformationJsonConverter>(reader); if (info == null) { return(null); } IPv6HeaderInformation result = new IPv6HeaderInformation(info.Source, info.Destination, info.Listener); return(result); }
private DHCPv6Packet GetRelayedReleasePacket( Random random, out IPv6Address usedAddress, out DUID clientDuid, out UInt32 iaId, Boolean withIdentity, params DHCPv6PacketOption[] options) { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); DHCPv6Packet innerPacket = GetReleasePacket(random, out usedAddress, out clientDuid, out iaId, withIdentity, options); DHCPv6Packet packet = DHCPv6RelayPacket.AsOuterRelay(headerInformation, true, 1, random.GetIPv6Address(), random.GetIPv6Address(), new DHCPv6PacketOption[] { new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, random.NextBytes(10)) }, innerPacket); return(packet); }
private DHCPv6Packet GetRandomPacket(Random random) { IPv6HeaderInformation header = new IPv6HeaderInformation( random.GetIPv6Address(), random.GetIPv6Address()); DHCPv6Packet input = new DHCPv6Packet(header, random.NextUInt16(), DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, new UUIDDUID(Guid.NewGuid())), new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ServerIdentifer, new UUIDDUID(Guid.NewGuid())), } ); return(input); }
public void SerializeAndDeserialize_Null() { IPv6HeaderInformation input = null; JsonSerializerSettings settings = new JsonSerializerSettings(); settings.Converters.Add(new IPv6AddressJsonConverter()); settings.Converters.Add(new IPv6HeaderInformationJsonConverter()); String serialized = JsonConvert.SerializeObject(input, settings); var actual = JsonConvert.DeserializeObject <IPv6HeaderInformation>(serialized, settings); Assert.Null(actual); }
private DHCPv6Packet GetRelayedConfirmPacket( Random random, out IPv6Address usedAddress, out DUID clientDuid, out UInt32 iaId, out DHCPv6PrefixDelegation prefixDelegation, Boolean withAddress, Boolean withPrefix) { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); clientDuid = new UUIDDUID(random.NextGuid()); usedAddress = IPv6Address.Empty; prefixDelegation = DHCPv6PrefixDelegation.None; iaId = 0; var packetOptions = new List <DHCPv6PacketOption>() { new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, clientDuid), }; if (withAddress == true) { iaId = random.NextUInt32(); usedAddress = random.GetIPv6Address(); packetOptions.Add(new DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption(iaId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[] { new DHCPv6PacketIdentityAssociationAddressSuboption(usedAddress, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), Array.Empty <DHCPv6PacketSuboption>()) })); } if (withPrefix == true) { IPv6Address prefix = IPv6Address.FromString("2acd:adce::0"); UInt32 prefixId = random.NextBoolean() == false?random.NextUInt32() : 0; Byte mask = (Byte)random.Next(64, 80); prefixDelegation = DHCPv6PrefixDelegation.FromValues(prefix, new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(mask)), prefixId); packetOptions.Add(new DHCPv6PacketIdentityAssociationPrefixDelegationOption(prefixId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[] { new DHCPv6PacketIdentityAssociationPrefixDelegationSuboption(TimeSpan.Zero, TimeSpan.Zero, mask, prefix, Array.Empty <DHCPv6PacketSuboption>()) })); } DHCPv6Packet innerPacket = DHCPv6Packet.AsInner(random.NextUInt16(), DHCPv6PacketTypes.CONFIRM, packetOptions); DHCPv6Packet packet = DHCPv6RelayPacket.AsOuterRelay(headerInformation, true, 1, random.GetIPv6Address(), random.GetIPv6Address(), new DHCPv6PacketOption[] { new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, random.NextBytes(10)) }, innerPacket); return(packet); }
public void FromByteArray_TimeOption() { Random random = new Random(); UInt32 transactionId = (UInt32)random.Next(0, 256 * 256 * 256); IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); DHCPv6Packet packet = new DHCPv6Packet(header, transactionId, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketTimeOption(DHCPv6PacketOptionTypes.ElapsedTime, random.NextUInt32(), DHCPv6PacketTimeOption.DHCPv6PacketTimeOptionUnits.HundredsOfSeconds), new DHCPv6PacketTimeOption(DHCPv6PacketOptionTypes.InformationRefreshTime, random.NextUInt32(), DHCPv6PacketTimeOption.DHCPv6PacketTimeOptionUnits.Seconds), } ); CheckByteRepresentation(packet, header); }
public void FromByteArray_ByteArrayOption() { Random random = new Random(); UInt32 transactionId = (UInt32)random.Next(0, 256 * 256 * 256); IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); DHCPv6Packet packet = new DHCPv6Packet(header, transactionId, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketByteArrayOption(DHCPv6PacketOptionTypes.InterfaceId, random.NextBytes(20)), new DHCPv6PacketByteArrayOption(157, random.NextBytes(20)), } ); CheckByteRepresentation(packet, header); }
public void FromByteArray_IdentifierOption() { Random random = new Random(); UInt32 transactionId = (UInt32)random.Next(0, 256 * 256 * 256); IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); DHCPv6Packet packet = new DHCPv6Packet(header, transactionId, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, new UUIDDUID(Guid.NewGuid())), new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ServerIdentifer, new UUIDDUID(Guid.NewGuid())), } ); CheckByteRepresentation(packet, header); }
public void FromByteArray_TrueOption() { Random random = new Random(); UInt32 transactionId = (UInt32)random.Next(0, 256 * 256 * 256); IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); DHCPv6Packet packet = new DHCPv6Packet(header, transactionId, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit), new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.ReconfigureAccepte), } ); CheckByteRepresentation(packet, header); }
public void FromByteArray_VendorClassOption() { Random random = new Random(); UInt32 transactionId = (UInt32)random.Next(0, 256 * 256 * 256); IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); DHCPv6Packet packet = new DHCPv6Packet(header, transactionId, DHCPv6PacketTypes.Solicit, new List <DHCPv6PacketOption> { new DHCPv6PacketVendorClassOption(random.NextUInt32(), random.NextByteArrays(10, 15, 30)), new DHCPv6PacketIPAddressOption(DHCPv6PacketOptionTypes.ServerUnicast, IPv6Address.FromString("fe80::1")), } ); CheckByteRepresentation(packet, header); }
public void GetInnerPacket_SingleEncapsulated() { IPv6HeaderInformation header = new IPv6HeaderInformation(IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2")); DHCPv6Packet innerPacket = DHCPv6Packet.AsInner(1, DHCPv6PacketTypes.REPLY, Array.Empty <DHCPv6PacketOption>()); DHCPv6RelayPacket outerPacket = DHCPv6RelayPacket.AsOuterRelay( header, true, 1, IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::2"), Array.Empty <DHCPv6PacketOption>(), innerPacket); DHCPv6Packet actualInnerPacket = outerPacket.GetInnerPacket(); Assert.Equal(innerPacket, actualInnerPacket); }
public void SerializeAndDeserialize() { Random random = new Random(); var input = new IPv6HeaderInformation( random.GetIPv6Address(), random.GetIPv6Address()); JsonSerializerSettings settings = new JsonSerializerSettings(); settings.Converters.Add(new IPv6AddressJsonConverter()); settings.Converters.Add(new IPv6HeaderInformationJsonConverter()); String serialized = JsonConvert.SerializeObject(input, settings); var actual = JsonConvert.DeserializeObject <IPv6HeaderInformation>(serialized, settings); Assert.Equal(input.Source, actual.Source); Assert.Equal(input.Destionation, actual.Destionation); }
public async Task Handle() { IPv6HeaderInformation headerInformation = new IPv6HeaderInformation( IPv6Address.FromString("fe80::2"), IPv6Address.FromString("fe80::1")); DHCPv6Packet response = DHCPv6Packet.AsOuter(headerInformation, 1, DHCPv6PacketTypes.ADVERTISE, new List <DHCPv6PacketOption>()); Mock <IDHCPv6InterfaceEngine> interfaceEngine = new Mock <IDHCPv6InterfaceEngine>(MockBehavior.Strict); interfaceEngine.Setup(x => x.SendPacket(response)).Returns(true).Verifiable(); DHCPv6PacketReadyToSendMessageHandler handler = new DHCPv6PacketReadyToSendMessageHandler( interfaceEngine.Object, Mock.Of <ILogger <DHCPv6PacketReadyToSendMessageHandler> >()); await handler.Handle(new DHCPv6PacketReadyToSendMessage(response), CancellationToken.None); interfaceEngine.Verify(); }