RaspberryIO/Unosquare.Swan/Network.cs

using Unosquare.Swan.Networking;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;

namespace Unosquare.Swan {
  /// <summary>
  /// Provides miscellaneous network utilities such as a Public IP finder,
  /// a DNS client to query DNS records of any kind, and an NTP client.
  /// </summary>
  public static class Network {
    /// <summary>
    /// The DNS default port.
    /// </summary>
    public const Int32 DnsDefaultPort = 53;

    /// <summary>
    /// The NTP default port.
    /// </summary>
    public const Int32 NtpDefaultPort = 123;

    /// <summary>
    /// Gets the name of the host.
    /// </summary>
    /// <value>
    /// The name of the host.
    /// </value>
    public static String HostName => IPGlobalProperties.GetIPGlobalProperties().HostName;

    /// <summary>
    /// Gets the name of the network domain.
    /// </summary>
    /// <value>
    /// The name of the network domain.
    /// </value>
    public static String DomainName => IPGlobalProperties.GetIPGlobalProperties().DomainName;

    #region IP Addresses and Adapters Information Methods

    /// <summary>
    /// Gets the active IPv4 interfaces.
    /// Only those interfaces with a valid unicast address and a valid gateway will be returned in the collection.
    /// </summary>
    /// <returns>
    /// A collection of NetworkInterface/IPInterfaceProperties pairs
    /// that represents the active IPv4 interfaces.
    /// </returns>
    public static Dictionary<NetworkInterface, IPInterfaceProperties> GetIPv4Interfaces() {
      // zero conf ip address
      IPAddress zeroConf = new IPAddress(0);

      NetworkInterface[] adapters = NetworkInterface.GetAllNetworkInterfaces()
          .Where(network =>
              network.OperationalStatus == OperationalStatus.Up
              && network.NetworkInterfaceType != NetworkInterfaceType.Unknown
              && network.NetworkInterfaceType != NetworkInterfaceType.Loopback)
          .ToArray();

      Dictionary<NetworkInterface, IPInterfaceProperties> result = new Dictionary<NetworkInterface, IPInterfaceProperties>();

      foreach(NetworkInterface adapter in adapters) {
        IPInterfaceProperties properties = adapter.GetIPProperties();
        if(properties == null
            || properties.GatewayAddresses.Count == 0
            || properties.GatewayAddresses.All(gateway => Equals(gateway.Address, zeroConf))
            || properties.UnicastAddresses.Count == 0
            || properties.GatewayAddresses.All(address => Equals(address.Address, zeroConf))
            || properties.UnicastAddresses.Any(a => a.Address.AddressFamily == AddressFamily.InterNetwork) ==
            false) {
          continue;
        }

        result[adapter] = properties;
      }

      return result;
    }

    /// <summary>
    /// Retrieves the local ip addresses.
    /// </summary>
    /// <param name="includeLoopback">if set to <c>true</c> [include loopback].</param>
    /// <returns>An array of local ip addresses.</returns>
    public static IPAddress[] GetIPv4Addresses(Boolean includeLoopback = true) =>
        GetIPv4Addresses(NetworkInterfaceType.Unknown, true, includeLoopback);

    /// <summary>
    /// Retrieves the local ip addresses.
    /// </summary>
    /// <param name="interfaceType">Type of the interface.</param>
    /// <param name="skipTypeFilter">if set to <c>true</c> [skip type filter].</param>
    /// <param name="includeLoopback">if set to <c>true</c> [include loopback].</param>
    /// <returns>An array of local ip addresses.</returns>
    public static IPAddress[] GetIPv4Addresses(
        NetworkInterfaceType interfaceType,
        Boolean skipTypeFilter = false,
        Boolean includeLoopback = false) {
      List<IPAddress> addressList = new List<IPAddress>();
      NetworkInterface[] interfaces = NetworkInterface.GetAllNetworkInterfaces()
          .Where(ni =>
#if NET452
                    ni.IsReceiveOnly == false &&
#endif
                    (skipTypeFilter || ni.NetworkInterfaceType == interfaceType) &&
              ni.OperationalStatus == OperationalStatus.Up)
          .ToArray();

      foreach(NetworkInterface networkInterface in interfaces) {
        IPInterfaceProperties properties = networkInterface.GetIPProperties();

        if(properties.GatewayAddresses.All(g => g.Address.AddressFamily != AddressFamily.InterNetwork)) {
          continue;
        }

        addressList.AddRange(properties.UnicastAddresses
            .Where(i => i.Address.AddressFamily == AddressFamily.InterNetwork)
            .Select(i => i.Address));
      }

      if(includeLoopback || interfaceType == NetworkInterfaceType.Loopback) {
        addressList.Add(IPAddress.Loopback);
      }

      return addressList.ToArray();
    }

