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