public void SerializeAndDeserialize()
{
Random random = new Random();
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.Converters.Add(new IPv6AddressJsonConverter());
settings.Converters.Add(new DHCPv6ScopeAddressPropertiesConverter());
settings.Converters.Add(new DHCPv6PrefixDelgationInfoJsonConverter());
var input = new DHCPv6ScopeAddressProperties(
IPv6Address.FromString("fe80::1"), IPv6Address.FromString("fe80::A"),
new List <IPv6Address> {
IPv6Address.FromString("fe80::4"), IPv6Address.FromString("fe80::5")
},
DHCPv6TimeScale.FromDouble(0.5), DHCPv6TimeScale.FromDouble(0.7),
TimeSpan.FromMinutes(random.Next(10, 20)), TimeSpan.FromMinutes(random.Next(40, 60)),
random.NextBoolean(), DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next, random.NextBoolean(),
random.NextBoolean(), random.NextBoolean(), random.NextBoolean(),
DHCPv6PrefixDelgationInfo.FromValues(IPv6Address.FromString("2001:e68:5423:5ffd::0"), new IPv6SubnetMaskIdentifier(64), new IPv6SubnetMaskIdentifier(70)));
String serialized = JsonConvert.SerializeObject(input, settings);
var actual = JsonConvert.DeserializeObject <DHCPv6ScopeAddressProperties>(serialized, settings);
Assert.Equal(input, actual);
}
private static void AdjustTimeValues(DHCPv6ScopeAddressProperties addressProperties, DHCPv6Lease lease, out TimeSpan preferredLifetime, out TimeSpan validLifetime)
{
TimeSpan delta = DateTime.UtcNow - lease.Start;
preferredLifetime = addressProperties.PreferredLeaseTime.Value - delta;
validLifetime = addressProperties.ValidLeaseTime.Value - delta;
if (validLifetime.TotalMinutes < 0)
{
preferredLifetime = TimeSpan.FromMinutes(1);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var info = serializer.Deserialize <EeasySerialibleVersionOfDHCPv6ScopeAddressProperties>(reader);
DHCPv6ScopeAddressProperties result = new DHCPv6ScopeAddressProperties(info.Start, info.End, info.ExcludedAddresses,
t1: info.T1.HasValue == true ? DHCPv6TimeScale.FromDouble(info.T1.Value) : null,
t2: info.T2.HasValue == true ? DHCPv6TimeScale.FromDouble(info.T2.Value) : null,
preferredLifeTime: info.PreferredLeaseTime, validLifeTime: info.ValidLeaseTime, reuseAddressIfPossible: info.ReuseAddressIfPossible, addressAllocationStrategy: info.AddressAllocationStrategy,
supportDirectUnicast: info.SupportDirectUnicast, acceptDecline: info.AcceptDecline, informsAreAllowd: info.InformsAreAllowd,
rapitCommitEnabled: info.RapitCommitEnabled, info.PrefixDelgationInfo);
return(result);
}
public static DHCPv6Packet AsReply(DHCPv6Packet requestPacket, DHCPv6ScopeAddressProperties addressProperties, DHCPv6ScopeProperties properties, DHCPv6Lease lease, Boolean adjustTimers, DUID serverDuid, Boolean isRapitCommit)
{
DHCPv6Packet innerReceivedPacket = requestPacket.GetInnerPacket();
GetTimeValues(addressProperties, lease, adjustTimers, out TimeSpan preferredLifetime, out TimeSpan validLifetime, out TimeSpan T1, out TimeSpan T2);
List <DHCPv6PacketOption> packetOptions = new List <DHCPv6PacketOption>();
if (innerReceivedPacket.HasOption(DHCPv6PacketOptionTypes.IdentityAssociation_NonTemporary) == true)
{
packetOptions.Add(DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption.AsSuccess(
lease.IdentityAssocicationId, T1, T2, lease.Address, preferredLifetime, validLifetime));
}
if (innerReceivedPacket.HasOption(DHCPv6PacketOptionTypes.IdentityAssociation_PrefixDelegation) == true)
{
if (lease.PrefixDelegation == DHCPv6PrefixDelegation.None)
{
packetOptions.Add(DHCPv6PacketIdentityAssociationPrefixDelegationOption.NotAvailable(
innerReceivedPacket.GetOption <DHCPv6PacketIdentityAssociationPrefixDelegationOption>(DHCPv6PacketOptionTypes.IdentityAssociation_PrefixDelegation)));
}
else
{
packetOptions.Add(DHCPv6PacketIdentityAssociationPrefixDelegationOption.AsSuccess(lease.PrefixDelegation.IdentityAssociation, T1, T2, lease.PrefixDelegation.Mask.Identifier, lease.PrefixDelegation.NetworkAddress, preferredLifetime, validLifetime));
}
}
if (isRapitCommit == true)
{
packetOptions.Add(new DHCPv6PacketTrueOption(DHCPv6PacketOptionTypes.RapitCommit));
}
AddOptions(packetOptions, requestPacket, serverDuid, addressProperties, properties, false);
DHCPv6Packet innerResponse = new DHCPv6Packet(DHCPv6PacketTypes.REPLY,
innerReceivedPacket.TransactionId,
packetOptions);
DHCPv6Packet response = ConstructPacketWithHeader(requestPacket, innerResponse);
return(response);
}
private static void GetTimeValues(DHCPv6ScopeAddressProperties addressProperties, DHCPv6Lease lease, bool adjustTimers, out TimeSpan preferredLifetime, out TimeSpan validLifetime, out TimeSpan T1, out TimeSpan T2)
{
if (addressProperties.UseDynamicRewnewTime == true)
{
ApplyDynamicRenewTime(lease, out T1, out T2, out preferredLifetime, out validLifetime);
}
else
{
preferredLifetime = addressProperties.PreferredLeaseTime.Value;
validLifetime = addressProperties.ValidLeaseTime.Value;
T1 = addressProperties.T1.Value * preferredLifetime;
T2 = addressProperties.T2.Value * preferredLifetime;
if (adjustTimers == true)
{
AdjustTimeValues(addressProperties, lease, out preferredLifetime, out validLifetime);
}
}
}
public static DHCPv6Packet AsAdvertise(
DHCPv6Packet requestPacket,
DHCPv6Lease lease,
DHCPv6PrefixDelegation prefixDelegation,
DHCPv6ScopeAddressProperties addressProperties,
DHCPv6ScopeProperties properties,
DUID serverDuid
)
{
DHCPv6Packet innerReceivedPacket = requestPacket.GetInnerPacket();
GetTimeValues(addressProperties, lease, false, out TimeSpan preferredLifetime, out TimeSpan validLifetime, out TimeSpan T1, out TimeSpan T2);
List <DHCPv6PacketOption> packetOptions = new List <DHCPv6PacketOption>
{
DHCPv6PacketIdentityAssociationNonTemporaryAddressesOption.AsSuccess(innerReceivedPacket.GetNonTemporaryIdentityAssocationId().Value, T1, T2, lease.Address, preferredLifetime, validLifetime)
};
if (innerReceivedPacket.HasOption(DHCPv6PacketOptionTypes.IdentityAssociation_PrefixDelegation) == true)
{
if (prefixDelegation == DHCPv6PrefixDelegation.None)
{
packetOptions.Add(DHCPv6PacketIdentityAssociationPrefixDelegationOption.NotAvailable(
requestPacket.GetOption <DHCPv6PacketIdentityAssociationPrefixDelegationOption>(DHCPv6PacketOptionTypes.IdentityAssociation_PrefixDelegation)));
}
else
{
packetOptions.Add(DHCPv6PacketIdentityAssociationPrefixDelegationOption.AsSuccess(prefixDelegation.IdentityAssociation, T1, T2, prefixDelegation.Mask.Identifier, prefixDelegation.NetworkAddress, preferredLifetime, validLifetime));
}
}
AddOptions(packetOptions, requestPacket, serverDuid, addressProperties, properties, false);
DHCPv6Packet innerResponse = new DHCPv6Packet(DHCPv6PacketTypes.ADVERTISE,
innerReceivedPacket.TransactionId,
packetOptions);
DHCPv6Packet response = ConstructPacketWithHeader(requestPacket, innerResponse);
return(response);
}
public static DHCPv6Packet AsPrefixAdvertise(DHCPv6Packet requestPacket, DHCPv6ScopeAddressProperties addressProperties, DHCPv6ScopeProperties properties, DHCPv6Lease lease, DUID serverDuid)
{
DHCPv6Packet innerReceivedPacket = requestPacket.GetInnerPacket();
GetTimeValues(addressProperties, lease, false, out TimeSpan preferredLifetime, out TimeSpan validLifetime, out TimeSpan T1, out TimeSpan T2);
List <DHCPv6PacketOption> packetOptions = new List <DHCPv6PacketOption>
{
DHCPv6PacketIdentityAssociationPrefixDelegationOption.AsSuccess(lease.PrefixDelegation.IdentityAssociation, T1, T2, lease.PrefixDelegation.Mask.Identifier, lease.PrefixDelegation.NetworkAddress, preferredLifetime, validLifetime)
};
AddOptions(packetOptions, requestPacket, serverDuid, addressProperties, properties, false);
DHCPv6Packet innerResponse = new DHCPv6Packet(DHCPv6PacketTypes.ADVERTISE,
innerReceivedPacket.TransactionId,
packetOptions);
DHCPv6Packet response = ConstructPacketWithHeader(requestPacket, innerResponse);
return(response);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
DHCPv6ScopeAddressProperties item = (DHCPv6ScopeAddressProperties)value;
serializer.Serialize(writer, new EeasySerialibleVersionOfDHCPv6ScopeAddressProperties
{
AcceptDecline = item.AcceptDecline,
AddressAllocationStrategy = item.AddressAllocationStrategy,
End = item.End,
InformsAreAllowd = item.InformsAreAllowd,
RapitCommitEnabled = item.RapitCommitEnabled,
ReuseAddressIfPossible = item.ReuseAddressIfPossible,
Start = item.Start,
SupportDirectUnicast = item.SupportDirectUnicast,
PreferredLeaseTime = item.PreferredLeaseTime,
ValidLeaseTime = item.ValidLeaseTime,
ExcludedAddresses = item.ExcludedAddresses,
PrefixDelgationInfo = item.PrefixDelgationInfo,
T1 = item.T1?.Value,
T2 = item.T2?.Value,
});
}
public void DHCPv6Scope_AddressPropertiesInherientce()
{
Random random = new Random();
for (int i = 0; i < 100; i++)
{
IPv6Address grantParentStart = random.GetIPv6Address();
IPv6Address grantParentEnd = random.GetIPv6AddressGreaterThan(grantParentStart);
List <IPv6Address> grantParentExcludedAddresses = random.GetIPv6AddressesBetween(grantParentStart, grantParentEnd);
DHCPv6TimeScale grantParentT1 = DHCPv6TimeScale.FromDouble(0.2);
DHCPv6TimeScale grantParentT2 = DHCPv6TimeScale.FromDouble(0.6);
TimeSpan grantParentPreferredLifeTime = TimeSpan.FromMinutes(random.Next(10, 30));
TimeSpan grantParentValuidLifeTime = TimeSpan.FromMinutes(random.Next(40, 60));
Boolean grantParentReuseAddressIfPossible = random.NextBoolean();
var grantParentAllocationStrategy = DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next;
Boolean grantParentSupportDirectUnicast = random.NextBoolean();
Boolean grantParentAcceptDecline = random.NextBoolean();
Boolean grantParentInformsAreAllowd = random.NextBoolean();
DHCPv6ScopeAddressProperties grantParentProperties = new DHCPv6ScopeAddressProperties(
grantParentStart, grantParentEnd, grantParentExcludedAddresses,
grantParentT1, grantParentT2,
grantParentPreferredLifeTime, grantParentValuidLifeTime,
grantParentReuseAddressIfPossible, grantParentAllocationStrategy,
grantParentInformsAreAllowd, grantParentAcceptDecline, grantParentInformsAreAllowd,
null, DHCPv6PrefixDelgationInfo.FromValues(IPv6Address.FromString("2001:e68:5423:5ffd::0"), new IPv6SubnetMaskIdentifier(64), new IPv6SubnetMaskIdentifier(70)));
IPv6Address parentStart = random.GetIPv6Address();
IPv6Address parentEnd = random.GetIPv6AddressGreaterThan(parentStart);
List <IPv6Address> parentExcludedAddresses = random.GetIPv6AddressesBetween(parentStart, parentEnd);
TimeSpan? parentPreferedLifeTime = null;
TimeSpan? parentValuidLifetime = null;
DHCPv6TimeScale parentT1 = DHCPv6TimeScale.FromDouble(0.3);
DHCPv6TimeScale parentT2 = null;
Boolean?parentReuseAddressIfPossible = null;
DHCPv6ScopeAddressProperties.AddressAllocationStrategies?parentAllocationStrategy = null;
Boolean?parentSupportDirectUnicast = null;
Boolean?parentAcceptDecline = null;
Boolean?parentInformsAreAllowd = null;
if (random.NextBoolean() == true)
{
parentPreferedLifeTime = TimeSpan.FromMinutes(random.Next());
}
if (random.NextBoolean() == true)
{
parentValuidLifetime = TimeSpan.FromMinutes(random.Next());
}
if (random.NextBoolean() == true)
{
parentReuseAddressIfPossible = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
parentAllocationStrategy = DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Random;
}
if (random.NextBoolean() == true)
{
parentSupportDirectUnicast = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
parentAcceptDecline = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
parentInformsAreAllowd = random.NextBoolean();
}
DHCPv6ScopeAddressProperties parentProperties = new DHCPv6ScopeAddressProperties(
parentStart, parentEnd, parentExcludedAddresses,
parentT1, parentT2,
parentPreferedLifeTime, parentValuidLifetime,
parentReuseAddressIfPossible, parentAllocationStrategy,
parentInformsAreAllowd, parentAcceptDecline, parentInformsAreAllowd,
null, DHCPv6PrefixDelgationInfo.FromValues(IPv6Address.FromString("2001:e68:5423:5ffe::0"), new IPv6SubnetMaskIdentifier(64), new IPv6SubnetMaskIdentifier(70))
);
IPv6Address childStart = random.GetIPv6Address();
IPv6Address childEnd = random.GetIPv6AddressGreaterThan(childStart);
List <IPv6Address> childExcludedAddresses = random.GetIPv6AddressesBetween(childStart, childEnd);
DHCPv6TimeScale childT1 = null;
DHCPv6TimeScale childT2 = DHCPv6TimeScale.FromDouble(0.9);
TimeSpan?childPreferredLifeTime = null;
TimeSpan?childValidLifeTime = null;
Boolean?childReuseAddressIfPossible = null;
DHCPv6ScopeAddressProperties.AddressAllocationStrategies?childAllocationStrategy = null;
Boolean?childSupportDirectUnicast = random.NextDouble() > 0.5;
Boolean?childAcceptDecline = random.NextDouble() > 0.5;
Boolean?childInformsAreAllowd = random.NextDouble() > 0.5;
if (random.NextBoolean() == true)
{
childPreferredLifeTime = TimeSpan.FromMinutes(random.Next());
}
if (random.NextBoolean() == true)
{
childValidLifeTime = TimeSpan.FromMinutes(random.Next());
}
if (random.NextBoolean() == true)
{
childReuseAddressIfPossible = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
childAllocationStrategy = DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Random;
}
if (random.NextBoolean() == true)
{
childSupportDirectUnicast = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
childAcceptDecline = random.NextBoolean();
}
if (random.NextBoolean() == true)
{
childInformsAreAllowd = random.NextBoolean();
}
var childPrefixDelegationInfo = DHCPv6PrefixDelgationInfo.FromValues(IPv6Address.FromString("2001:e68:5423:5ffe::0"), new IPv6SubnetMaskIdentifier(64), new IPv6SubnetMaskIdentifier(70));
DHCPv6ScopeAddressProperties childProperties = new DHCPv6ScopeAddressProperties(
childStart, childEnd, childExcludedAddresses,
childT1, childT2,
childPreferredLifeTime, childValidLifeTime,
childReuseAddressIfPossible, childAllocationStrategy,
childSupportDirectUnicast, childAcceptDecline, childInformsAreAllowd,
null, childPrefixDelegationInfo
);
Guid grantParentId = Guid.NewGuid();
Guid parentId = Guid.NewGuid();
Guid childId = Guid.NewGuid();
List <DomainEvent> events = new List <DomainEvent>
{
new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction
{
Id = grantParentId,
AddressProperties = grantParentProperties,
}),
new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction
{
Id = parentId,
ParentId = grantParentId,
AddressProperties = parentProperties,
}),
new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction
{
Id = childId,
ParentId = parentId,
AddressProperties = childProperties,
}),
};
DHCPv6RootScope rootScope = GetRootScope();
rootScope.Load(events);
DHCPv6Scope scope = rootScope.GetScopeById(childId);
DHCPv6ScopeAddressProperties actualProperties = scope.GetAddressProperties();
DHCPv6ScopeAddressProperties expectedProperties = new DHCPv6ScopeAddressProperties(
childStart, childEnd, grantParentExcludedAddresses.Union(parentExcludedAddresses).Union(childExcludedAddresses).Where(x => x.IsBetween(childStart, childEnd)),
childT1 ?? (parentT1 ?? grantParentT1),
childT2 ?? (parentT2 ?? grantParentT2),
childPreferredLifeTime.HasValue == true ? childPreferredLifeTime.Value : (parentPreferedLifeTime.HasValue == true ? parentPreferedLifeTime.Value : grantParentPreferredLifeTime),
childValidLifeTime.HasValue == true ? childValidLifeTime.Value : (parentValuidLifetime.HasValue == true ? parentValuidLifetime.Value : grantParentValuidLifeTime),
childReuseAddressIfPossible.HasValue == true ? childReuseAddressIfPossible.Value : (parentReuseAddressIfPossible.HasValue == true ? parentReuseAddressIfPossible.Value : grantParentReuseAddressIfPossible),
childAllocationStrategy.HasValue == true ? childAllocationStrategy.Value : (parentAllocationStrategy.HasValue == true ? parentAllocationStrategy.Value : grantParentAllocationStrategy),
childSupportDirectUnicast.HasValue == true ? childSupportDirectUnicast.Value : (parentSupportDirectUnicast.HasValue == true ? parentSupportDirectUnicast.Value : grantParentSupportDirectUnicast),
childAcceptDecline.HasValue == true ? childAcceptDecline.Value : (parentAcceptDecline.HasValue == true ? parentAcceptDecline.Value : grantParentAcceptDecline),
childInformsAreAllowd.HasValue == true ? childInformsAreAllowd.Value : (parentInformsAreAllowd.HasValue == true ? parentInformsAreAllowd.Value : grantParentInformsAreAllowd),
null,
childPrefixDelegationInfo
);
Assert.Equal(expectedProperties, actualProperties);
}
}
public static DHCPv6Packet AsPrefixReplyWithRapitCommit(DHCPv6Packet requestPacket, DHCPv6ScopeAddressProperties addressProperties, DHCPv6ScopeProperties properties, DHCPv6Lease lease, DUID serverDuid)
{
DHCPv6Packet response = AsPrefixAdvertise(requestPacket, addressProperties, properties, lease, serverDuid);
AddRapitCommitOption(response);
return(response);
}
private static void AddOptions(ICollection <DHCPv6PacketOption> packetOptions, DHCPv6Packet requestPacket, DUID serverDuid, DHCPv6ScopeAddressProperties addressProperties, DHCPv6ScopeProperties properties, Boolean onlyMinimialOptions)
{
DHCPv6Packet innerReceivedPacket = requestPacket.GetInnerPacket();
packetOptions.Add(new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ServerIdentifer, serverDuid));
packetOptions.Add(new DHCPv6PacketIdentifierOption(DHCPv6PacketOptionTypes.ClientIdentifier, innerReceivedPacket.GetClientIdentifer()));
if (onlyMinimialOptions == true)
{
return;
}
if (addressProperties?.SupportDirectUnicast == true)
{
packetOptions.Add(new DHCPv6PacketIPAddressOption(DHCPv6PacketOptionTypes.ServerUnicast, requestPacket.Header.ListenerAddress));
}
foreach (var item in properties?.Properties)
{
switch (item)
{
case DHCPv6AddressListScopeProperty property:
packetOptions.Add(new DHCPv6PacketIPAddressListOption(property.OptionIdentifier, property.Addresses));
break;
case DHCPv6NumericValueScopeProperty property:
switch (property.NumericType)
{
case NumericScopePropertiesValueTypes.Byte:
packetOptions.Add(new DHCPv6PacketByteOption(property.OptionIdentifier, (Byte)property.Value));
break;
case NumericScopePropertiesValueTypes.UInt16:
packetOptions.Add(new DHCPv6PacketUInt16Option(property.OptionIdentifier, (UInt16)property.Value));
break;
case NumericScopePropertiesValueTypes.UInt32:
packetOptions.Add(new DHCPv6PacketUInt32Option(property.OptionIdentifier, (UInt32)property.Value));
break;
default:
break;
}
break;
default:
break;
}
}
}