    /// <summary>
    /// Gets the public IP address using ipify.org.
    /// </summary>
    /// <param name="ct">The cancellation token.</param>
    /// <returns>A public IP address of the result produced by this Task.</returns>
    public static async Task<IPAddress> GetPublicIPAddressAsync(CancellationToken ct = default) {
      using(HttpClient client = new HttpClient()) {
        HttpResponseMessage response = await client.GetAsync("https://api.ipify.org", ct).ConfigureAwait(false);
        return IPAddress.Parse(await response.Content.ReadAsStringAsync().ConfigureAwait(false));
      }
    }

    /// <summary>
    /// Gets the public IP address using ipify.org.
    /// </summary>
    /// <returns>A public ip address.</returns>
    public static IPAddress GetPublicIPAddress() => GetPublicIPAddressAsync().GetAwaiter().GetResult();

    /// <summary>
    /// Gets the configured IPv4 DNS servers for the active network interfaces.
    /// </summary>
    /// <returns>
    /// A collection of NetworkInterface/IPInterfaceProperties pairs
    /// that represents the active IPv4 interfaces.
    /// </returns>
    public static IPAddress[] GetIPv4DnsServers()
        => GetIPv4Interfaces()
            .Select(a => a.Value.DnsAddresses.Where(d => d.AddressFamily == AddressFamily.InterNetwork))
            .SelectMany(d => d)
            .ToArray();

    #endregion

    #region DNS and NTP Clients

    /// <summary>
    /// Gets the DNS host entry (a list of IP addresses) for the domain name.
    /// </summary>
    /// <param name="fqdn">The FQDN.</param>
    /// <returns>An array of local ip addresses.</returns>
    public static IPAddress[] GetDnsHostEntry(String fqdn) {
      IPAddress dnsServer = GetIPv4DnsServers().FirstOrDefault() ?? IPAddress.Parse("8.8.8.8");
      return GetDnsHostEntry(fqdn, dnsServer, DnsDefaultPort);
    }

    /// <summary>
    /// Gets the DNS host entry (a list of IP addresses) for the domain name.
    /// </summary>
    /// <param name="fqdn">The FQDN.</param>
    /// <param name="ct">The cancellation token.</param>
    /// <returns>An array of local ip addresses of the result produced by this task.</returns>
    public static Task<IPAddress[]> GetDnsHostEntryAsync(String fqdn,
        CancellationToken ct = default) => Task.Run(() => GetDnsHostEntry(fqdn), ct);

    /// <summary>
    /// Gets the DNS host entry (a list of IP addresses) for the domain name.
    /// </summary>
    /// <param name="fqdn">The FQDN.</param>
    /// <param name="dnsServer">The DNS server.</param>
    /// <param name="port">The port.</param>
    /// <returns>
    /// An array of local ip addresses.
    /// </returns>
    /// <exception cref="ArgumentNullException">fqdn.</exception>
    public static IPAddress[] GetDnsHostEntry(String fqdn, IPAddress dnsServer, Int32 port) {
      if(fqdn == null) {
        throw new ArgumentNullException(nameof(fqdn));
      }

      if(fqdn.IndexOf(".", StringComparison.Ordinal) == -1) {
        fqdn += "." + IPGlobalProperties.GetIPGlobalProperties().DomainName;
      }

      while(true) {
        if(fqdn.EndsWith(".") == false) {
          break;
        }

        fqdn = fqdn.Substring(0, fqdn.Length - 1);
      }

      DnsClient client = new DnsClient(dnsServer, port);
      IList<IPAddress> result = client.Lookup(fqdn);
      return result.ToArray();
    }

