protected static DHCPv4Lease CheckLease( Int32 index, Int32 expectedAmount, IPv4Address expectedAdress, Guid scopeId, DHCPv4RootScope rootScope, DateTime expectedCreationData, Boolean checkExpires = true, Byte[] uniqueIdentifier = null, Boolean shouldBePending = true) { DHCPv4Scope scope = rootScope.GetScopeById(scopeId); var leases = scope.Leases.GetAllLeases(); Assert.Equal(expectedAmount, leases.Count()); DHCPv4Lease lease = leases.ElementAt(index); Assert.NotNull(lease); Assert.Equal(expectedAdress, lease.Address); if (checkExpires == 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); Assert.Equal(shouldBePending, lease.IsPending()); if (uniqueIdentifier == null) { Assert.Empty(lease.UniqueIdentifier); } else { Assert.NotNull(lease.UniqueIdentifier); Assert.Equal(uniqueIdentifier, lease.UniqueIdentifier); } return(lease); }
public void DHCPv4Lease_IsCancelable() { Random random = new Random(); DHCPv4RootScope rootScope = GetRootScope(); Guid scopeId = Guid.NewGuid(); rootScope.Load(new[] { new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { Id = scopeId, }), }); Dictionary <DHCPv4Lease, Boolean> expectedResults = AddEventsForCancelableLeases(random, scopeId, rootScope); DHCPv4Scope scope = rootScope.GetRootScopes().First(); foreach (var item in expectedResults) { DHCPv4Lease lease = item.Key; Boolean actual = lease.IsCancelable(); Assert.Equal(item.Value, actual); } }
public void DHCPv4Leases_GetLeaseById() { Random random = new Random(); DHCPv4RootScope rootScope = GetRootScope(); Guid scopeId = Guid.NewGuid(); List <DomainEvent> events = new List <DomainEvent> { new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { 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 DHCPv4LeaseCreatedEvent { ScopeId = scopeId, EntityId = leaseId, Address = random.GetIPv4Address(), ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(), }); existingIds.Add(leaseId); } rootScope.Load(events); DHCPv4Scope scope = rootScope.GetRootScopes().First(); foreach (Guid leaseId in existingIds) { DHCPv4Lease lease = scope.Leases.GetLeaseById(leaseId); Assert.True(lease != DHCPv4Lease.Empty); } Int32 notExisitngAmount = random.Next(30, 100); for (int i = 0; i < notExisitngAmount; i++) { Guid id = Guid.NewGuid(); if (existingIds.Contains(id) == true) { continue; } DHCPv4Lease lease = scope.Leases.GetLeaseById(id); Assert.True(lease == DHCPv4Lease.Empty); } }
public void DHCPv4Lease_IsActive() { Random random = new Random(); DHCPv4RootScope rootScope = GetRootScope(); Guid scopeId = Guid.NewGuid(); List <DomainEvent> events = new List <DomainEvent> { new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { 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 DHCPv4LeaseCreatedEvent { ScopeId = scopeId, EntityId = leaseId, Address = random.GetIPv4Address(), ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(), }); Boolean addressIsActive = random.NextDouble() > 0.5; if (addressIsActive == true) { events.Add(new DHCPv4LeaseActivatedEvent(leaseId)); } expectedResults.Add(leaseId, addressIsActive); } rootScope.Load(events); DHCPv4Scope scope = rootScope.GetRootScopes().First(); foreach (var item in expectedResults) { DHCPv4Lease lease = scope.Leases.GetLeaseById(item.Key); Boolean actual = lease.IsActive(); Assert.Equal(item.Value, actual); } }
private DHCPv4LeaseOverview GetLeaseOverview(DHCPv4Lease lease, DHCPv4Scope scope) => new DHCPv4LeaseOverview { Address = lease.Address.ToString(), MacAddress = lease.Identifier.HwAddress, Started = lease.Start, ExpectedEnd = lease.End, Id = lease.Id, UniqueIdentifier = lease.UniqueIdentifier, State = lease.State, Scope = new DHCPv4ScopeOverview { Id = scope.Id, Name = scope.Name, } };
protected static void CheckLeaseCreatedEvent( Int32 index, byte[] clientMacAdress, Guid scopeId, DHCPv4RootScope rootScope, IPv4Address expectedAdress, DHCPv4Lease lease, Byte[] uniqueIdentifier = null, Boolean checkRenewTimes = true ) { IEnumerable <DomainEvent> changes = rootScope.GetChanges(); Assert.NotNull(changes); Assert.IsAssignableFrom <DHCPv4LeaseCreatedEvent>(changes.ElementAt(index)); DHCPv4LeaseCreatedEvent createdEvent = (DHCPv4LeaseCreatedEvent)changes.ElementAt(index); Assert.NotNull(createdEvent); Assert.Equal(scopeId, createdEvent.ScopeId); Assert.Equal(expectedAdress, createdEvent.Address); var clientIdentifier = DHCPv4ClientIdentifier.FromOptionData(createdEvent.ClientIdenfier); Assert.Equal(clientMacAdress, clientIdentifier.HwAddress); Assert.Equal(lease.Id, createdEvent.EntityId); if (uniqueIdentifier == null) { Assert.Null(createdEvent.UniqueIdentifier); } else { Assert.Equal(uniqueIdentifier, createdEvent.UniqueIdentifier); } Assert.Equal(lease.Start, createdEvent.StartedAt); Assert.Equal(lease.End, createdEvent.ValidUntil); var addressProperties = rootScope.GetScopeById(scopeId).AddressRelatedProperties; if (checkRenewTimes == true) { Assert.Equal(addressProperties.RenewalTime.Value, createdEvent.RenewalTime); Assert.Equal(addressProperties.PreferredLifetime.Value, createdEvent.PreferredLifetime); } }
public static DHCPv4Packet AsRequestResponse( DHCPv4Packet request, DHCPv4Lease lease, DHCPv4ScopeAddressProperties addressProperties, IEnumerable <DHCPv4ScopeProperty> scopeProperties) { DHCPv4Packet packet = new DHCPv4Packet(DHCPv4MessagesTypes.Acknowledge, request) { YourIPAdress = lease.Address, _isValid = true, }; packet.SetIPHeader(request); packet.AddOption(new DHCPv4PacketAddressOption(DHCPv4OptionTypes.ServerIdentifier, packet.Header.Source)); packet.AddOptions(lease, addressProperties, scopeProperties); packet.AddOptions82AtTheEnd(request); return(packet); }
public void HandleRelease_LeaseExists_AddressIsActive() { Random random = new Random(); IPv4Address leasedAddress = IPv4Address.FromString("192.168.178.10"); IPv4HeaderInformation headerInformation = new IPv4HeaderInformation(leasedAddress, IPv4Address.FromString("192.168.178.1")); Byte[] clientMacAdress = random.NextBytes(6); DHCPv4Packet requestPacket = new DHCPv4Packet( headerInformation, clientMacAdress, (UInt32)random.Next(), IPv4Address.Empty, IPv4Address.Empty, IPv4Address.Empty, DHCPv4PacketFlags.Unicast, new DHCPv4PacketMessageTypeOption(DHCPv4MessagesTypes.Release) ); Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> > scopeResolverMock = new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict); var resolverInformations = new CreateScopeResolverInformation { Typename = nameof(DHCPv4RelayAgentSubnetResolver), }; Mock <IScopeResolver <DHCPv4Packet, IPv4Address> > resolverMock = new Mock <IScopeResolver <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict); scopeResolverMock.Setup(x => x.InitializeResolver(resolverInformations)).Returns(resolverMock.Object); Guid scopeId = random.NextGuid(); Guid leaseId = random.NextGuid(); DateTime leaseCreatedAt = DateTime.UtcNow.AddHours(-1); DHCPv4RootScope rootScope = GetRootScope(scopeResolverMock); rootScope.Load(new List <DomainEvent> { new DHCPv4ScopeEvents.DHCPv4ScopeAddedEvent( new DHCPv4ScopeCreateInstruction { AddressProperties = new DHCPv4ScopeAddressProperties( IPv4Address.FromString("192.168.178.1"), IPv4Address.FromString("192.168.178.255"), new List <IPv4Address> { IPv4Address.FromString("192.168.178.1") }, leaseTime: TimeSpan.FromDays(1) ), ResolverInformation = resolverInformations, Name = "Testscope", Id = scopeId, }), new DHCPv4LeaseCreatedEvent { EntityId = leaseId, Address = leasedAddress, ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(clientMacAdress).GetBytes(), ScopeId = scopeId, UniqueIdentifier = null, StartedAt = leaseCreatedAt, ValidUntil = DateTime.UtcNow.AddDays(1), }, new DHCPv4LeaseActivatedEvent { EntityId = leaseId, ScopeId = scopeId, }, }); DHCPv4Lease lease = rootScope.GetScopeById(scopeId).Leases.GetLeaseById(leaseId); DHCPv4Packet result = rootScope.HandleRelease(requestPacket); Assert.Equal(DHCPv4Packet.Empty, result); CheckIfLeaseIsRelease(lease); CheckEventAmount(2, rootScope); CheckLeaseReleasedEvent(0, scopeId, rootScope, leaseId); CheckHandeledEvent(1, ReleaseError.NoError, requestPacket, rootScope); }
private void CheckIfLeaseIsRelease(DHCPv4Lease lease) { Assert.NotEqual(DHCPv4Lease.Empty, lease); Assert.False(lease.IsActive()); Assert.Equal(LeaseStates.Released, lease.State); }
public void HandleRelease_LeaseExists_AddressIsActive_NotSentDiscover() { Random random = new Random(); IPv4Address leasedAddress = IPv4Address.FromString("192.168.178.10"); IPv4HeaderInformation headerInformation = new IPv4HeaderInformation(leasedAddress, IPv4Address.FromString("192.168.178.1")); Byte[] clientMacAdress = random.NextBytes(6); DHCPv4Packet requestPacket = new DHCPv4Packet( headerInformation, clientMacAdress, (UInt32)random.Next(), IPv4Address.Empty, IPv4Address.Empty, IPv4Address.Empty, DHCPv4PacketFlags.Unicast, new DHCPv4PacketMessageTypeOption(DHCPv4MessagesTypes.Release) ); DHCPv4Packet discoverPacket = new DHCPv4Packet( headerInformation, clientMacAdress, (UInt32)random.Next(), IPv4Address.Empty, IPv4Address.Empty, IPv4Address.Empty, DHCPv4PacketFlags.Broadcast, new DHCPv4PacketMessageTypeOption(DHCPv4MessagesTypes.Discover), new DHCPv4PacketClientIdentifierOption(DHCPv4ClientIdentifier.FromIdentifierValue("random test client")) ); Mock <IScopeResolver <DHCPv4Packet, IPv4Address> > resolverMock = new Mock <IScopeResolver <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict); resolverMock.Setup(x => x.PacketMeetsCondition(discoverPacket)).Returns(true); resolverMock.SetupGet(x => x.HasUniqueIdentifier).Returns(false); Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> > scopeResolverMock = new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict); var resolverInformations = new CreateScopeResolverInformation { Typename = nameof(DHCPv4RelayAgentSubnetResolver), }; scopeResolverMock.Setup(x => x.InitializeResolver(resolverInformations)).Returns(resolverMock.Object); Guid scopeId = random.NextGuid(); Guid leaseId = random.NextGuid(); DateTime leaseCreatedAt = DateTime.UtcNow.AddHours(-1); DHCPv4RootScope rootScope = GetRootScope(scopeResolverMock); rootScope.Load(new List <DomainEvent> { new DHCPv4ScopeEvents.DHCPv4ScopeAddedEvent( new DHCPv4ScopeCreateInstruction { AddressProperties = new DHCPv4ScopeAddressProperties( IPv4Address.FromString("192.168.178.1"), IPv4Address.FromString("192.168.178.255"), new List <IPv4Address> { IPv4Address.FromString("192.168.178.1") }, leaseTime: TimeSpan.FromDays(1), renewalTime: TimeSpan.FromHours(12), preferredLifetime: TimeSpan.FromHours(18), reuseAddressIfPossible: true, acceptDecline: true, addressAllocationStrategy: DHCPv4ScopeAddressProperties.AddressAllocationStrategies.Next, supportDirectUnicast: true, maskLength: 24 ), ResolverInformation = resolverInformations, Name = "Testscope", Id = scopeId, }), new DHCPv4LeaseCreatedEvent { EntityId = leaseId, Address = leasedAddress, ClientIdenfier = DHCPv4ClientIdentifier.FromIdentifierValue("random test client").GetBytes(), ScopeId = scopeId, UniqueIdentifier = null, StartedAt = leaseCreatedAt, ValidUntil = DateTime.UtcNow.AddDays(1), }, new DHCPv4LeaseActivatedEvent { EntityId = leaseId, ScopeId = scopeId, }, }); DHCPv4Lease existingLease = rootScope.GetScopeById(scopeId).Leases.GetLeaseById(leaseId); DHCPv4Packet releaseResult = rootScope.HandleRelease(requestPacket); Assert.Equal(DHCPv4Packet.Empty, releaseResult); CheckIfLeaseIsRelease(existingLease); CheckEventAmount(2, rootScope); CheckLeaseReleasedEvent(0, scopeId, rootScope, leaseId); CheckHandeledEvent(1, ReleaseError.NoError, requestPacket, rootScope); DHCPv4Packet discoveryResult = rootScope.HandleDiscover(discoverPacket); IPv4Address newAssignedAddress = IPv4Address.FromString("192.168.178.2"); Assert.Equal(newAssignedAddress, discoveryResult.YourIPAdress); }
public void HandleDecline_AcceptDecline_RequesAddressExits_LeaseExists_LeaseIsPending_AddressIsNotSuspended() { Random random = new Random(); IPv4Address leasedAddress = IPv4Address.FromString("192.168.178.3"); DHCPv4Packet requestPacket = GetDeclinePacket(random, leasedAddress); Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> > scopeResolverMock = new Mock <IScopeResolverManager <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict); var resolverInformations = new CreateScopeResolverInformation { Typename = nameof(DHCPv4RelayAgentSubnetResolver), }; Mock <IScopeResolver <DHCPv4Packet, IPv4Address> > resolverMock = new Mock <IScopeResolver <DHCPv4Packet, IPv4Address> >(MockBehavior.Strict); scopeResolverMock.Setup(x => x.InitializeResolver(resolverInformations)).Returns(resolverMock.Object); Guid scopeId = random.NextGuid(); Guid leaseId = random.NextGuid(); DateTime leaseCreatedAt = DateTime.UtcNow.AddHours(-1); DHCPv4RootScope rootScope = GetRootScope(scopeResolverMock); rootScope.Load(new List <DomainEvent> { new DHCPv4ScopeEvents.DHCPv4ScopeAddedEvent( new DHCPv4ScopeCreateInstruction { AddressProperties = new DHCPv4ScopeAddressProperties( IPv4Address.FromString("192.168.178.0"), IPv4Address.FromString("192.168.178.100"), new List <IPv4Address> { IPv4Address.FromString("192.168.178.0") }, leaseTime: TimeSpan.FromDays(1), acceptDecline: true), ResolverInformation = resolverInformations, Name = "Testscope", Id = scopeId, }), new DHCPv4LeaseCreatedEvent { EntityId = leaseId, Address = leasedAddress, ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(requestPacket.ClientHardwareAddress).GetBytes(), ScopeId = scopeId, UniqueIdentifier = null, StartedAt = leaseCreatedAt, ValidUntil = DateTime.UtcNow.AddDays(1), }, }); DHCPv4Packet result = rootScope.HandleDecline(requestPacket); Assert.Equal(DHCPv4Packet.Empty, result); DHCPv4Lease lease = rootScope.GetScopeById(scopeId).Leases.GetLeaseById(leaseId); Assert.Equal(LeaseStates.Suspended, lease.State); CheckEventAmount(2, rootScope); CheckDeclineEvent(0, leaseId, leasedAddress, scopeId, rootScope); CheckDeclinedEvent(1, DeclineErros.NoError, requestPacket, rootScope, scopeId); }
public void DHCPv4Lease_AddressesAreInUse() { Random random = new Random(); DHCPv4RootScope rootScope = GetRootScope(); Guid scopeId = Guid.NewGuid(); rootScope.Load(new[] { new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { Id = scopeId, }) }); Int32 leaseAmount = random.Next(10, 30); Dictionary <Guid, Boolean> expectedResults = new Dictionary <Guid, bool>(); Dictionary <Guid, DHCPv4Lease> leases = new Dictionary <Guid, DHCPv4Lease>(); for (int i = 0; i < leaseAmount; i++) { Guid leaseId = Guid.NewGuid(); rootScope.Load(new[] { new DHCPv4LeaseCreatedEvent { ScopeId = scopeId, EntityId = leaseId, Address = random.GetIPv4Address(), ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(), } }); leases.Add(leaseId, 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 DHCPv4LeaseReleasedEvent(leaseId); addressIsInUse = false; } else if (randomValue < 2 / possiblities) { eventToAdd = new DHCPv4LeaseRevokedEvent(leaseId); addressIsInUse = false; } else if (randomValue < 3 / possiblities) { eventToAdd = new DHCPv4AddressSuspendedEvent(leaseId, random.GetIPv4Address(), DateTime.UtcNow.AddHours(12)); addressIsInUse = false; } if (eventToAdd != null) { rootScope.Load(new[] { eventToAdd }); } expectedResults.Add(leaseId, addressIsInUse); } foreach (var item in expectedResults) { DHCPv4Lease lease = leases[item.Key]; Boolean actual = lease.AddressIsInUse(); Assert.Equal(item.Value, actual); } }
public static Dictionary <DHCPv4Lease, Boolean> AddEventsForCancelableLeases( Random random, Guid scopeId, DHCPv4RootScope scope) { Dictionary <LeaseStates, Func <Guid, DHCPv4ScopeRelatedEvent> > cancalableStateBuilder = new Dictionary <LeaseStates, Func <Guid, DHCPv4ScopeRelatedEvent> > { { LeaseStates.Pending, (id) => null }, { LeaseStates.Active, (id) => new DHCPv4LeaseActivatedEvent(id) }, }; Dictionary <LeaseStates, Func <Guid, DHCPv4ScopeRelatedEvent> > nonCancalableStateBuilder = new Dictionary <LeaseStates, Func <Guid, DHCPv4ScopeRelatedEvent> > { { LeaseStates.Inactive, (id) => new DHCPv4LeaseExpiredEvent(id) }, { LeaseStates.Canceled, (id) => new DHCPv4LeaseCanceledEvent(id) }, { LeaseStates.Released, (id) => new DHCPv4LeaseReleasedEvent(id) }, { LeaseStates.Revoked, (id) => new DHCPv4LeaseRevokedEvent(id) }, }; Int32 leaseAmount = random.Next(20, 40); Dictionary <DHCPv4Lease, Boolean> expectedCancallations = new(); for (int i = 0; i < leaseAmount; i++) { Guid leaseId = Guid.NewGuid(); scope.Load(new[] { new DHCPv4LeaseCreatedEvent { ScopeId = scopeId, EntityId = leaseId, ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(), Address = random.GetIPv4Address(), } }); DHCPv4Lease lease = scope.GetRootScopes().First().Leases.GetLeaseById(leaseId); Boolean shouldBeCancelable = random.NextDouble() > 0.5; Dictionary <LeaseStates, Func <Guid, DHCPv4ScopeRelatedEvent> > eventCreatorDict = null; if (shouldBeCancelable == true) { eventCreatorDict = cancalableStateBuilder; } else { eventCreatorDict = nonCancalableStateBuilder; } var entry = eventCreatorDict.ElementAt(random.Next(0, eventCreatorDict.Count)); DHCPv4ScopeRelatedEvent stateChangingEvent = entry.Value(leaseId); if (stateChangingEvent != null) { stateChangingEvent.ScopeId = scopeId; scope.Load(new[] { stateChangingEvent }); } expectedCancallations.Add(lease, shouldBeCancelable); } return(expectedCancallations); }
public void DHCPv4Lease_MatchesUniqueIdentiifer() { Random random = new Random(); DHCPv4RootScope rootScope = GetRootScope(); Guid scopeId = Guid.NewGuid(); Byte[] uniqueIdentifier = random.NextBytes(10); List <DomainEvent> events = new List <DomainEvent> { new DHCPv4ScopeAddedEvent(new DHCPv4ScopeCreateInstruction { 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 DHCPv4LeaseCreatedEvent { ScopeId = scopeId, EntityId = leaseId, UniqueIdentifier = identifier, Address = random.GetIPv4Address(), ClientIdenfier = DHCPv4ClientIdentifier.FromHwAddress(random.NextBytes(6)).GetBytes(), }); expectedResults.Add(leaseId, matches); } rootScope.Load(events); DHCPv4Scope scope = rootScope.GetRootScopes().First(); foreach (var item in expectedResults) { DHCPv4Lease lease = scope.Leases.GetLeaseById(item.Key); Boolean actual = lease.MatchesUniqueIdentiifer(uniqueIdentifier); Assert.Equal(item.Value, actual); } }
private void AddOptions( DHCPv4Lease lease, DHCPv4ScopeAddressProperties addressProperties, IEnumerable <DHCPv4ScopeProperty> scopeProperties) { List <DHCPv4ScopeProperty> propertiesToInsert = new List <DHCPv4ScopeProperty>(scopeProperties); if (addressProperties != null) { propertiesToInsert.Add(new DHCPv4AddressScopeProperty(DHCPv4OptionTypes.SubnetMask, IPv4Address.FromByteArray(addressProperties.Mask.GetBytes()))); } Dictionary <DHCPv4OptionTypes, TimeSpan?> timeRelatedOptions = new Dictionary <DHCPv4OptionTypes, TimeSpan?>(); if (lease != null) { timeRelatedOptions.Add(DHCPv4OptionTypes.IPAddressLeaseTime, lease.End - DateTime.UtcNow); timeRelatedOptions.Add(DHCPv4OptionTypes.RenewalTimeValue, lease.RenewSpan); timeRelatedOptions.Add(DHCPv4OptionTypes.RebindingTimeValue, lease.RebindingSpan); } Int32 timeOptionIndex = 0; foreach (var item in timeRelatedOptions) { if (item.Value.HasValue == false) { continue; } propertiesToInsert.Insert(timeOptionIndex++, new DHCPv4TimeScopeProperty(item.Key, false, item.Value.Value)); } foreach (var item in propertiesToInsert) { switch (item.ValueType) { case DHCPv4ScopePropertyType.Address: case DHCPv4ScopePropertyType.Subnet: AddOption(new DHCPv4PacketAddressOption(item.OptionIdentifier, ((DHCPv4AddressScopeProperty)item).Address)); break; case DHCPv4ScopePropertyType.AddressList: AddOption(new DHCPv4PacketAddressListOption(item.OptionIdentifier, ((DHCPv4AddressListScopeProperty)item).Addresses)); break; case DHCPv4ScopePropertyType.Time: AddOption(new DHCPv4PacketTimeSpanOption(item.OptionIdentifier, ((DHCPv4TimeScopeProperty)item).Value, false)); break; case DHCPv4ScopePropertyType.TimeOffset: AddOption(new DHCPv4PacketTimeSpanOption(item.OptionIdentifier, ((DHCPv4TimeScopeProperty)item).Value, true)); break; case DHCPv4ScopePropertyType.Byte: AddOption(new DHCPv4PacketByteOption(item.OptionIdentifier, (Byte)(((DHCPv4NumericValueScopeProperty)item).Value))); break; case DHCPv4ScopePropertyType.UInt16: AddOption(new DHCPv4PacketUInt16Option(item.OptionIdentifier, (UInt16)(((DHCPv4NumericValueScopeProperty)item).Value))); break; case DHCPv4ScopePropertyType.UInt32: AddOption(new DHCPv4PacketUInt32Option(item.OptionIdentifier, (UInt32)(((DHCPv4NumericValueScopeProperty)item).Value))); break; case DHCPv4ScopePropertyType.Boolean: AddOption(new DHCPv4PacketBooleanOption(item.OptionIdentifier, ((DHCPv4BooleanScopeProperty)item).Value)); break; case DHCPv4ScopePropertyType.AddressAndMask: throw new NotImplementedException(); case DHCPv4ScopePropertyType.Text: AddOption(new DHCPv4PacketTextOption(item.OptionIdentifier, ((DHCPv4TextScopeProperty)item).Value)); break; case DHCPv4ScopePropertyType.ByteArray: //AddOption(new DHCPv4PacketRawByteOption(item.OptionIdentifier, ((DHCPv4RawByteScopeProperty)item).Value)); throw new NotImplementedException(); default: break; } } }