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