protected static void CheckLeaseRenewdEvent(
Guid scopeId,
DHCPv6RootScope rootScope, DHCPv6Lease lease, Boolean expectReset, Boolean expectedPrefixReset)
{
IEnumerable <DomainEvent> changes = rootScope.GetChanges();
Assert.NotNull(changes);
Assert.Equal(2, changes.Count());
Assert.IsAssignableFrom <DHCPv6LeaseRenewedEvent>(changes.First());
DHCPv6LeaseRenewedEvent createdEvent = (DHCPv6LeaseRenewedEvent)changes.First();
Assert.NotNull(createdEvent);
Assert.Equal(scopeId, createdEvent.ScopeId);
Assert.NotEqual(Guid.Empty, lease.Id);
Assert.Equal(lease.Id, createdEvent.EntityId);
Assert.Equal(expectReset, createdEvent.Reset);
Assert.Equal(expectedPrefixReset, createdEvent.ResetPrefix);
Assert.Equal(lease.End, createdEvent.End);
var addressProperties = rootScope.GetScopeById(scopeId).AddressRelatedProperties;
Assert.True(Math.Abs(((addressProperties.T1.Value * addressProperties.ValidLeaseTime.Value) - createdEvent.RenewSpan).TotalSeconds) < 20);
Assert.True(Math.Abs(((addressProperties.T2.Value * addressProperties.ValidLeaseTime.Value) - createdEvent.ReboundSpan).TotalSeconds) < 20);
}
private static void ApplyDynamicRenewTime(DHCPv6Lease lease, out TimeSpan T1, out TimeSpan T2, out TimeSpan preferredLifetime, out TimeSpan validLifetime)
{
T1 = lease.RenewSpan;
T2 = lease.RebindingSpan;
preferredLifetime = lease.RebindingSpan;
validLifetime = lease.End - DateTime.UtcNow;
}
public void GetLeaseById()
{
Random random = new Random();
DHCPv6RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
List <DomainEvent> events = new List <DomainEvent>
{
new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction
{
Id = scopeId,
}),
};
Int32 leaseAmount = random.Next(3, 10);
HashSet <Guid> existingIds = new HashSet <Guid>();
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = Guid.NewGuid();
events.Add(new DHCPv6LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
Address = random.GetIPv6Address(),
ClientIdentifier = new UUIDDUID(random.NextGuid()),
});
existingIds.Add(leaseId);
}
rootScope.Load(events);
DHCPv6Scope scope = rootScope.GetRootScopes().First();
foreach (Guid leaseId in existingIds)
{
DHCPv6Lease lease = scope.Leases.GetLeaseById(leaseId);
Assert.True(lease != DHCPv6Lease.Empty);
}
Int32 notExisitngAmount = random.Next(30, 100);
for (int i = 0; i < notExisitngAmount; i++)
{
Guid id = Guid.NewGuid();
if (existingIds.Contains(id) == true)
{
continue;
}
DHCPv6Lease lease = scope.Leases.GetLeaseById(id);
Assert.True(lease == DHCPv6Lease.Empty);
}
}
protected static void CheckLeaseCreatedEvent(
Int32 index, DUID clientDuid, UInt32 iaId,
Guid scopeId, DHCPv6RootScope rootScope,
IPv6Address expectedAdress, DHCPv6Lease lease,
Byte[] uniqueIdentifier = null,
Guid?ancestorId = null,
Boolean checkLeaseTimes = true
)
{
IEnumerable <DomainEvent> changes = rootScope.GetChanges();
Assert.NotNull(changes);
Assert.IsAssignableFrom <DHCPv6LeaseCreatedEvent>(changes.ElementAt(index));
DHCPv6LeaseCreatedEvent createdEvent = (DHCPv6LeaseCreatedEvent)changes.ElementAt(index);
Assert.NotNull(createdEvent);
Assert.Equal(scopeId, createdEvent.ScopeId);
Assert.Equal(expectedAdress, createdEvent.Address);
Assert.Equal(clientDuid, createdEvent.ClientIdentifier);
Assert.Equal(iaId, createdEvent.IdentityAssocationId);
Assert.Equal(lease.Id, createdEvent.EntityId);
Assert.Equal(ancestorId, createdEvent.AncestorId);
if (uniqueIdentifier == null)
{
Assert.Null(createdEvent.UniqueIdentiifer);
}
else
{
Assert.Equal(uniqueIdentifier, createdEvent.UniqueIdentiifer);
}
Assert.Equal(lease.Start, createdEvent.StartedAt);
Assert.Equal(lease.End, createdEvent.ValidUntil);
var addressProperties = rootScope.GetScopeById(scopeId).AddressRelatedProperties;
if (checkLeaseTimes == true)
{
Assert.Equal(addressProperties.T1.Value * addressProperties.ValidLeaseTime.Value, createdEvent.RenewalTime);
Assert.Equal(addressProperties.T2.Value * addressProperties.ValidLeaseTime.Value, createdEvent.PreferredLifetime);
}
if (lease.PrefixDelegation == DHCPv6PrefixDelegation.None)
{
Assert.Equal(IPv6Address.Empty, createdEvent.DelegatedNetworkAddress);
Assert.Equal(0, createdEvent.PrefixLength);
Assert.False(createdEvent.HasPrefixDelegation);
}
}
protected static DHCPv6Lease CheckLease(
Int32 index, Int32 expectedAmount, IPv6Address expectedAdress,
Guid scopeId, DHCPv6RootScope rootScope, DateTime expectedCreationData,
DUID clientDuid, UInt32 iaId, Boolean shouldBePending, Boolean shouldHavePrefix, Byte[] uniqueIdentifier = null, Boolean checkExpire = true)
{
DHCPv6Scope scope = rootScope.GetScopeById(scopeId);
var leases = scope.Leases.GetAllLeases();
Assert.Equal(expectedAmount, leases.Count());
DHCPv6Lease lease = leases.ElementAt(index);
Assert.NotNull(lease);
Assert.Equal(expectedAdress, lease.Address);
if (checkExpire == true)
{
Int32 expiresInMinutes = (Int32)(lease.End - DateTime.UtcNow).TotalMinutes;
Assert.True(expiresInMinutes >= 60 * 24 - 4 && expiresInMinutes <= 60 * 24);
}
Assert.True((expectedCreationData - lease.Start).TotalMinutes < 2);
if (shouldBePending == true)
{
Assert.True(lease.IsPending());
}
else
{
Assert.True(lease.IsActive());
}
Assert.Equal(clientDuid, lease.ClientDUID);
Assert.Equal(iaId, lease.IdentityAssocicationId);
if (uniqueIdentifier == null)
{
Assert.Empty(lease.UniqueIdentifier);
}
else
{
Assert.NotNull(lease.UniqueIdentifier);
Assert.Equal(uniqueIdentifier, lease.UniqueIdentifier);
}
if (shouldHavePrefix == false)
{
Assert.Equal(DHCPv6PrefixDelegation.None, lease.PrefixDelegation);
}
return(lease);
}
public void IsActive()
{
Random random = new Random();
DHCPv6RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
List <DomainEvent> events = new List <DomainEvent>
{
new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction
{
Id = scopeId,
}),
};
Int32 leaseAmount = random.Next(10, 30);
Dictionary <Guid, Boolean> expectedResults = new Dictionary <Guid, bool>();
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = Guid.NewGuid();
events.Add(new DHCPv6LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
Address = random.GetIPv6Address(),
ClientIdentifier = new UUIDDUID(random.NextGuid()),
});
Boolean addressIsActive = random.NextDouble() > 0.5;
if (addressIsActive == true)
{
events.Add(new DHCPv6LeaseActivatedEvent(leaseId));
}
expectedResults.Add(leaseId, addressIsActive);
}
rootScope.Load(events);
DHCPv6Scope scope = rootScope.GetRootScopes().First();
foreach (var item in expectedResults)
{
DHCPv6Lease lease = scope.Leases.GetLeaseById(item.Key);
Boolean actual = lease.IsActive();
Assert.Equal(item.Value, actual);
}
}
internal static PrefixBinding FromLease(DHCPv6Lease currentLease, Boolean throwException = true)
{
try
{
return(new PrefixBinding(currentLease.PrefixDelegation.NetworkAddress, currentLease.PrefixDelegation.Mask, currentLease.Address));
}
catch (Exception)
{
if (throwException == true)
{
throw;
}
return(null);
}
}
private DHCPv6LeaseOverview GetLeaseOverview(DHCPv6Lease lease, DHCPv6Scope scope) => new DHCPv6LeaseOverview
{
Address = lease.Address.ToString(),
ClientIdentifier = lease.ClientDUID,
Started = lease.Start,
ExpectedEnd = lease.End,
Id = lease.Id,
Prefix = lease.PrefixDelegation != DHCPv6PrefixDelegation.None ? new PrefixOverview {
Address = lease.PrefixDelegation.NetworkAddress.ToString(), Mask = lease.PrefixDelegation.Mask.Identifier
} : null,
UniqueIdentifier = lease.UniqueIdentifier,
State = lease.State,
Scope = new ScopeOverview
{
Id = scope.Id,
Name = scope.Name,
}
};
protected static DHCPv6Lease CheckLeaseForPrefix(
Int32 index, Int32 expectedAmount, IPv6Address minAddress, IPv6Address maxAddress,
Guid scopeId, DHCPv6RootScope rootScope,
DUID clientDuid, UInt32 prefixIaId, Byte prefixLength, Boolean shouldBePending, Byte[] uniqueIdentifier = null)
{
DHCPv6Scope scope = rootScope.GetScopeById(scopeId);
var leases = scope.Leases.GetAllLeases();
Assert.Equal(expectedAmount, leases.Count());
DHCPv6Lease lease = leases.ElementAt(index);
Assert.Equal(clientDuid, lease.ClientDUID);
Assert.NotNull(lease);
Assert.NotEqual(DHCPv6PrefixDelegation.None, lease.PrefixDelegation);
Assert.Equal(prefixIaId, lease.PrefixDelegation.IdentityAssociation);
Assert.Equal(prefixLength, lease.PrefixDelegation.Mask.Identifier);
Assert.True((new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(prefixLength))).IsIPv6AdressANetworkAddress(lease.PrefixDelegation.NetworkAddress));
Assert.True(lease.PrefixDelegation.NetworkAddress.IsBetween(minAddress, maxAddress));
if (shouldBePending == true)
{
Assert.True(lease.IsPending());
}
else
{
Assert.True(lease.IsActive());
}
if (uniqueIdentifier == null)
{
Assert.Empty(lease.UniqueIdentifier);
}
else
{
Assert.NotNull(lease.UniqueIdentifier);
Assert.Equal(uniqueIdentifier, lease.UniqueIdentifier);
}
return(lease);
}
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);
}
protected static void CheckDHCPv6LeasePrefixAddedEvent(
Int32 index, UInt32 prefixIaId,
Guid scopeId, DHCPv6RootScope rootScope,
DHCPv6Lease lease
)
{
IEnumerable <DomainEvent> changes = rootScope.GetChanges();
Assert.NotNull(changes);
Assert.IsAssignableFrom <DHCPv6LeasePrefixAddedEvent>(changes.ElementAt(index));
DHCPv6LeasePrefixAddedEvent createdEvent = (DHCPv6LeasePrefixAddedEvent)changes.ElementAt(index);
Assert.NotNull(createdEvent);
Assert.Equal(scopeId, createdEvent.ScopeId);
Assert.Equal(lease.PrefixDelegation.NetworkAddress, createdEvent.NetworkAddress);
Assert.Equal(lease.PrefixDelegation.IdentityAssociation, createdEvent.PrefixAssociationId);
Assert.Equal(lease.PrefixDelegation.Mask.Identifier, createdEvent.PrefixLength);
Assert.Equal(lease.PrefixDelegation.IdentityAssociation, prefixIaId);
}
public void IsCancelable()
{
Random random = new Random();
DHCPv6RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
rootScope.Load(new[] {
new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction
{
Id = scopeId,
})
});
Dictionary <DHCPv6Lease, Boolean> expectedResults =
AddEventsForCancelableLeases(random, scopeId, rootScope);
foreach (var item in expectedResults)
{
DHCPv6Lease lease = item.Key;
Boolean actual = lease.IsCancelable();
Assert.Equal(item.Value, actual);
}
}
public void CanBeExtended()
{
Random random = new Random(1345);
DHCPv6RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
rootScope.Load(new[] {
new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction
{
Id = scopeId,
}),
});
Int32 leaseAmount = random.Next(10, 30);
Dictionary <DHCPv6Lease, Boolean> expectedResults = new();
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = Guid.NewGuid();
rootScope.Load(new[] { new DHCPv6LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
Address = random.GetIPv6Address(),
ClientIdentifier = new UUIDDUID(random.NextGuid()),
} });
DHCPv6Lease lease = rootScope.GetRootScopes().First().Leases.GetLeaseById(leaseId);
Boolean shouldBeExtentable = random.NextBoolean();
DomainEvent @event = null;
if (shouldBeExtentable == true)
{
Int32 nextValue = random.Next(0, 4);
switch (nextValue)
{
case 0:
@event = new DHCPv6LeaseActivatedEvent(leaseId);
break;
case 1:
@event = new DHCPv6LeaseReleasedEvent(leaseId, false);
break;
case 2:
@event = new DHCPv6LeaseRenewedEvent(leaseId, DateTime.UtcNow.AddHours(3), TimeSpan.FromHours(1), TimeSpan.FromHours(2), false, false);
break;
case 3:
@event = new DHCPv6LeaseExpiredEvent(leaseId);
break;
default:
break;
}
}
else
{
Int32 nextValue = random.Next(0, 3);
switch (nextValue)
{
case 0:
@event = new DHCPv6LeaseCanceledEvent(leaseId);
break;
case 1:
@event = new DHCPv6LeaseRevokedEvent(leaseId);
break;
case 2:
@event = new DHCPv6AddressSuspendedEvent(leaseId, random.GetIPv6Address(), DateTime.UtcNow.AddHours(3));
break;
default:
break;
}
}
rootScope.Load(new[] { @event });
expectedResults.Add(lease, shouldBeExtentable);
}
foreach (var item in expectedResults)
{
DHCPv6Lease lease = item.Key;
Boolean actual = lease.CanBeExtended();
Assert.Equal(item.Value, 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);
}
}
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 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);
}
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);
}
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 async Task HandleRebind_LeaseFound_ReuseIsNotAllowed_TwoPackets(Boolean withPrefixDelegation)
{
Random random = new Random();
UInt32 prefixId = random.NextBoolean() == false?random.NextUInt32() : 0;
Byte prefixLength = (Byte)random.Next(34, 64);
IPv6Address prefixNetworkAddress = IPv6Address.FromString("fd01::0");
DHCPv6PacketOption[] options = Array.Empty <DHCPv6PacketOption>();
if (withPrefixDelegation == true)
{
options = new DHCPv6PacketOption[] {
new DHCPv6PacketIdentityAssociationPrefixDelegationOption(prefixId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), Array.Empty <DHCPv6PacketSuboption>())
};
}
var packet = GetRelayedRebindPacket(random, out IPv6Address _, out DUID clientDuid, out UInt32 iaId, true, options);
var resolverInformations = GetMockupResolver(packet, out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock);
Guid scopeId = random.NextGuid();
Guid leaseId = random.NextGuid();
IPv6Address leasedAddress = IPv6Address.FromString("fe80::01");
IPv6Address expectedAddress = IPv6Address.FromString("fe80::03");
DateTime leaseCreatedAt = DateTime.UtcNow.AddHours(-2);
DHCPv6RootScope rootScope = GetRootScope(scopeResolverMock);
rootScope.Load(new List <DomainEvent> {
new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent(
new DHCPv6ScopeCreateInstruction
{
AddressProperties = new DHCPv6ScopeAddressProperties(
IPv6Address.FromString("fe80::01"),
IPv6Address.FromString("fe80::ff"),
new List <IPv6Address> {
IPv6Address.FromString("fe80::02")
},
t1: DHCPv6TimeScale.FromDouble(0.5),
t2: DHCPv6TimeScale.FromDouble(0.75),
preferredLifeTime: TimeSpan.FromDays(0.5),
validLifeTime: TimeSpan.FromDays(1),
reuseAddressIfPossible: false,
prefixDelgationInfo: DHCPv6PrefixDelgationInfo.FromValues(IPv6Address.FromString("2140:1::0"), new IPv6SubnetMaskIdentifier(32), new IPv6SubnetMaskIdentifier(prefixLength)),
addressAllocationStrategy: DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next),
ResolverInformation = resolverInformations,
Name = "Testscope",
Id = scopeId,
}),
new DHCPv6LeaseCreatedEvent
{
EntityId = leaseId,
Address = leasedAddress,
ClientIdentifier = clientDuid,
IdentityAssocationId = iaId,
ScopeId = scopeId,
StartedAt = leaseCreatedAt,
ValidUntil = DateTime.UtcNow.AddDays(1),
HasPrefixDelegation = withPrefixDelegation,
PrefixLength = prefixLength,
IdentityAssocationIdForPrefix = prefixId,
DelegatedNetworkAddress = prefixNetworkAddress,
},
new DHCPv6LeaseActivatedEvent
{
EntityId = leaseId,
ScopeId = scopeId,
}
});
Guid serverId = random.NextGuid();
var revokedLease = rootScope.GetScopeById(scopeId).Leases.GetLeaseById(leaseId);
DHCPv6Packet result = rootScope.HandleRebind(packet, GetServerPropertiesResolver(serverId));
await Task.Delay(3000);
DHCPv6Packet secondResult = rootScope.HandleRebind(packet, GetServerPropertiesResolver(serverId));
Assert.Equal(result, secondResult);
DHCPv6Lease lease = CheckLease(0, 1, expectedAddress, scopeId, rootScope, DateTime.UtcNow, clientDuid, iaId, false, withPrefixDelegation);
CheckPacket(packet, expectedAddress, iaId, result, DHCPv6PacketTypes.REPLY, withPrefixDelegation == false ? DHCPv6PrefixDelegation.None : DHCPv6PrefixDelegation.FromValues(lease.PrefixDelegation.NetworkAddress, new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(prefixLength)), prefixId));
Assert.False(revokedLease.IsActive());
Assert.Equal(LeaseStates.Revoked, revokedLease.State);
CheckEventAmount(5, rootScope);
CheckRevokedEvent(0, scopeId, leaseId, rootScope);
CheckLeaseCreatedEvent(1, clientDuid, iaId, scopeId, rootScope, expectedAddress, lease);
CheckLeaseActivatedEvent(2, scopeId, lease.Id, rootScope);
CheckHandeledEvent(3, packet, result, rootScope, scopeId, DHCPv6RebindHandledEvent.RebindErrors.NoError);
CheckHandeledEvent(4, packet, result, rootScope, scopeId, DHCPv6RebindHandledEvent.RebindErrors.NoError);
}
public void MatchesUniqueIdentiifer()
{
Random random = new Random();
DHCPv6RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
Byte[] uniqueIdentifier = random.NextBytes(10);
List <DomainEvent> events = new List <DomainEvent>
{
new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction
{
Id = scopeId,
}),
};
Int32 leaseAmount = random.Next(3, 10);
Dictionary <Guid, Boolean> expectedResults = new Dictionary <Guid, bool>();
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = Guid.NewGuid();
Byte[] identifier = null;
Boolean matches = false;
Double randomValue = random.NextDouble();
if (randomValue > 0.75)
{
identifier = uniqueIdentifier;
matches = true;
}
else if (randomValue > 0.5)
{
identifier = random.NextBytes(12);
}
else if (randomValue > 0.25)
{
identifier = new byte[0];
}
events.Add(new DHCPv6LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
UniqueIdentiifer = identifier,
Address = random.GetIPv6Address(),
ClientIdentifier = new UUIDDUID(random.NextGuid()),
});
expectedResults.Add(leaseId, matches);
}
rootScope.Load(events);
DHCPv6Scope scope = rootScope.GetRootScopes().First();
foreach (var item in expectedResults)
{
DHCPv6Lease lease = scope.Leases.GetLeaseById(item.Key);
Boolean actual = lease.MatchesUniqueIdentiifer(uniqueIdentifier);
Assert.Equal(item.Value, actual);
}
}
public static Dictionary <DHCPv6Lease, Boolean> AddEventsForCancelableLeases(
Random random,
Guid scopeId,
DHCPv6RootScope rootScope)
{
Dictionary <LeaseStates, Func <Guid, DHCPv6ScopeRelatedEvent> > cancalableStateBuilder = new Dictionary <LeaseStates, Func <Guid, DHCPv6ScopeRelatedEvent> >
{
{ LeaseStates.Pending, (id) => null },
{ LeaseStates.Active, (id) => new DHCPv6LeaseActivatedEvent(id) },
};
Dictionary <LeaseStates, Func <Guid, DHCPv6ScopeRelatedEvent> > nonCancalableStateBuilder = new Dictionary <LeaseStates, Func <Guid, DHCPv6ScopeRelatedEvent> >
{
//{ LeaseStates.Inactive, (id) => new DHCPv6LeaseExpiredEvent(id) },
//{ LeaseStates.Canceled, (id) => new DHCPv6LeaseCanceledEvent(id) },
{ LeaseStates.Released, (id) => new DHCPv6LeaseReleasedEvent(id, false) },
{ LeaseStates.Revoked, (id) => new DHCPv6LeaseRevokedEvent(id) },
};
Int32 leaseAmount = random.Next(20, 40);
Dictionary <DHCPv6Lease, Boolean> expectedCancallations = new();
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = random.NextGuid();
rootScope.Load(new[]
{
new DHCPv6LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
Address = random.GetIPv6Address(),
ClientIdentifier = new UUIDDUID(random.NextGuid()),
}
});
DHCPv6Lease lease = rootScope.GetRootScopes().First().Leases.GetLeaseById(leaseId);
Boolean shouldBeCancelable = random.NextDouble() > 0.5;
Dictionary <LeaseStates, Func <Guid, DHCPv6ScopeRelatedEvent> > eventCreatorDict = null;
if (shouldBeCancelable == true)
{
eventCreatorDict = cancalableStateBuilder;
}
else
{
eventCreatorDict = nonCancalableStateBuilder;
}
var entry = eventCreatorDict.ElementAt(random.Next(0, eventCreatorDict.Count));
DHCPv6ScopeRelatedEvent stateChangingEvent = entry.Value(leaseId);
if (stateChangingEvent != null)
{
stateChangingEvent.ScopeId = scopeId;
rootScope.Load(new[] { stateChangingEvent });
}
expectedCancallations.Add(lease, shouldBeCancelable);
}
return(expectedCancallations);
}
public void HandleRebind_LeaseFound_ReuseIsAllowed(Boolean withPrefixDelegation)
{
Random random = new Random();
UInt32 prefixId = random.NextBoolean() == false?random.NextUInt32() : 0;
Byte prefixLength = (Byte)random.Next(20, 60);
IPv6Address prefixNetworkAddress = IPv6Address.FromString("fd01::0");
DHCPv6PacketOption[] options = Array.Empty <DHCPv6PacketOption>();
if (withPrefixDelegation == true)
{
options = new DHCPv6PacketOption[] {
new DHCPv6PacketIdentityAssociationPrefixDelegationOption(prefixId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), Array.Empty <DHCPv6PacketSuboption>())
};
}
var packet = GetRelayedRebindPacket(random, out IPv6Address _, out DUID clientDuid, out UInt32 iaId, true, options);
var resolverInformations = GetMockupResolver(packet, out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock);
Guid scopeId = random.NextGuid();
Guid leaseId = random.NextGuid();
IPv6Address leasedAddress = IPv6Address.FromString("fe80::2");
DateTime leaseCreatedAt = DateTime.UtcNow;
DHCPv6RootScope rootScope = GetRootScope(scopeResolverMock);
rootScope.Load(new List <DomainEvent> {
new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent(
new DHCPv6ScopeCreateInstruction
{
AddressProperties = new DHCPv6ScopeAddressProperties(
IPv6Address.FromString("fe80::0"),
IPv6Address.FromString("fe80::ff"),
new List <IPv6Address> {
IPv6Address.FromString("fe80::1")
},
t1: DHCPv6TimeScale.FromDouble(0.5),
t2: DHCPv6TimeScale.FromDouble(0.75),
preferredLifeTime: TimeSpan.FromDays(0.5),
validLifeTime: TimeSpan.FromDays(1),
reuseAddressIfPossible: true),
ResolverInformation = resolverInformations,
Name = "Testscope",
Id = scopeId,
}),
new DHCPv6LeaseCreatedEvent
{
EntityId = leaseId,
Address = leasedAddress,
ClientIdentifier = clientDuid,
IdentityAssocationId = iaId,
ScopeId = scopeId,
StartedAt = leaseCreatedAt,
ValidUntil = DateTime.UtcNow.AddDays(1),
HasPrefixDelegation = withPrefixDelegation,
PrefixLength = prefixLength,
IdentityAssocationIdForPrefix = prefixId,
DelegatedNetworkAddress = prefixNetworkAddress,
},
new DHCPv6LeaseActivatedEvent
{
EntityId = leaseId,
ScopeId = scopeId,
}
});
DHCPv6Packet result = rootScope.HandleRebind(packet, GetServerPropertiesResolver());
CheckPacket(packet, leasedAddress, iaId, result, DHCPv6PacketTypes.REPLY, withPrefixDelegation == false ? DHCPv6PrefixDelegation.None : DHCPv6PrefixDelegation.FromValues(prefixNetworkAddress, new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(prefixLength)), prefixId));
DHCPv6Lease lease = CheckLease(0, 1, leasedAddress, scopeId, rootScope, leaseCreatedAt, clientDuid, iaId, false, withPrefixDelegation);
CheckEventAmount(2, rootScope);
CheckLeaseRenewdEvent(scopeId, rootScope, lease, false, false);
CheckHandeledEvent(1, packet, result, rootScope, scopeId, DHCPv6RebindHandledEvent.RebindErrors.NoError);
}
public void AddressesAreInUse()
{
Random random = new Random(123);
DHCPv6RootScope rootScope = GetRootScope();
Guid scopeId = Guid.NewGuid();
rootScope.Load(new[] {
new DHCPv6ScopeAddedEvent(new DHCPv6ScopeCreateInstruction
{
Id = scopeId,
})
});
Int32 leaseAmount = random.Next(10, 30);
Dictionary <DHCPv6Lease, Boolean> expectedResults = new();
for (int i = 0; i < leaseAmount; i++)
{
Guid leaseId = Guid.NewGuid();
rootScope.Load(new[] {
new DHCPv6LeaseCreatedEvent
{
ScopeId = scopeId,
EntityId = leaseId,
Address = random.GetIPv6Address(),
ClientIdentifier = new UUIDDUID(random.NextGuid()),
}
});
DHCPv6Lease lease = rootScope.GetRootScopes().First().Leases.GetLeaseById(leaseId);
DomainEvent eventToAdd = null;
Boolean addressIsInUse = true;
Double randomValue = random.NextDouble();
Double possiblities = 5.0;
if (randomValue < 1 / possiblities)
{
eventToAdd = new DHCPv6LeaseReleasedEvent(leaseId, false);
addressIsInUse = false;
}
else if (randomValue < 2 / possiblities)
{
eventToAdd = new DHCPv6LeaseRevokedEvent(leaseId);
addressIsInUse = false;
}
else if (randomValue < 3 / possiblities)
{
eventToAdd = new DHCPv6AddressSuspendedEvent(leaseId, random.GetIPv6Address(), DateTime.UtcNow.AddHours(12));
addressIsInUse = false;
}
else if (randomValue < 4 / possiblities)
{
eventToAdd = new DHCPv6LeaseCanceledEvent(leaseId, LeaseCancelReasons.NotSpecified);
addressIsInUse = false;
}
if (eventToAdd != null)
{
rootScope.Load(new[] { eventToAdd });
}
expectedResults.Add(lease, addressIsInUse);
}
foreach (var item in expectedResults)
{
DHCPv6Lease lease = item.Key;
Boolean actual = lease.AddressIsInUse();
Assert.Equal(item.Value, actual);
}
}
public void HandleRelease_NoLeaseFound(Boolean withPrefixDelegation, Boolean isUnicast)
{
Random random = new Random();
UInt32 prefixId = random.NextUInt32();
Byte prefixLength = (Byte)random.Next(34, 64);
IPv6Address prefixNetworkAddress = IPv6Address.FromString("fd01::0");
DHCPv6PacketOption[] options = Array.Empty <DHCPv6PacketOption>();
if (withPrefixDelegation == true)
{
options = new DHCPv6PacketOption[] {
new DHCPv6PacketIdentityAssociationPrefixDelegationOption(prefixId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[] {
new DHCPv6PacketIdentityAssociationPrefixDelegationSuboption(TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), prefixLength, prefixNetworkAddress, Array.Empty <DHCPv6PacketSuboption>())
})
};
}
var packet = isUnicast == true?
GetReleasePacket(random, out IPv6Address leasedAddress, out _, out UInt32 iaId, true, options) :
GetRelayedReleasePacket(random, out leasedAddress, out _, out iaId, true, options);
var resolverInformations = GetMockupResolver(packet, out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock);
Guid scopeId = random.NextGuid();
Guid leaseId = random.NextGuid();
DateTime leaseCreatedAt = DateTime.UtcNow;
DHCPv6RootScope rootScope = GetRootScope(scopeResolverMock);
rootScope.Load(new List <DomainEvent> {
new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent(
new DHCPv6ScopeCreateInstruction
{
AddressProperties = new DHCPv6ScopeAddressProperties(
IPv6Address.FromString("fe80::01"),
IPv6Address.FromString("fe80::ff"),
new List <IPv6Address> {
IPv6Address.FromString("fe80::02")
},
preferredLifeTime: TimeSpan.FromDays(0.5),
validLifeTime: TimeSpan.FromDays(1),
reuseAddressIfPossible: false,
prefixDelgationInfo: DHCPv6PrefixDelgationInfo.FromValues(IPv6Address.FromString("2140:1::0"), new IPv6SubnetMaskIdentifier(32), new IPv6SubnetMaskIdentifier(prefixLength)),
addressAllocationStrategy: DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Next),
ResolverInformation = resolverInformations,
Name = "Testscope",
Id = scopeId,
}),
new DHCPv6LeaseCreatedEvent
{
EntityId = leaseId,
Address = leasedAddress,
ClientIdentifier = new UUIDDUID(random.NextGuid()),
IdentityAssocationId = iaId,
ScopeId = scopeId,
StartedAt = leaseCreatedAt,
ValidUntil = DateTime.UtcNow.AddDays(1),
HasPrefixDelegation = withPrefixDelegation,
PrefixLength = prefixLength,
IdentityAssocationIdForPrefix = prefixId,
DelegatedNetworkAddress = prefixNetworkAddress,
},
new DHCPv6LeaseActivatedEvent
{
EntityId = leaseId,
ScopeId = scopeId,
}
});
DHCPv6Packet result = rootScope.HandleRelease(packet, GetServerPropertiesResolver());
CheckErrorPacket(packet, leasedAddress, iaId, result, withPrefixDelegation == false ? DHCPv6PrefixDelegation.None : DHCPv6PrefixDelegation.FromValues(prefixNetworkAddress, new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(prefixLength)), prefixId), DHCPv6StatusCodes.NoBinding);
DHCPv6Lease lease = rootScope.GetScopeById(scopeId).Leases.GetLeaseById(leaseId);
Assert.Equal(LeaseStates.Active, lease.State);
CheckEventAmount(1, rootScope);
CheckHandeledEvent(0, packet, result, rootScope, scopeId, DHCPv6ReleaseHandledEvent.ReleaseError.NoLeaseFound);
}
public async Task HandleRenew_OnlyPrefix_LeaseFound_NotReuseAddress(Boolean isUnicast, Boolean sendSecondPacket)
{
Random random = new Random();
UInt32 prefixId = random.NextUInt32();
Byte prefixLength = 36;
IPv6Address prefixNetworkAddress = IPv6Address.FromString("2140:1::0");
IPv6Address leasedAddress = IPv6Address.FromString("fe80::4");
DHCPv6PacketOption[] options = new DHCPv6PacketOption[] {
new DHCPv6PacketIdentityAssociationPrefixDelegationOption(prefixId, TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), new DHCPv6PacketSuboption[] {
new DHCPv6PacketIdentityAssociationPrefixDelegationSuboption(TimeSpan.FromSeconds(random.Next()), TimeSpan.FromSeconds(random.Next()), prefixLength, prefixNetworkAddress, Array.Empty <DHCPv6PacketSuboption>())
})
};
var packet = isUnicast == true?
GetRenewPacket(random, out IPv6Address _, out DUID clientDuid, out UInt32 _, false, options) :
GetRelayedRenewPacket(random, out IPv6Address _, out clientDuid, out UInt32 _, false, options);
var resolverInformations = GetMockupResolver(packet, out Mock <IScopeResolverManager <DHCPv6Packet, IPv6Address> > scopeResolverMock);
Guid scopeId = random.NextGuid();
Guid leaseId = random.NextGuid();
UInt32 iaId = random.NextUInt32();
DateTime leaseCreatedAt = DateTime.UtcNow.AddHours(-random.Next(4, 10));
DHCPv6RootScope rootScope = GetRootScope(scopeResolverMock);
rootScope.Load(new List <DomainEvent> {
new DHCPv6ScopeEvents.DHCPv6ScopeAddedEvent(
new DHCPv6ScopeCreateInstruction
{
AddressProperties = new DHCPv6ScopeAddressProperties(
IPv6Address.FromString("fe80::01"),
IPv6Address.FromString("fe80::ff"),
new List <IPv6Address> {
IPv6Address.FromString("fe80::02")
},
preferredLifeTime: TimeSpan.FromDays(0.5),
validLifeTime: TimeSpan.FromDays(1),
t1: DHCPv6TimeScale.FromDouble(0.5),
t2: DHCPv6TimeScale.FromDouble(0.75),
reuseAddressIfPossible: false,
prefixDelgationInfo: DHCPv6PrefixDelgationInfo.FromValues(IPv6Address.FromString("2140:1::0"), new IPv6SubnetMaskIdentifier(32), new IPv6SubnetMaskIdentifier(prefixLength)),
addressAllocationStrategy: DHCPv6ScopeAddressProperties.AddressAllocationStrategies.Random),
ResolverInformation = resolverInformations,
Name = "Testscope",
Id = scopeId,
}),
new DHCPv6LeaseCreatedEvent
{
EntityId = leaseId,
Address = leasedAddress,
ClientIdentifier = clientDuid,
IdentityAssocationId = iaId,
ScopeId = scopeId,
StartedAt = leaseCreatedAt,
ValidUntil = DateTime.UtcNow.AddDays(1),
HasPrefixDelegation = true,
PrefixLength = prefixLength,
IdentityAssocationIdForPrefix = prefixId,
DelegatedNetworkAddress = prefixNetworkAddress,
},
new DHCPv6LeaseActivatedEvent
{
EntityId = leaseId,
ScopeId = scopeId,
},
new DHCPv6LeaseRenewedEvent
{
EntityId = leaseId,
ScopeId = scopeId,
ResetPrefix = true,
End = DateTime.UtcNow.AddDays(1)
}
});
DHCPv6Packet result = rootScope.HandleRenew(packet, GetServerPropertiesResolver());
DHCPv6Lease lease = CheckLease(0, 1, leasedAddress, scopeId, rootScope, leaseCreatedAt, clientDuid, iaId, false, true);
CheckPacket(packet, leasedAddress, 0, result, DHCPv6PacketTypes.REPLY, DHCPv6PrefixDelegation.FromValues(lease.PrefixDelegation.NetworkAddress, new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(prefixLength)), prefixId));
DHCPv6Packet secondResponse = null;
if (sendSecondPacket == true)
{
await Task.Delay(1000);
secondResponse = rootScope.HandleRenew(packet, GetServerPropertiesResolver());
CheckPacket(packet, leasedAddress, 0, secondResponse, DHCPv6PacketTypes.REPLY, DHCPv6PrefixDelegation.FromValues(lease.PrefixDelegation.NetworkAddress, new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(prefixLength)), prefixId));
}
CheckPacket(packet, leasedAddress, 0, result, DHCPv6PacketTypes.REPLY, DHCPv6PrefixDelegation.FromValues(lease.PrefixDelegation.NetworkAddress, new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(prefixLength)), prefixId));
CheckEventAmount(sendSecondPacket == false ? 2 : 3, rootScope);
CheckDHCPv6LeasePrefixAddedEvent(0, prefixId, scopeId, rootScope, lease);
CheckHandeledEvent(1, packet, result, rootScope, scopeId, DHCPv6RenewHandledEvent.RenewErrors.NoError);
if (sendSecondPacket == true)
{
CheckHandeledEvent(2, packet, secondResponse, rootScope, scopeId, DHCPv6RenewHandledEvent.RenewErrors.NoError);
}
var trigger = CheckTrigger <PrefixEdgeRouterBindingUpdatedTrigger>(rootScope);
Assert.Null(trigger.OldBinding);
Assert.NotNull(trigger.NewBinding);
Assert.Equal(leasedAddress, trigger.NewBinding.Host);
Assert.Equal(lease.PrefixDelegation.NetworkAddress, trigger.NewBinding.Prefix);
Assert.Equal(new IPv6SubnetMask(new IPv6SubnetMaskIdentifier(prefixLength)), trigger.NewBinding.Mask);
}