    /// <summary>
    /// Gets the DNS host entry (a list of IP addresses) for the domain name.
    /// </summary>
    /// <param name="fqdn">The FQDN.</param>
    /// <param name="dnsServer">The DNS server.</param>
    /// <param name="port">The port.</param>
    /// <param name="ct">The cancellation token.</param>
    /// <returns>An array of local ip addresses of the result produced by this task.</returns>
    public static Task<IPAddress[]> GetDnsHostEntryAsync(String fqdn, IPAddress dnsServer, Int32 port, CancellationToken ct = default) => Task.Run(() => GetDnsHostEntry(fqdn, dnsServer, port), ct);

    /// <summary>
    /// Gets the reverse lookup FQDN of the given IP Address.
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="dnsServer">The DNS server.</param>
    /// <param name="port">The port.</param>
    /// <returns>A <see cref="System.String" /> that represents the current object.</returns>
    public static String GetDnsPointerEntry(IPAddress query, IPAddress dnsServer, Int32 port) => new DnsClient(dnsServer, port).Reverse(query);

    /// <summary>
    /// Gets the reverse lookup FQDN of the given IP Address.
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="dnsServer">The DNS server.</param>
    /// <param name="port">The port.</param>
    /// <param name="ct">The cancellation token.</param>
    /// <returns>A <see cref="System.String" /> that represents the current object.</returns>
    public static Task<String> GetDnsPointerEntryAsync(
        IPAddress query,
        IPAddress dnsServer,
        Int32 port,
        CancellationToken ct = default) => Task.Run(() => GetDnsPointerEntry(query, dnsServer, port), ct);

    /// <summary>
    /// Gets the reverse lookup FQDN of the given IP Address.
    /// </summary>
    /// <param name="query">The query.</param>
    /// <returns>A <see cref="System.String" /> that represents the current object.</returns>
    public static String GetDnsPointerEntry(IPAddress query) => new DnsClient(GetIPv4DnsServers().FirstOrDefault()).Reverse(query);

    /// <summary>
    /// Gets the reverse lookup FQDN of the given IP Address.
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="ct">The cancellation token.</param>
    /// <returns>A <see cref="System.String" /> that represents the current object.</returns>
    public static Task<String> GetDnsPointerEntryAsync(
        IPAddress query,
        CancellationToken ct = default) => Task.Run(() => GetDnsPointerEntry(query), ct);

    /// <summary>
    /// Queries the DNS server for the specified record type.
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="recordType">Type of the record.</param>
    /// <param name="dnsServer">The DNS server.</param>
    /// <param name="port">The port.</param>
    /// <returns>
    /// Appropriate DNS server for the specified record type.
    /// </returns>
    public static DnsQueryResult QueryDns(String query, DnsRecordType recordType, IPAddress dnsServer, Int32 port) {
      if(query == null) {
        throw new ArgumentNullException(nameof(query));
      }

      DnsClient.DnsClientResponse response = new DnsClient(dnsServer, port).Resolve(query, recordType);
      return new DnsQueryResult(response);
    }

    /// <summary>
    /// Queries the DNS server for the specified record type.
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="recordType">Type of the record.</param>
    /// <param name="dnsServer">The DNS server.</param>
    /// <param name="port">The port.</param>
    /// <param name="ct">The cancellation token.</param>
    /// <returns>Queries the DNS server for the specified record type of the result produced by this Task.</returns>
    public static Task<DnsQueryResult> QueryDnsAsync(
        String query,
        DnsRecordType recordType,
        IPAddress dnsServer,
        Int32 port,
        CancellationToken ct = default) => Task.Run(() => QueryDns(query, recordType, dnsServer, port), ct);

    /// <summary>
    /// Queries the DNS server for the specified record type.
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="recordType">Type of the record.</param>
    /// <returns>Appropriate DNS server for the specified record type.</returns>
    public static DnsQueryResult QueryDns(String query, DnsRecordType recordType) => QueryDns(query, recordType, GetIPv4DnsServers().FirstOrDefault(), DnsDefaultPort);

    /// <summary>
    /// Queries the DNS server for the specified record type.
    /// </summary>
    /// <param name="query">The query.</param>
    /// <param name="recordType">Type of the record.</param>
    /// <param name="ct">The cancellation token.</param>
    /// <returns>Queries the DNS server for the specified record type of the result produced by this Task.</returns>
    public static Task<DnsQueryResult> QueryDnsAsync(
        String query,
        DnsRecordType recordType,
        CancellationToken ct = default) => Task.Run(() => QueryDns(query, recordType), ct);

