diff --git a/DnsServerCore/Dhcp/Scope.cs b/DnsServerCore/Dhcp/Scope.cs index 35b9d454..81d661a1 100644 --- a/DnsServerCore/Dhcp/Scope.cs +++ b/DnsServerCore/Dhcp/Scope.cs @@ -21,15 +21,19 @@ using DnsServerCore.Dhcp.Options; using System; using System.Collections.Concurrent; using System.Collections.Generic; +using System.IO; using System.Linq; using System.Net; using System.Net.NetworkInformation; using System.Net.Sockets; -using System.Threading; +using System.Text; +using TechnitiumLibrary.IO; +using TechnitiumLibrary.Net; +using TechnitiumLibrary.Net.Dns; namespace DnsServerCore.Dhcp { - public class Scope : IDisposable, IEquatable + public class Scope { #region variables @@ -39,48 +43,45 @@ namespace DnsServerCore.Dhcp IPAddress _startingAddress; IPAddress _endingAddress; IPAddress _subnetMask; + uint _leaseTime = 86400; //default 1 day lease + ushort _offerDelayTime; - //optional parameters + //dhcp options string _domainName; + uint _dnsTtl = 900; IPAddress _routerAddress; IPAddress[] _dnsServers; IPAddress[] _winsServers; IPAddress[] _ntpServers; ClasslessStaticRouteOption.Route[] _staticRoutes; - uint _leaseTime = 86400; //default 1 day lease - ushort _delayTime; - bool _autoRouter; - bool _autoDnsServer; - bool _reservedAddressOffersOnly; - readonly List _exclusions = new List(); - readonly ConcurrentDictionary _reservedAddresses = new ConcurrentDictionary(); + + //advanced options + Exclusion[] _exclusions; + Lease[] _reservedLeases; + bool _allowOnlyReservedLeases; //leases readonly ConcurrentDictionary _leases = new ConcurrentDictionary(); - //computed parameters + //internal computed parameters IPAddress _networkAddress; IPAddress _broadcastAddress; + string _reverseZone; uint _renewTime; uint _rebindTime; //internal parameters + const int OFFER_EXPIRY_SECONDS = 60; //1 mins offer expiry readonly ConcurrentDictionary _offers = new ConcurrentDictionary(); IPAddress _lastAddressOffered; - const int OFFER_EXPIRY_SECONDS = 120; //2 mins offer expiry - - bool _isActive; IPAddress _interfaceAddress; - LogManager _log; - - Timer _maintenanceTimer; - const int MAINTENANCE_TIMER_INTERVAL = 60000; + DateTime _lastModified = DateTime.UtcNow; #endregion #region constructor - public Scope(string name, IPAddress startingAddress, IPAddress endingAddress, IPAddress subnetMask, bool enabled) + public Scope(string name, bool enabled, IPAddress startingAddress, IPAddress endingAddress, IPAddress subnetMask) { _name = name; _enabled = enabled; @@ -89,33 +90,123 @@ namespace DnsServerCore.Dhcp _renewTime = _leaseTime / 2; _rebindTime = Convert.ToUInt32(_leaseTime * 0.875); - - StartMaintenanceTimer(); } - #endregion - - #region IDisposable - - bool _disposed = false; - - protected virtual void Dispose(bool disposing) + public Scope(BinaryReader bR) { - if (_disposed) - return; + if (Encoding.ASCII.GetString(bR.ReadBytes(2)) != "SC") + throw new InvalidDataException("DhcpServer scope file format is invalid."); - if (disposing) + switch (bR.ReadByte()) { - if (_maintenanceTimer != null) - _maintenanceTimer.Dispose(); + case 1: + _name = bR.ReadShortString(); + _enabled = bR.ReadBoolean(); + + ChangeNetwork(IPAddressExtension.Parse(bR), IPAddressExtension.Parse(bR), IPAddressExtension.Parse(bR)); + + _leaseTime = bR.ReadUInt32(); + _renewTime = _leaseTime / 2; + _rebindTime = Convert.ToUInt32(_leaseTime * 0.875); + + _offerDelayTime = bR.ReadUInt16(); + + _domainName = bR.ReadShortString(); + if (_domainName == "") + _domainName = null; + + _dnsTtl = bR.ReadUInt32(); + + _routerAddress = IPAddressExtension.Parse(bR); + if (_routerAddress.Equals(IPAddress.Any)) + _routerAddress = null; + + { + int count = bR.ReadByte(); + if (count > 0) + { + _dnsServers = new IPAddress[count]; + + for (int i = 0; i < count; i++) + _dnsServers[i] = IPAddressExtension.Parse(bR); + } + } + + { + int count = bR.ReadByte(); + if (count > 0) + { + _winsServers = new IPAddress[count]; + + for (int i = 0; i < count; i++) + _winsServers[i] = IPAddressExtension.Parse(bR); + } + } + + { + int count = bR.ReadByte(); + if (count > 0) + { + _ntpServers = new IPAddress[count]; + + for (int i = 0; i < count; i++) + _ntpServers[i] = IPAddressExtension.Parse(bR); + } + } + + { + int count = bR.ReadByte(); + if (count > 0) + { + _staticRoutes = new ClasslessStaticRouteOption.Route[count]; + + for (int i = 0; i < count; i++) + _staticRoutes[i] = new ClasslessStaticRouteOption.Route(bR.BaseStream); + } + } + + { + int count = bR.ReadByte(); + if (count > 0) + { + _exclusions = new Exclusion[count]; + + for (int i = 0; i < count; i++) + _exclusions[i] = new Exclusion(IPAddressExtension.Parse(bR), IPAddressExtension.Parse(bR)); + } + } + + { + int count = bR.ReadInt32(); + if (count > 0) + { + _reservedLeases = new Lease[count]; + + for (int i = 0; i < count; i++) + _reservedLeases[i] = new Lease(bR); + } + + _allowOnlyReservedLeases = bR.ReadBoolean(); + } + + { + int count = bR.ReadInt32(); + if (count > 0) + { + for (int i = 0; i < count; i++) + { + Lease lease = new Lease(bR); + + _leases.TryAdd(lease.ClientIdentifier, lease); + } + } + } + + break; + + default: + throw new InvalidDataException("Scope data format version not supported."); } - - _disposed = true; - } - - public void Dispose() - { - Dispose(true); } #endregion @@ -124,9 +215,9 @@ namespace DnsServerCore.Dhcp public static bool IsAddressInRange(IPAddress address, IPAddress startingAddress, IPAddress endingAddress) { - uint addressNumber = ConvertIpToNumber(address); - uint startingAddressNumber = ConvertIpToNumber(startingAddress); - uint endingAddressNumber = ConvertIpToNumber(endingAddress); + uint addressNumber = address.ConvertIpToNumber(); + uint startingAddressNumber = startingAddress.ConvertIpToNumber(); + uint endingAddressNumber = endingAddress.ConvertIpToNumber(); return (startingAddressNumber <= addressNumber) && (addressNumber <= endingAddressNumber); } @@ -135,20 +226,6 @@ namespace DnsServerCore.Dhcp #region private - private static uint ConvertIpToNumber(IPAddress address) - { - byte[] addr = address.GetAddressBytes(); - Array.Reverse(addr); - return BitConverter.ToUInt32(addr, 0); - } - - private static IPAddress ConvertNumberToIp(uint address) - { - byte[] addr = BitConverter.GetBytes(address); - Array.Reverse(addr); - return new IPAddress(addr); - } - private bool IsAddressAvailable(ref IPAddress address) { if (address.Equals(_routerAddress)) @@ -163,7 +240,7 @@ namespace DnsServerCore.Dhcp if ((_ntpServers != null) && _ntpServers.Contains(address)) return false; - lock (_exclusions) + if (_exclusions != null) { foreach (Exclusion exclusion in _exclusions) { @@ -175,9 +252,9 @@ namespace DnsServerCore.Dhcp } } - foreach (KeyValuePair reservedAddress in _reservedAddresses) + foreach (Lease reservedLease in _reservedLeases) { - if (address.Equals(reservedAddress.Value.Address)) + if (address.Equals(reservedLease.Address)) return false; } @@ -212,7 +289,7 @@ namespace DnsServerCore.Dhcp responseFlags |= ClientFullyQualifiedDomainNameFlags.OverrideByServer; } - string responseDomainName; + string clientDomainName; if (request.ClientFullyQualifiedDomainName.DomainName == "") { @@ -220,72 +297,53 @@ namespace DnsServerCore.Dhcp if (request.HostName == null) return null; //server unable to decide a name for client - responseDomainName = request.HostName.HostName + "." + _domainName; + clientDomainName = request.HostName.HostName + "." + _domainName; } else if (request.ClientFullyQualifiedDomainName.DomainName.Contains(".")) { //client domain is fqdn if (request.ClientFullyQualifiedDomainName.DomainName.EndsWith("." + _domainName, StringComparison.OrdinalIgnoreCase)) { - responseDomainName = request.ClientFullyQualifiedDomainName.DomainName; + clientDomainName = request.ClientFullyQualifiedDomainName.DomainName; } else { string[] parts = request.ClientFullyQualifiedDomainName.DomainName.Split('.'); - responseDomainName = parts[0] + "." + _domainName; + clientDomainName = parts[0] + "." + _domainName; } } else { //client domain is just hostname - responseDomainName = request.ClientFullyQualifiedDomainName.DomainName + "." + _domainName; + clientDomainName = request.ClientFullyQualifiedDomainName.DomainName + "." + _domainName; } - return new ClientFullyQualifiedDomainNameOption(responseFlags, 255, 255, responseDomainName); - } - - private void StartMaintenanceTimer() - { - if (_maintenanceTimer == null) - { - _maintenanceTimer = new Timer(delegate (object state) - { - try - { - List expiredOffers = new List(); - DateTime utcNow = DateTime.UtcNow; - - foreach (KeyValuePair offer in _offers) - { - if (offer.Value.LeaseObtained.AddSeconds(OFFER_EXPIRY_SECONDS) > utcNow) - { - //offer expired - expiredOffers.Add(offer.Key); - } - } - - foreach (ClientIdentifierOption expiredOffer in expiredOffers) - _offers.TryRemove(expiredOffer, out _); - } - catch (Exception ex) - { - LogManager log = _log; - if (log != null) - log.Write(ex); - } - finally - { - if (!_disposed) - _maintenanceTimer.Change(MAINTENANCE_TIMER_INTERVAL, Timeout.Infinite); - } - }, null, MAINTENANCE_TIMER_INTERVAL, Timeout.Infinite); - } + return new ClientFullyQualifiedDomainNameOption(responseFlags, 255, 255, clientDomainName); } #endregion #region internal + internal static string GetReverseZone(IPAddress address, IPAddress subnetMask) + { + return GetReverseZone(address, subnetMask.GetSubnetMaskWidth()); + } + + internal static string GetReverseZone(IPAddress address, int subnetMaskWidth) + { + int addressByteCount = Convert.ToInt32(Math.Ceiling(Convert.ToDecimal(subnetMaskWidth) / 8)); + byte[] addressBytes = address.GetAddressBytes(); + string reverseZone = ""; + + for (int i = 0; i < addressByteCount; i++) + reverseZone = addressBytes[i] + "." + reverseZone; + + reverseZone += "in-addr.arpa"; + + return reverseZone; + } + internal bool IsAddressInRange(IPAddress address) { return IsAddressInRange(address, _startingAddress, _endingAddress); @@ -299,18 +357,22 @@ namespace DnsServerCore.Dhcp return existingLease; } - if (_reservedAddresses.TryGetValue(request.ClientIdentifier, out Lease existingReservedAddress)) + ClientIdentifierOption clientIdentifier = new ClientIdentifierOption(1, request.ClientHardwareAddress); + foreach (Lease reservedLease in _reservedLeases) { - //reserved address exists - Lease reservedOffer = new Lease(request.ClientIdentifier, request.HostName?.HostName, request.ClientHardwareAddress, existingReservedAddress.Address, _leaseTime); - - return _offers.AddOrUpdate(request.ClientIdentifier, reservedOffer, delegate (ClientIdentifierOption key, Lease existingValue) + if (reservedLease.ClientIdentifier.Equals(clientIdentifier)) { - return reservedOffer; - }); + //reserved address exists + Lease reservedOffer = new Lease(request.ClientIdentifier, request.HostName?.HostName, request.ClientHardwareAddress, reservedLease.Address, _leaseTime); + + return _offers.AddOrUpdate(request.ClientIdentifier, reservedOffer, delegate (ClientIdentifierOption key, Lease existingValue) + { + return reservedOffer; + }); + } } - if (_reservedAddressOffersOnly) + if (_allowOnlyReservedLeases) return null; //client does not have reserved address as per scope requirements Lease dummyOffer = new Lease(request.ClientIdentifier, request.HostName?.HostName, request.ClientHardwareAddress, null, _leaseTime); @@ -347,7 +409,7 @@ namespace DnsServerCore.Dhcp while (true) { - offerAddress = ConvertNumberToIp(ConvertIpToNumber(offerAddress) + 1u); + offerAddress = IPAddressExtension.ConvertNumberToIp(offerAddress.ConvertIpToNumber() + 1u); if (offerAddress.Equals(_endingAddress)) { @@ -429,14 +491,10 @@ namespace DnsServerCore.Dhcp options.Add(GetClientFullyQualifiedDomainNameOption(request)); } - if (_autoRouter) - options.Add(new RouterOption(new IPAddress[] { interfaceAddress })); - else if (_routerAddress != null) + if (_routerAddress != null) options.Add(new RouterOption(new IPAddress[] { _routerAddress })); - if (_autoDnsServer) - options.Add(new DomainNameServerOption(new IPAddress[] { interfaceAddress })); - else if (_dnsServers != null) + if (_dnsServers != null) options.Add(new DomainNameServerOption(_dnsServers)); if (_winsServers != null) @@ -471,17 +529,13 @@ namespace DnsServerCore.Dhcp break; case DhcpOptionCode.Router: - if (_autoRouter) - options.Add(new RouterOption(new IPAddress[] { interfaceAddress })); - else if (_routerAddress != null) + if (_routerAddress != null) options.Add(new RouterOption(new IPAddress[] { _routerAddress })); break; case DhcpOptionCode.DomainNameServer: - if (_autoDnsServer) - options.Add(new DomainNameServerOption(new IPAddress[] { interfaceAddress })); - else if (_dnsServers != null) + if (_dnsServers != null) options.Add(new DomainNameServerOption(_dnsServers)); break; @@ -520,21 +574,70 @@ namespace DnsServerCore.Dhcp { return lease; }); + + _lastModified = DateTime.UtcNow; } internal void ReleaseLease(Lease lease) { _leases.TryRemove(lease.ClientIdentifier, out _); + + _lastModified = DateTime.UtcNow; } - internal void SetActive(bool isActive) + internal void SetEnabled(bool isEnabled) { - _isActive = isActive; + _enabled = isEnabled; - if (!_isActive) + if (!isEnabled) _interfaceAddress = null; //remove interface address on deactivation to allow finding it back on activation } + internal void RemoveExpiredOffers() + { + List expiredOffers = new List(); + DateTime utcNow = DateTime.UtcNow; + + foreach (KeyValuePair offer in _offers) + { + if (utcNow > offer.Value.LeaseObtained.AddSeconds(OFFER_EXPIRY_SECONDS)) + { + //offer expired + expiredOffers.Add(offer.Key); + } + } + + foreach (ClientIdentifierOption expiredOffer in expiredOffers) + _offers.TryRemove(expiredOffer, out _); + } + + internal List RemoveExpiredLeases() + { + List expiredLeaseKeys = new List(); + DateTime utcNow = DateTime.UtcNow; + + foreach (KeyValuePair lease in _leases) + { + if (utcNow > lease.Value.LeaseExpires) + { + //lease expired + expiredLeaseKeys.Add(lease.Key); + } + } + + List expiredLeases = new List(); + + foreach (ClientIdentifierOption expiredLeaseKey in expiredLeaseKeys) + { + if (_leases.TryRemove(expiredLeaseKey, out Lease expiredLease)) + expiredLeases.Add(expiredLease); + } + + _lastModified = DateTime.UtcNow; + + return expiredLeases; + } + #endregion #region public @@ -550,8 +653,8 @@ namespace DnsServerCore.Dhcp if (subnetMask.AddressFamily != AddressFamily.InterNetwork) throw new ArgumentException("Address family not supported.", "subnetMask"); - uint startingAddressNumber = ConvertIpToNumber(startingAddress); - uint endingAddressNumber = ConvertIpToNumber(endingAddress); + uint startingAddressNumber = startingAddress.ConvertIpToNumber(); + uint endingAddressNumber = endingAddress.ConvertIpToNumber(); if (startingAddressNumber >= endingAddressNumber) throw new ArgumentException("Ending address must be greater than starting address.", "endingAddress"); @@ -561,76 +664,119 @@ namespace DnsServerCore.Dhcp _subnetMask = subnetMask; //compute other parameters - uint subnetMaskNumber = ConvertIpToNumber(_subnetMask); + uint subnetMaskNumber = _subnetMask.ConvertIpToNumber(); uint networkAddressNumber = startingAddressNumber & subnetMaskNumber; - _networkAddress = ConvertNumberToIp(networkAddressNumber); - _broadcastAddress = ConvertNumberToIp(networkAddressNumber | ~subnetMaskNumber); + _networkAddress = IPAddressExtension.ConvertNumberToIp(networkAddressNumber); + _broadcastAddress = IPAddressExtension.ConvertNumberToIp(networkAddressNumber | ~subnetMaskNumber); + _reverseZone = GetReverseZone(_networkAddress, _subnetMask); _lastAddressOffered = _startingAddress; } - public void AddExclusion(IPAddress startingAddress, IPAddress endingAddress) + public void WriteTo(BinaryWriter bW) { - if (!IsAddressInRange(startingAddress)) - throw new ArgumentOutOfRangeException("startingAddress", "Exclusion address must be in scope range."); + bW.Write(Encoding.ASCII.GetBytes("SC")); + bW.Write((byte)1); //version - if (!IsAddressInRange(endingAddress)) - throw new ArgumentOutOfRangeException("endingAddress", "Exclusion address must be in scope range."); + bW.WriteShortString(_name); + bW.Write(_enabled); + _startingAddress.WriteTo(bW); + _endingAddress.WriteTo(bW); + _subnetMask.WriteTo(bW); + bW.Write(_leaseTime); + bW.Write(_offerDelayTime); - lock (_exclusions) + if (string.IsNullOrEmpty(_domainName)) + bW.Write((byte)0); + else + bW.WriteShortString(_domainName); + + bW.Write(_dnsTtl); + + if (_routerAddress == null) + IPAddress.Any.WriteTo(bW); + else + _routerAddress.WriteTo(bW); + + if (_dnsServers == null) { - foreach (Exclusion exclusion in _exclusions) - { - if (IsAddressInRange(startingAddress, exclusion.StartingAddress, exclusion.EndingAddress)) - throw new ArgumentException("Exclusion range overlaps existing exclusion."); - - if (IsAddressInRange(endingAddress, exclusion.StartingAddress, exclusion.EndingAddress)) - throw new ArgumentException("Exclusion range overlaps existing exclusion."); - } - - _exclusions.Add(new Exclusion(startingAddress, endingAddress)); + bW.Write((byte)0); } - } - - public bool RemoveExclusion(IPAddress startingAddress, IPAddress endingAddress) - { - lock (_exclusions) + else { - Exclusion exclusionFound = null; + bW.Write(Convert.ToByte(_dnsServers.Length)); + + foreach (IPAddress dnsServer in _dnsServers) + dnsServer.WriteTo(bW); + } + + if (_winsServers == null) + { + bW.Write((byte)0); + } + else + { + bW.Write(Convert.ToByte(_winsServers.Length)); + + foreach (IPAddress winsServer in _winsServers) + winsServer.WriteTo(bW); + } + + if (_ntpServers == null) + { + bW.Write((byte)0); + } + else + { + bW.Write(Convert.ToByte(_ntpServers.Length)); + + foreach (IPAddress ntpServer in _ntpServers) + ntpServer.WriteTo(bW); + } + + if (_staticRoutes == null) + { + bW.Write((byte)0); + } + else + { + bW.Write(Convert.ToByte(_staticRoutes.Length)); + + foreach (ClasslessStaticRouteOption.Route route in _staticRoutes) + route.WriteTo(bW.BaseStream); + } + + if (_exclusions == null) + { + bW.Write((byte)0); + } + else + { + bW.Write(Convert.ToByte(_exclusions.Length)); foreach (Exclusion exclusion in _exclusions) { - if (exclusion.StartingAddress.Equals(startingAddress) && exclusion.EndingAddress.Equals(endingAddress)) - { - exclusionFound = exclusion; - break; - } + exclusion.StartingAddress.WriteTo(bW); + exclusion.EndingAddress.WriteTo(bW); } - - if (exclusionFound == null) - return false; - - return _exclusions.Remove(exclusionFound); } - } - public void AddReservedAddress(byte[] hardwareAddress, IPAddress address) - { - if (!IsAddressInRange(address)) - throw new ArgumentOutOfRangeException("address", "Reserved address must be in scope range."); - - Lease reservedLease = new Lease(hardwareAddress, address, _leaseTime); - - _reservedAddresses.AddOrUpdate(new ClientIdentifierOption(1, hardwareAddress), reservedLease, delegate (ClientIdentifierOption key, Lease existingValue) { - return reservedLease; - }); - } + bW.Write(_reservedLeases.Length); - public bool RemoveReservedAddress(byte[] hardwareAddress) - { - return _reservedAddresses.TryRemove(new ClientIdentifierOption(1, hardwareAddress), out _); + foreach (Lease reservedLease in _reservedLeases) + reservedLease.WriteTo(bW); + + bW.Write(_allowOnlyReservedLeases); + } + + { + bW.Write(_leases.Count); + + foreach (KeyValuePair lease in _leases) + lease.Value.WriteTo(bW); + } } public override bool Equals(object obj) @@ -655,9 +801,6 @@ namespace DnsServerCore.Dhcp if (!_endingAddress.Equals(other._endingAddress)) return false; - if (!_subnetMask.Equals(other._subnetMask)) - return false; - return true; } @@ -686,10 +829,7 @@ namespace DnsServerCore.Dhcp } public bool Enabled - { - get { return _enabled; } - set { _enabled = value; } - } + { get { return _enabled; } } public IPAddress StartingAddress { get { return _startingAddress; } } @@ -700,10 +840,37 @@ namespace DnsServerCore.Dhcp public IPAddress SubnetMask { get { return _subnetMask; } } + public uint LeaseTime + { + get { return _leaseTime; } + set + { + _leaseTime = value; + _renewTime = _leaseTime / 2; + _rebindTime = Convert.ToUInt32(_leaseTime * 0.875); + } + } + + public ushort OfferDelayTime + { + get { return _offerDelayTime; } + set { _offerDelayTime = value; } + } + public string DomainName { get { return _domainName; } - set { _domainName = value; } + set + { + DnsClient.IsDomainNameValid(value, true); + _domainName = value; + } + } + + public uint DnsTtl + { + get { return _dnsTtl; } + set { _dnsTtl = value; } } public IPAddress RouterAddress @@ -736,54 +903,64 @@ namespace DnsServerCore.Dhcp set { _staticRoutes = value; } } - public uint LeaseTime - { - get { return _leaseTime; } - set - { - _leaseTime = value; - _renewTime = _leaseTime / 2; - _rebindTime = Convert.ToUInt32(_leaseTime * 0.875); - } - } - - public ushort DelayTime - { - get { return _delayTime; } - set { _delayTime = value; } - } - - public bool AutoRouter - { - get { return _autoRouter; } - set { _autoRouter = value; } - } - - public bool AutoDnsServer - { - get { return _autoDnsServer; } - set { _autoDnsServer = value; } - } - - public bool ReservedAddressOffersOnly - { - get { return _reservedAddressOffersOnly; } - set { _reservedAddressOffersOnly = value; } - } - public Exclusion[] Exclusions { get { - lock (_exclusions) + return _exclusions; + } + set + { + if (value == null) { - return _exclusions.ToArray(); + _exclusions = null; + } + else + { + foreach (Exclusion exclusion in value) + { + if (!IsAddressInRange(exclusion.StartingAddress)) + throw new ArgumentOutOfRangeException("StartingAddress", "Exclusion address must be in scope range."); + + if (!IsAddressInRange(exclusion.EndingAddress)) + throw new ArgumentOutOfRangeException("EndingAddress", "Exclusion address must be in scope range."); + } + + _exclusions = value; } } } - public ICollection ReservedAddresses - { get { return _reservedAddresses.Values; } } + public Lease[] ReservedLeases + { + get + { + return _reservedLeases; + } + set + { + if (value == null) + { + _reservedLeases = null; + } + else + { + foreach (Lease reservedLease in value) + { + if (!IsAddressInRange(reservedLease.Address)) + throw new ArgumentOutOfRangeException("Address", "Reserved address must be in scope range."); + } + + _reservedLeases = value; + } + } + } + + public bool AllowOnlyReservedLeases + { + get { return _allowOnlyReservedLeases; } + set { _allowOnlyReservedLeases = value; } + } public ICollection Leases { get { return _leases.Values; } } @@ -794,8 +971,8 @@ namespace DnsServerCore.Dhcp public IPAddress BroadcastAddress { get { return _broadcastAddress; } } - public bool IsActive - { get { return _isActive; } } + public string ReverseZone + { get { return _reverseZone; } } public IPAddress InterfaceAddress { @@ -803,8 +980,8 @@ namespace DnsServerCore.Dhcp { if (_interfaceAddress == null) { - uint networkAddressNumber = ConvertIpToNumber(_networkAddress); - uint subnetMaskNumber = ConvertIpToNumber(_subnetMask); + uint networkAddressNumber = _networkAddress.ConvertIpToNumber(); + uint subnetMaskNumber = _subnetMask.ConvertIpToNumber(); foreach (NetworkInterface nic in NetworkInterface.GetAllNetworkInterfaces()) { @@ -817,10 +994,13 @@ namespace DnsServerCore.Dhcp { if (ip.Address.AddressFamily == AddressFamily.InterNetwork) { - uint addressNumber = ConvertIpToNumber(ip.Address); + uint addressNumber = ip.Address.ConvertIpToNumber(); if ((addressNumber & subnetMaskNumber) == networkAddressNumber) - return ip.Address; + { + _interfaceAddress = ip.Address; + return _interfaceAddress; + } } } } @@ -832,11 +1012,8 @@ namespace DnsServerCore.Dhcp } } - internal LogManager LogManager - { - get { return _log; } - set { _log = value; } - } + internal DateTime LastModified + { get { return _lastModified; } } #endregion }