internal DHCPv6Packet HandleRebind(DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver properyResolver) { DHCPv6Packet response = HandleLeaseExtentions(packet, properyResolver, out LeaseExtentionsErros error); var handlingError = DHCPv6RebindHandledEvent.RebindErrors.NoError; switch (error) { case LeaseExtentionsErros.LeaseNotFound: handlingError = DHCPv6RebindHandledEvent.RebindErrors.LeaseNotFound; break; case LeaseExtentionsErros.NoAddressAvailaibe: handlingError = DHCPv6RebindHandledEvent.RebindErrors.NoAddressesAvaiable; break; case LeaseExtentionsErros.OnlyPrefixIsNotAllowed: handlingError = DHCPv6RebindHandledEvent.RebindErrors.OnlyPrefixIsNotAllowed; break; default: break; } base.Apply(new DHCPv6RebindHandledEvent(this.Id, packet, response, handlingError)); return(response); }
internal DHCPv6Packet HandleRelease(DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver properyResolver) { var innerPacket = packet.GetInnerPacket(); DUID clientIdentifier = innerPacket.GetClientIdentifer(); UInt32?identityAssociationId = innerPacket.GetNonTemporaryIdentityAssocationId(); UInt32?prefixIdentityAssociationId = innerPacket.GetPrefixDelegationIdentityAssocationId(); DHCPv6Lease lease = DHCPv6Lease.NotFound; if (identityAssociationId.HasValue == true) { lease = Leases.GetLeaseAssociationIdAndDuid(identityAssociationId.Value, clientIdentifier); } else { var tempLease = Leases.GetLeaseByClientDuid(clientIdentifier); if (tempLease.PrefixDelegation != DHCPv6PrefixDelegation.None && tempLease.PrefixDelegation.IdentityAssociation == prefixIdentityAssociationId.Value ) { lease = tempLease; } } DHCPv6Packet response; var error = DHCPv6ReleaseHandledEvent.ReleaseError.NoError; if (lease == DHCPv6Lease.NotFound) { response = DHCPv6Packet.AsError(packet, DHCPv6StatusCodes.NoBinding, properyResolver.GetServerDuid()); error = DHCPv6ReleaseHandledEvent.ReleaseError.NoLeaseFound; } else { if (lease.IsActive() == false) { response = DHCPv6Packet.AsError(packet, DHCPv6StatusCodes.NoBinding, properyResolver.GetServerDuid()); } else { PrefixBinding prefixBinding = lease.PrefixDelegation != DHCPv6PrefixDelegation.None ? PrefixBinding.FromLease(lease) : null; lease.Release(identityAssociationId.HasValue == false); Leases.Remove(lease); response = DHCPv6Packet.AsReleaseResponse(packet, lease.IdentityAssocicationId, lease.PrefixDelegation.IdentityAssociation, properyResolver.GetServerDuid()); if (prefixBinding != null) { AddNotificationTrigger(PrefixEdgeRouterBindingUpdatedTrigger.WithOldBinding( Id, prefixBinding)); } } } base.Apply(new DHCPv6ReleaseHandledEvent(this.Id, packet, response, error)); return(response); }
internal DHCPv6Packet HandleRequest(DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver properyResolver) { DHCPv6Packet response = HandleRequestInternal(packet, properyResolver, false, out DHCPv6RequestHandledEvent.RequestErrors error, false); base.Apply(new DHCPv6RequestHandledEvent(this.Id, packet, response, error)); return(response); }
public DHCPv6Packet HandleRelease(DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver propertyResolver) { CheckPacket(packet, DHCPv6PacketTypes.RELEASE); DHCPv6Packet result = null; if (packet.IsUnicast() == true) { _logger.LogDebug("RELEASE packet is unicasted. Looking for matching scope based on source address {address}", packet.Header.Source); result = HandlePacketBySourceAddress( packet, (scope) => scope.HandleRelease(packet, propertyResolver), () => new DHCPv6ReleaseHandledEvent(packet) ); } else { _logger.LogDebug("Looking for matching scope based on scope resolvers"); result = HandlePacketByResolver( packet, (scope) => scope.HandleRelease(packet, propertyResolver), () => new DHCPv6ReleaseHandledEvent(packet) ); } return(result); }
public DHCPv6LeaseEngine( IDHCPv6StorageEngine store, DHCPv6RootScope rootScope, IDHCPv6ServerPropertiesResolver serverPropertyResolver, IServiceBus serviceBus, ILogger <DHCPv6LeaseEngine> logger) : base(rootScope, serviceBus, store, logger) { this._serverPropertyResolver = serverPropertyResolver; }
public DHCPv6Packet HandleRequest(DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver propertyResolver) { CheckPacket(packet, DHCPv6PacketTypes.REQUEST); DHCPv6Packet result = HandlePacketByResolver( packet, (scope) => scope.HandleRequest(packet, propertyResolver), () => new DHCPv6RequestHandledEvent(packet) ); return(result); }
public DHCPv6Packet HandleConfirm(DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver propertyResolver) { CheckPacket(packet, DHCPv6PacketTypes.CONFIRM); DHCPv6Packet result = HandlePacketByResolver( packet, (scope) => scope.HandleConfirm(packet, propertyResolver), () => new DHCPv6RebindHandledEvent(packet) ); return(result); }
public DHCPv6Packet HandleSolicit(DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver propertyResolver) { CheckPacket(packet, DHCPv6PacketTypes.Solicit); DHCPv6Packet result = HandlePacketByResolver( packet, (scope) => scope.HandleSolicit(packet, propertyResolver), (scope) => scope.HandleSolicitWithPrefixDelegation(packet, propertyResolver), () => new DHCPv6SolicitHandledEvent(packet) ); return(result); }
internal DHCPv6Packet HandleSolicitWithPrefixDelegation(DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver properyResolver) { DHCPv6Packet innerPacket = packet.GetInnerPacket(); var addressProperties = GetAddressProperties(); Boolean rapitCommit = addressProperties.IsRapitCommitEnabled() && innerPacket.HasRapitCommitOption(); DUID clientDuid = innerPacket.GetClientIdentifer(); DHCPv6Lease currentLease = Leases.GetLeaseByClientDuid(clientDuid); DHCPv6Packet response = null; Boolean responseNeeded = false; Int32 waitingForLease = 15; // In some client implementations like Cisco IOS XE, two solicit packets are sent, one for an address and a second for a prefix, which would be handled without this loop. // Unfortunately, the PD is sent first and as long as the router received an answer for the address the PD packet is not sent again. Hence, progressing is delayed for a small amount of time. while ((currentLease == DHCPv6Lease.NotFound || currentLease.IsActive() == false) && --waitingForLease > 0) { Task.Delay(100).GetAwaiter().GetResult(); currentLease = Leases.GetLeaseByClientDuid(clientDuid); } if (currentLease == DHCPv6Lease.NotFound) { _logger.LogDebug("no lease for client duid {duid} found", clientDuid); base.Apply(new DHCPv6SolicitHandledEvent(this.Id, packet, DHCPv6SolicitHandledEvent.SolicitErros.LeaseNotFound)); } else if (currentLease.IsActive() == false) { _logger.LogDebug("lease with {address} for client duid {duid} found but not active. state is {state}", currentLease.Address, clientDuid, currentLease.State); base.Apply(new DHCPv6SolicitHandledEvent(this.Id, packet, DHCPv6SolicitHandledEvent.SolicitErros.LeaseNotActive)); } else if (addressProperties.PrefixDelgationInfo == null) { _logger.LogDebug("prefix delegation for {name} is not enabled", Name); base.Apply(new DHCPv6SolicitHandledEvent(this.Id, packet, DHCPv6SolicitHandledEvent.SolicitErros.PrefixDelegationNotAvailable)); } else { if (IsFreshPrefix(currentLease) == false) { responseNeeded = true; } else { _logger.LogInformation("a fresh leased prefix found. Skipping creating of a new prefix"); } } if (responseNeeded == true) { UInt32 prefixIdentityAsscocationId = packet.GetInnerPacket().GetPrefixDelegationIdentityAssocationId().Value; var prefix = addressProperties.GetValidPrefix(Leases.GetUsedPrefixes(), prefixIdentityAsscocationId); currentLease.UpdateAddressPrefix(prefix, false); _logger.LogDebug("prefix {prefix}/{lenth} for id {id} is generated", currentLease.PrefixDelegation.NetworkAddress, currentLease.PrefixDelegation.Mask.Identifier.Value, currentLease.PrefixDelegation.IdentityAssociation); if (rapitCommit == true) { _logger.LogDebug("rapit commit is enabled. sending packet as reply"); response = DHCPv6Packet.AsPrefixReplyWithRapitCommit( packet, addressProperties, DHCPv6ScopeProperties.Empty, currentLease, properyResolver.GetServerDuid()); base.AddNotificationTrigger( PrefixEdgeRouterBindingUpdatedTrigger.WithNewBinding(Id, PrefixBinding.FromLease(currentLease) )); } else { _logger.LogDebug("rapit commit is not enabled. sending packet as advertise"); response = DHCPv6Packet.AsPrefixAdvertise( packet, addressProperties, DHCPv6ScopeProperties.Empty, currentLease, properyResolver.GetServerDuid()); } base.Apply(new DHCPv6SolicitHandledEvent(this.Id, packet, response, rapitCommit)); } return(response); }
internal DHCPv6Packet HandleConfirm(DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver properyResolver) { var addressProperties = GetAddressProperties(); var innerPacket = packet.GetInnerPacket(); DUID clientIdentifier = innerPacket.GetClientIdentifer(); UInt32?identityAssociationId = innerPacket.GetNonTemporaryIdentityAssocationId(); UInt32?prefixIdentityAsscocationId = innerPacket.GetPrefixDelegationIdentityAssocationId(); DHCPv6Lease lease; if (identityAssociationId.HasValue == true) { lease = Leases.GetLeaseAssociationIdAndDuid(identityAssociationId.Value, clientIdentifier); } else { lease = Leases.GetLeaseByClientDuid(clientIdentifier); } if (lease == DHCPv6Lease.NotFound) { base.Apply(new DHCPv6ConfirmHandledEvent(this.Id, packet, DHCPv6ConfirmHandledEvent.ConfirmErrors.LeaseNotFound)); return(DHCPv6Packet.Empty); } DHCPv6Packet response; if (lease.IsActive() == false) { response = DHCPv6Packet.AsError(packet, DHCPv6StatusCodes.NotOnLink, properyResolver.GetServerDuid()); base.Apply(new DHCPv6ConfirmHandledEvent(this.Id, packet, response, DHCPv6ConfirmHandledEvent.ConfirmErrors.LeaseNotActive)); } else { Boolean bindingVerified = true; if (identityAssociationId.HasValue == true) { IPv6Address requestedAddress = innerPacket.GetNonTemporaryIdentiyAssocation(identityAssociationId.Value).GetAddress(); if (requestedAddress != lease.Address) { bindingVerified = false; } } if (prefixIdentityAsscocationId.HasValue == true && bindingVerified == true) { if ((prefixIdentityAsscocationId != lease.PrefixDelegation.IdentityAssociation)) { bindingVerified = false; } else { DHCPv6PrefixDelegation requestedPrefix = innerPacket.GetPrefixDelegationIdentiyAssocation(prefixIdentityAsscocationId.Value).GetPrefixDelegation(); bindingVerified = requestedPrefix.AreValuesEqual(lease.PrefixDelegation); } } if (bindingVerified == true) { response = DHCPv6Packet.AsReply(packet, addressProperties, DHCPv6ScopeProperties.Empty, lease, true, properyResolver.GetServerDuid(), false); base.Apply(new DHCPv6ConfirmHandledEvent(this.Id, packet, response)); } else { response = DHCPv6Packet.AsError(packet, DHCPv6StatusCodes.NotOnLink, properyResolver.GetServerDuid()); base.Apply(new DHCPv6ConfirmHandledEvent(this.Id, packet, response, DHCPv6ConfirmHandledEvent.ConfirmErrors.AddressMismtach)); } } return(response); }
private DHCPv6Packet HandleLeaseExtentions(DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver properyResolver, out LeaseExtentionsErros extentionError) { var innerPacket = packet.GetInnerPacket(); var addressProperties = GetAddressProperties(); DUID clientIdentifier = innerPacket.GetClientIdentifer(); UInt32? identityAssociationId = innerPacket.GetNonTemporaryIdentityAssocationId(); UInt32? prefixIdentityAsscocationId = innerPacket.GetPrefixDelegationIdentityAssocationId(); DHCPv6Lease lease; if (identityAssociationId.HasValue == false && prefixIdentityAsscocationId.HasValue == true) { DHCPv6Lease belongingLease = Leases.GetLeaseByClientDuid(clientIdentifier); if (belongingLease == DHCPv6Lease.NotFound) { extentionError = LeaseExtentionsErros.OnlyPrefixIsNotAllowed; return(DHCPv6Packet.AsError(packet, DHCPv6StatusCodes.NoBinding, properyResolver.GetServerDuid())); } // In some client implementations like Cisco IOS XE, two renew packets are sent, one for an address and a second for a prefix. // Unfortunately, if the PD is sent first, the lease is not extented. So... we just wait a second and hopefully than the lease is ready Task.Delay(1000).GetAwaiter().GetResult(); lease = Leases.GetLeaseByClientDuid(clientIdentifier); } else { lease = Leases.GetLeaseAssociationIdAndDuid(identityAssociationId.Value, clientIdentifier); } DHCPv6Packet response = null; extentionError = LeaseExtentionsErros.NoError; if (lease == DHCPv6Lease.NotFound) { response = DHCPv6Packet.AsError(packet, DHCPv6StatusCodes.NoBinding, properyResolver.GetServerDuid()); extentionError = LeaseExtentionsErros.LeaseNotFound; } else { DHCPv6Lease leaseUsedToGenerateResponse = null; if (addressProperties.ReuseAddressIfPossible == true && lease.CanBeExtended() == true) { var tempDelegation = lease.PrefixDelegation; Boolean resetPrefix = false; if (prefixIdentityAsscocationId.HasValue == false && tempDelegation != DHCPv6PrefixDelegation.None) { resetPrefix = true; AddNotificationTrigger( PrefixEdgeRouterBindingUpdatedTrigger.WithOldBinding(Id, PrefixBinding.FromLease(lease))); } else if (tempDelegation == DHCPv6PrefixDelegation.None && prefixIdentityAsscocationId.HasValue == true) { var prefix = addressProperties.GetValidPrefix(Leases.GetUsedPrefixes(), prefixIdentityAsscocationId.Value, lease.PrefixDelegation.NetworkAddress); lease.UpdateAddressPrefix(prefix, false); AddNotificationTrigger( PrefixEdgeRouterBindingUpdatedTrigger.WithNewBinding(Id, PrefixBinding.FromLease(lease))); } if (identityAssociationId.HasValue == true) { var timers = GetLeaseTimers(addressProperties); lease.Renew(timers.Lifespan, timers.RenewTime, timers.ReboundTime, false, resetPrefix); } leaseUsedToGenerateResponse = lease; } else { if ((identityAssociationId.HasValue == true && IsFreshLease(lease) == true) || (prefixIdentityAsscocationId.HasValue == true && IsFreshPrefix(lease) == true)) { leaseUsedToGenerateResponse = lease; } else { PrefixBinding oldBinding = null; PrefixBinding newBinding = null; if (lease.PrefixDelegation != DHCPv6PrefixDelegation.None) { oldBinding = PrefixBinding.FromLease(lease); } if (lease.AddressIsInUse() == true && identityAssociationId.HasValue == true) { Leases.Revoke(lease); } IPv6Address leaseAddress = identityAssociationId.HasValue == true?GetLeasedAddress(addressProperties, lease.Address) : lease.Address; DHCPv6PrefixDelegation leasedPrefix = DHCPv6PrefixDelegation.None; if (prefixIdentityAsscocationId.HasValue == true) { leasedPrefix = addressProperties.GetValidPrefix(Leases.GetUsedPrefixes(), prefixIdentityAsscocationId.Value, lease.PrefixDelegation.NetworkAddress); newBinding = new PrefixBinding(leasedPrefix.NetworkAddress, leasedPrefix.Mask, leaseAddress); if (identityAssociationId.HasValue == false) { lease.UpdateAddressPrefix(leasedPrefix, false); } } if (leaseAddress == IPv6Address.Empty) { base.Apply(new DHCPv6ScopeAddressesAreExhaustedEvent(Id)); AddNotificationTrigger(PrefixEdgeRouterBindingUpdatedTrigger.WithOldBinding(Id, oldBinding)); response = DHCPv6Packet.AsError(packet, DHCPv6StatusCodes.NoAddrsAvail, properyResolver.GetServerDuid()); extentionError = LeaseExtentionsErros.NoAddressAvailaibe; } else { leaseUsedToGenerateResponse = identityAssociationId.HasValue == false ? lease : AddLease(packet, addressProperties, clientIdentifier, identityAssociationId.Value, prefixIdentityAsscocationId, lease, leaseAddress, leasedPrefix); /* * Leases.AddLease( * Guid.NewGuid(), * leaseAddress, * addressProperties.ValidLeaseTime.Value, * addressProperties.T1.Value * addressProperties.ValidLeaseTime.Value, * addressProperties.T2.Value * addressProperties.ValidLeaseTime.Value, * identityAssociationId.Value, * clientIdentifier, * Resolver.HasUniqueIdentifier == true ? Resolver.GetUniqueIdentifier(packet) : null, * prefixIdentityAsscocationId.HasValue == false ? DHCPv6PrefixDelegation.None : leasedPrefix, * lease * ) */ if (identityAssociationId.HasValue == true) { leaseUsedToGenerateResponse.RemovePendingState(); } if (newBinding != null || oldBinding != null && oldBinding != newBinding) { AddNotificationTrigger(new PrefixEdgeRouterBindingUpdatedTrigger(oldBinding, newBinding, Id)); } } } } if (extentionError == LeaseExtentionsErros.NoError) { response = DHCPv6Packet.AsReply(packet, addressProperties, GetScopeProperties(), leaseUsedToGenerateResponse, false, properyResolver.GetServerDuid(), false); } } return(response); }
internal DHCPv6Packet HandleRequestInternal( DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver properyResolver, Boolean isRapitCommit, out DHCPv6RequestHandledEvent.RequestErrors requestError, Boolean onlyGenerateResponse) { var addressProperties = GetAddressProperties(); var innerPacket = packet.GetInnerPacket(); DUID clientIdentifier = innerPacket.GetClientIdentifer(); UInt32?identityAssociationId = innerPacket.GetNonTemporaryIdentityAssocationId(); DHCPv6Lease lease; if (identityAssociationId.HasValue == true) { lease = Leases.GetLeaseAssociationIdAndDuid(identityAssociationId.Value, clientIdentifier); } else { lease = Leases.GetLeaseByClientDuid(clientIdentifier); } requestError = DHCPv6RequestHandledEvent.RequestErrors.NoError; DHCPv6Packet response; if (lease == DHCPv6Lease.Empty) { response = DHCPv6Packet.AsError(packet, DHCPv6StatusCodes.NoAddrsAvail, properyResolver.GetServerDuid()); requestError = DHCPv6RequestHandledEvent.RequestErrors.LeaseNotFound; } else { if (onlyGenerateResponse == true) { return(DHCPv6Packet.AsReply(packet, addressProperties, GetScopeProperties(), lease, true, properyResolver.GetServerDuid(), isRapitCommit)); } var ancsestorLease = lease.HasAncestor() == true?Leases.GetAncestor(lease) : null; if (lease.IsPending() == true) { if (identityAssociationId.HasValue == true) { lease.RemovePendingState(); if (ancsestorLease != null) { Leases.Revoke(ancsestorLease); } response = DHCPv6Packet.AsReply(packet, addressProperties, GetScopeProperties(), lease, false, properyResolver.GetServerDuid(), isRapitCommit); } else { response = DHCPv6Packet.AsError(packet, DHCPv6StatusCodes.NoAddrsAvail, properyResolver.GetServerDuid()); requestError = DHCPv6RequestHandledEvent.RequestErrors.LeasePendingButOnlyPrefixRequested; } } else if (lease.IsActive() == true) { if (identityAssociationId.HasValue == false) { lease.ActivateAddressPrefix(); } response = DHCPv6Packet.AsReply(packet, addressProperties, GetScopeProperties(), lease, true, properyResolver.GetServerDuid(), isRapitCommit); } else { response = DHCPv6Packet.AsError(packet, DHCPv6StatusCodes.NoAddrsAvail, properyResolver.GetServerDuid()); requestError = DHCPv6RequestHandledEvent.RequestErrors.LeaseNotInCorrectState; } if (requestError == DHCPv6RequestHandledEvent.RequestErrors.NoError) { PrefixBinding oldBinding = null; PrefixBinding newBinding = null; if ((ancsestorLease?.PrefixDelegation ?? DHCPv6PrefixDelegation.None) != DHCPv6PrefixDelegation.None) { oldBinding = PrefixBinding.FromLease(ancsestorLease, false); } if (lease.PrefixDelegation != DHCPv6PrefixDelegation.None) { newBinding = PrefixBinding.FromLease(lease, false); } if ((oldBinding != newBinding) && (oldBinding != null || newBinding != null)) { base.AddNotificationTrigger(new PrefixEdgeRouterBindingUpdatedTrigger(oldBinding, newBinding, Id)); } } } return(response); }
internal DHCPv6Packet HandleSolicit(DHCPv6Packet packet, IDHCPv6ServerPropertiesResolver properyResolver) { DHCPv6Packet innerPacket = packet.GetInnerPacket(); var addressProperties = GetAddressProperties(); Boolean rapitCommit = addressProperties.IsRapitCommitEnabled() && innerPacket.HasRapitCommitOption(); DUID clientIdentifier = innerPacket.GetClientIdentifer(); UInt32 identityAssociationId = innerPacket.GetNonTemporaryIdentityAssocationId().Value; UInt32?prefixIdentityAsscocationId = innerPacket.GetPrefixDelegationIdentityAssocationId(); DHCPv6Lease currentLease = Leases.GetLeaseAssociationIdAndDuid(identityAssociationId, clientIdentifier); if (currentLease == null && Resolver.HasUniqueIdentifier) { currentLease = Leases.GetLeaseByUniqueIdentifier(Resolver.GetUniqueIdentifier(packet)); } IPv6Address excludeFromLease = IPv6Address.Empty; IPv6Address excludeFromPrefix = IPv6Address.Empty; IPv6Address leaseAddress = IPv6Address.Empty; DHCPv6PrefixDelegation leasedPrefix = DHCPv6PrefixDelegation.None; Boolean skipLeaseCreation = false; if (currentLease != DHCPv6Lease.NotFound) { _logger.LogDebug("active lease found for client {duid} and {iaid}", clientIdentifier, identityAssociationId); if (IsFreshLease(currentLease) == true) { _logger.LogInformation("a fresh lease found. Skipping creating of a new lease"); skipLeaseCreation = true; } else { if (addressProperties.ReuseAddressIfPossible == true && currentLease.CanBeExtended() == true) { leaseAddress = currentLease.Address; leasedPrefix = currentLease.PrefixDelegation; } else { if (currentLease.IsActive() == true || currentLease.IsPending() == true) { excludeFromLease = IPv6Address.FromByteArray(currentLease.Address.GetBytes()); excludeFromPrefix = currentLease.PrefixDelegation.NetworkAddress; } } } } if (skipLeaseCreation == false) { if (leaseAddress == IPv6Address.Empty) { leaseAddress = GetLeasedAddress(addressProperties, excludeFromLease); if (leaseAddress == IPv6Address.Empty) { _logger.LogError("{scope} has no ip addresses left", Name); base.Apply(new DHCPv6ScopeAddressesAreExhaustedEvent(Id)); base.Apply(new DHCPv6SolicitHandledEvent(this.Id, packet, DHCPv6SolicitHandledEvent.SolicitErros.NoAddressesLeft)); return(DHCPv6Packet.Empty); } } if (prefixIdentityAsscocationId.HasValue == true && leasedPrefix == DHCPv6PrefixDelegation.None) { leasedPrefix = addressProperties.GetValidPrefix(Leases.GetUsedPrefixes(), prefixIdentityAsscocationId.Value, excludeFromPrefix); } currentLease = AddLease(packet, addressProperties, clientIdentifier, identityAssociationId, prefixIdentityAsscocationId, currentLease, leaseAddress, leasedPrefix); } DHCPv6Packet response; if (rapitCommit == true) { response = HandleRequestInternal(packet, properyResolver, true, out DHCPv6RequestHandledEvent.RequestErrors _, skipLeaseCreation); } else { response = DHCPv6Packet.AsAdvertise( packet, currentLease, prefixIdentityAsscocationId.HasValue == false ? DHCPv6PrefixDelegation.None : leasedPrefix, addressProperties, GetScopeProperties(), properyResolver.GetServerDuid()); } base.Apply(new DHCPv6SolicitHandledEvent(this.Id, packet, response, rapitCommit)); return(response); }