    /// <summary>
    /// Gets the UTC time by querying from an NTP server.
    /// </summary>
    /// <param name="ntpServerAddress">The NTP server address.</param>
    /// <param name="port">The port.</param>
    /// <returns>
    /// A new instance of the DateTime structure to 
    /// the specified year, month, day, hour, minute and second.
    /// </returns>
    public static DateTime GetNetworkTimeUtc(IPAddress ntpServerAddress, Int32 port = NtpDefaultPort) {
      if(ntpServerAddress == null) {
        throw new ArgumentNullException(nameof(ntpServerAddress));
      }

      // NTP message size - 16 bytes of the digest (RFC 2030)
      Byte[] ntpData = new Byte[48];

      // Setting the Leap Indicator, Version Number and Mode values
      ntpData[0] = 0x1B; // LI = 0 (no warning), VN = 3 (IPv4 only), Mode = 3 (Client Mode)

      // The UDP port number assigned to NTP is 123
      IPEndPoint endPoint = new IPEndPoint(ntpServerAddress, port);
      Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

      socket.Connect(endPoint);
      socket.ReceiveTimeout = 3000; // Stops code hang if NTP is blocked
      _ = socket.Send(ntpData);
      _ = socket.Receive(ntpData);
      socket.Dispose();

      // Offset to get to the "Transmit Timestamp" field (time at which the reply 
      // departed the server for the client, in 64-bit timestamp format."
      const Byte serverReplyTime = 40;

      // Get the seconds part
      UInt64 intPart = BitConverter.ToUInt32(ntpData, serverReplyTime);

      // Get the seconds fraction
      UInt64 fractPart = BitConverter.ToUInt32(ntpData, serverReplyTime + 4);

      // Convert From big-endian to little-endian to match the platform
      if(BitConverter.IsLittleEndian) {
        intPart = intPart.SwapEndianness();
        fractPart = intPart.SwapEndianness();
      }

      UInt64 milliseconds = intPart * 1000 + fractPart * 1000 / 0x100000000L;

      // The time is given in UTC
      return new DateTime(1900, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds((Int64)milliseconds);
    }

    /// <summary>
    /// Gets the UTC time by querying from an NTP server.
    /// </summary>
    /// <param name="ntpServerName">The NTP server, by default pool.ntp.org.</param>
    /// <param name="port">The port, by default NTP 123.</param>
    /// <returns>The UTC time by querying from an NTP server.</returns>
    public static DateTime GetNetworkTimeUtc(String ntpServerName = "pool.ntp.org",
        Int32 port = NtpDefaultPort) {
      IPAddress[] addresses = GetDnsHostEntry(ntpServerName);
      return GetNetworkTimeUtc(addresses.First(), port);
    }

    /// <summary>
    /// Gets the UTC time by querying from an NTP server.
    /// </summary>
    /// <param name="ntpServerAddress">The NTP server address.</param>
    /// <param name="port">The port.</param>
    /// <param name="ct">The cancellation token.</param>
    /// <returns>The UTC time by querying from an NTP server of the result produced by this Task.</returns>
    public static Task<DateTime> GetNetworkTimeUtcAsync(
        IPAddress ntpServerAddress,
        Int32 port = NtpDefaultPort,
        CancellationToken ct = default) => Task.Run(() => GetNetworkTimeUtc(ntpServerAddress, port), ct);

    /// <summary>
    /// Gets the UTC time by querying from an NTP server.
    /// </summary>
    /// <param name="ntpServerName">Name of the NTP server.</param>
    /// <param name="port">The port.</param>
    /// <param name="ct">The cancellation token.</param>
    /// <returns>The UTC time by querying from an NTP server of the result produced by this Task.</returns>
    public static Task<DateTime> GetNetworkTimeUtcAsync(
        String ntpServerName = "pool.ntp.org",
        Int32 port = NtpDefaultPort,
        CancellationToken ct = default) => Task.Run(() => GetNetworkTimeUtc(ntpServerName, port), ct);

    #endregion
  }
}