InternetGatewayRegistrator.cs

using System;
using System.Threading;
using System.Collections.Generic;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Networking.Sniffers;
using Waher.Networking.UPnP;
using Waher.Networking.UPnP.Services;
 
namespace Waher.Networking.PeerToPeer
{
    public class InternetGatewayRegistrator : IDisposableAsync
    {
        private static readonly object upnpClientLock = new object();
        private static UPnPClient upnpClient = null;
        private static int upnpClientRefCount = 0;
 
        internal readonly InternetGatewayRegistration[] ports;
        internal IPAddress localAddress;
        internal IPAddress externalAddress;
        internal Exception exception = null;
        private readonly ISniffer[] sniffers;
        private HashSet<string> deviceUrlsProcessed = new HashSet<string>();
        private IInternetGateway internetGateway;
        private PeerToPeerNetworkState state = PeerToPeerNetworkState.Created;
        private ManualResetEvent ready = new ManualResetEvent(false);
        private ManualResetEvent error = new ManualResetEvent(false);
        private Timer searchTimer = null;
        private bool upnpHandlerRegistered = false;
        internal bool disposed = false;
 
        public InternetGatewayRegistrator(InternetGatewayRegistration[] Ports, params ISniffer[] Sniffers)
        {
            this.ports = Ports;
            this.sniffers = Sniffers;
 
            NetworkChange.NetworkAddressChanged += this.NetworkChange_NetworkAddressChanged;
        }
 
        private async void NetworkChange_NetworkAddressChanged(object Sender, EventArgs e)
        {
            try
            {
                if (!this.disposed && this.State != PeerToPeerNetworkState.SearchingForGateway)    // Multiple events might get fired one after the other. Just start one search.
                {
                    await this.SetState(PeerToPeerNetworkState.Reinitializing);
 
                    this.ready?.Reset();
                    this.error?.Reset();
 
                    await this.Start();
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public virtual async Task Start()
        {
            if (this.OnPublicNetwork())
                this.localAddress = this.externalAddress;
            else
                await this.SearchGateways();
        }
 
        public bool OnPublicNetwork()
        {
            foreach (NetworkInterface Interface in NetworkInterface.GetAllNetworkInterfaces())
            {
                if (Interface.OperationalStatus != OperationalStatus.Up)
                    continue;
 
                IPInterfaceProperties Properties = Interface.GetIPProperties();
 
                foreach (UnicastIPAddressInformation UnicastAddress in Properties.UnicastAddresses)
                {
                    if (!IsPublicAddress(UnicastAddress.Address))
                        continue;
 
                    this.externalAddress = UnicastAddress.Address;
                    return true;
                }
            }
 
            return false;
        }
 
        public static bool IsPublicAddress(IPAddress Address)
        {
            if (Address.AddressFamily == AddressFamily.InterNetwork && Socket.OSSupportsIPv4)
            {
                byte[] Addr = Address.GetAddressBytes();
 
                // https://www.iana.org/assignments/ipv4-address-space/ipv4-address-space.xhtml
 
                switch (Addr[0])
                {
                    case 0:
                        return false;   // 000.X.X.X/8: Reserved for self-identification [RFC1122]
 
                    case 10:
                        return false;   // 010.X.X.X/8: Reserved for Private-Use Networks [RFC1918]
 
                    case 100:           // 100.64.X.X/10 reserved for Shared Address Space [RFC6598].
                        return (Addr[1] & 0xc0) != 64;
 
                    case 127:           // 127.X.X.X/8 reserved for Loopback [RFC1122]
                        return false;
 
                    case 169:           // 169.254.X.X/16 reserved for Link Local
                        return Addr[1] != 254;
 
                    case 172:           // 172.16.0.0/12 reserved for Private-Use Networks
                        return (Addr[1] & 0xf0) != 16;
 
                    case 192:
                        switch (Addr[1])
                        {
                            case 0:
                                switch (Addr[2])
                                {
                                    case 0:             // 192.0.0.0/24 reserved for IANA IPv4 Special Purpose Address Registry
                                        return false;
 
                                    case 2:             // 192.0.2.X/24  reserved for TEST-NET-1
                                        return false;
 
                                    default:
                                        return true;
                                }
 
                            case 88:
                                return Addr[2] != 99;   // 192.88.99.X/24 reserved for 6to4 Relay Anycast
 
                            case 168:
                                return false;           // 192.168.0.0/16 reserved for Private-Use Networks
                        }
                        break;
                }
 
                return true;
            }
            else
                return false;
        }
 
        public async Task SearchGateways()
        {
            if (this.disposed || this.deviceUrlsProcessed is null)
                return;
 
            try
            {
                this.searchTimer?.Dispose();
                this.searchTimer = null;
 
                if (!this.upnpHandlerRegistered)
                {
                    lock (upnpClientLock)
                    {
                        upnpClientRefCount++;
                        upnpClient ??= new UPnPClient(this.sniffers);
 
                        upnpClient.OnDeviceFound += this.UpnpClient_OnDeviceFound;
                        this.upnpHandlerRegistered = true;
                    }
                }
 
                lock (this.deviceUrlsProcessed)
                {
                    this.deviceUrlsProcessed.Clear();
                }
 
                await this.SetState(PeerToPeerNetworkState.SearchingForGateway);
 
                await upnpClient.StartSearch("urn:schemas-upnp-org:service:WANIPConnection:1", 1);
                await upnpClient.StartSearch("urn:schemas-upnp-org:service:WANIPConnection:2", 1);
                await upnpClient.StartSearch("urn:schemas-upnp-org:service:WANPPPConnection:1", 1);
 
                this.searchTimer = new Timer(this.SearchTimeout, null, 10000, Timeout.Infinite);
            }
            catch (Exception ex)
            {
                this.exception = ex;
                await this.SetState(PeerToPeerNetworkState.Error);
            }
        }
 
        private async void SearchTimeout(object State)
        {
            try
            {
                this.searchTimer?.Dispose();
                this.searchTimer = null;
 
                await this.UnregisterUPnPClient();
                await this.SetState(PeerToPeerNetworkState.Error);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private async Task UnregisterUPnPClient()
        {
            UPnPClient ToDispose = null;
 
            lock (upnpClientLock)
            {
                if (this.upnpHandlerRegistered)
                {
                    upnpClient.OnDeviceFound -= this.UpnpClient_OnDeviceFound;
                    this.upnpHandlerRegistered = false;
 
                    if (--upnpClientRefCount == 0)
                    {
                        ToDispose = upnpClient;
                        upnpClient = null;
                    }
                }
            }
 
            if (!(ToDispose is null))
                await ToDispose.DisposeAsync();
        }
 
        private void Reinitialize(object State)
        {
            this.searchTimer?.Dispose();
            this.searchTimer = null;
 
            this.NetworkChange_NetworkAddressChanged(this, EventArgs.Empty);
        }
 
        private async Task UpnpClient_OnDeviceFound(object Sender, DeviceLocationEventArgs e)
        {
            try
            {
                lock (this.deviceUrlsProcessed)
                {
                    if (this.deviceUrlsProcessed.Contains(e.Location.Location))
                        return;
 
                    this.deviceUrlsProcessed.Add(e.Location.Location);
                }
 
                DeviceDescriptionDocument Doc = await e.Location.GetDeviceAsync();
                if (!(Doc is null))
                {
                    UPnPService Service = Doc.GetService("urn:schemas-upnp-org:service:WANIPConnection:1");
                    if (!(Service is null))
                    {
                        ServiceDescriptionDocument Scpd = await Service.GetServiceAsync();
                        await this.ServiceRetrieved(new WANIPConnectionV1(Scpd), e.LocalEndPoint);
                        return;
 
                    }
 
                    Service = Doc.GetService("urn:schemas-upnp-org:service:WANIPConnection:2");
                    if (!(Service is null))
                    {
                        ServiceDescriptionDocument Scpd = await Service.GetServiceAsync();
                        await this.ServiceRetrieved(new WANIPConnectionV2(Scpd), e.LocalEndPoint);
                        return;
                    }
 
                    Service = Doc.GetService("urn:schemas-upnp-org:service:WANPPPConnection:1");
                    if (!(Service is null))
                    {
                        ServiceDescriptionDocument Scpd = await Service.GetServiceAsync();
                        await this.ServiceRetrieved(new WANPPPConnectionV1(Scpd), e.LocalEndPoint);
                        return;
                    }
                }
            }
            catch (Exception ex)
            {
                this.exception = ex;
                await this.SetState(PeerToPeerNetworkState.Error);
            }
        }
 
        private async Task ServiceRetrieved(IInternetGateway Gateway, IPEndPoint LocalEndPoint)
        {
            try
            {
                Dictionary<ushort, bool> TcpPortMapped = new Dictionary<ushort, bool>();
                Dictionary<ushort, bool> UdpPortMapped = new Dictionary<ushort, bool>();
                ushort PortMappingIndex;
 
                this.internetGateway = Gateway;
                await this.SetState(PeerToPeerNetworkState.RegisteringApplicationInGateway);
 
                this.internetGateway.GetExternalIPAddress(out string NewExternalIPAddress);
                this.externalAddress = IPAddress.Parse(NewExternalIPAddress);
 
                Log.Informational("External IP Address: " + NewExternalIPAddress);
 
                if (!IsPublicAddress(this.externalAddress))
                {
                    Log.Warning("External IP Address not a public IP address.");
                    return;     // TODO: Handle multiple layers of gateways.
                }
 
                PortMappingIndex = 0;
 
                try
                {
                    string LocalAddress = LocalEndPoint.Address.ToString();
 
                    while (true)
                    {
                        this.internetGateway.GetGenericPortMappingEntry(PortMappingIndex, out string NewRemoteHost,
                            out ushort NewExternalPort, out string NewProtocol, out ushort NewInternalPort, out string NewInternalClient,
                            out bool NewEnabled, out string NewPortMappingDescription, out uint NewLeaseDuration);
 
                        if (NewInternalClient != LocalAddress)
                        {
                            PortMappingIndex++;
                            continue;
                        }
 
                        bool Found = false;
 
                        foreach (InternetGatewayRegistration Registration in this.ports)
                        {
                            if ((Registration.ExternalPort != 0 && NewExternalPort == Registration.ExternalPort) ||
                                (Registration.ExternalPort == 0 && NewPortMappingDescription == Registration.ApplicationName))
                            {
                                if (NewProtocol == "TCP")
                                {
                                    Found = true;
                                    Registration.TcpRegistered = true;
                                    break;
                                }
                                else if (NewProtocol == "UDP")
                                {
                                    Found = true;
                                    Registration.UdpRegistered = true;
                                    break;
                                }
 
                                Log.Notice("Deleting Internet Gateway port mapping.",
                                    new KeyValuePair<string, object>("Host", NewRemoteHost),
                                    new KeyValuePair<string, object>("External Port", NewExternalPort),
                                    new KeyValuePair<string, object>("Protocol", NewProtocol),
                                    new KeyValuePair<string, object>("Local Port", NewInternalPort),
                                    new KeyValuePair<string, object>("Local Address", NewInternalClient),
                                    new KeyValuePair<string, object>("Application", NewPortMappingDescription));
 
                                this.internetGateway.DeletePortMapping(NewRemoteHost, NewExternalPort, NewProtocol);
                            }
                        }
 
                        if (Found)
                        {
                            PortMappingIndex++;
                            continue;
                        }
                        else
                        {
                            switch (NewProtocol)
                            {
                                case "TCP":
                                    TcpPortMapped[NewExternalPort] = true;
                                    break;
 
                                case "UDP":
                                    UdpPortMapped[NewExternalPort] = true;
                                    break;
                            }
 
                            PortMappingIndex++;
                        }
                    }
                }
                catch (AggregateException ex)
                {
                    if (!(ex.InnerException is UPnPException))
                        System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(ex).Throw();
                }
                catch (UPnPException)
                {
                    // No more entries.
                }
 
                this.localAddress = LocalEndPoint.Address;
 
                foreach (InternetGatewayRegistration Registration in this.ports)
                {
                    await this.BeforeRegistration(Registration, TcpPortMapped, UdpPortMapped);
 
                    if ((Registration.TcpRegistered || !Registration.Tcp) &&
                        (Registration.UdpRegistered || !Registration.Udp))
                    {
                        continue;
                    }
 
                    if (Registration.Tcp && !Registration.TcpRegistered)
                    {
                        Log.Notice("Adding Internet Gateway port mapping.",
                            new KeyValuePair<string, object>("Host", string.Empty),
                            new KeyValuePair<string, object>("External Port", Registration.ExternalPort),
                            new KeyValuePair<string, object>("Protocol", "TCP"),
                            new KeyValuePair<string, object>("Local Port", Registration.LocalPort),
                            new KeyValuePair<string, object>("Local Address", this.LocalAddress.ToString()),
                            new KeyValuePair<string, object>("Application", Registration.ApplicationName));
 
                        try
                        {
                            this.internetGateway.AddPortMapping(string.Empty, Registration.ExternalPort,
                                "TCP", Registration.LocalPort, this.LocalAddress.ToString(), true, Registration.ApplicationName, 0);
 
                            Registration.TcpRegistered = true;
                        }
                        catch (Exception ex)
                        {
                            Log.Error("Unable to register port in Internet Gateway: " + ex.Message,
                                new KeyValuePair<string, object>("External Port", Registration.ExternalPort),
                                new KeyValuePair<string, object>("Protocol", "TCP"),
                                new KeyValuePair<string, object>("Local Port", Registration.LocalPort),
                                new KeyValuePair<string, object>("Local Address", this.LocalAddress.ToString()),
                                new KeyValuePair<string, object>("Application", Registration.ApplicationName));
                        }
                    }
 
                    if (Registration.Udp && !Registration.UdpRegistered)
                    {
                        Log.Notice("Adding Internet Gateway port mapping.",
                            new KeyValuePair<string, object>("Host", string.Empty),
                            new KeyValuePair<string, object>("External Port", Registration.ExternalPort),
                            new KeyValuePair<string, object>("Protocol", "UDP"),
                            new KeyValuePair<string, object>("Local Port", Registration.LocalPort),
                            new KeyValuePair<string, object>("Local Address", this.LocalAddress.ToString()),
                            new KeyValuePair<string, object>("Application", Registration.ApplicationName));
 
                        try
                        {
                            this.internetGateway.AddPortMapping(string.Empty, Registration.ExternalPort,
                                "UDP", Registration.LocalPort, this.LocalAddress.ToString(), true, Registration.ApplicationName, 0);
 
                            Registration.UdpRegistered = true;
                        }
                        catch (Exception ex)
                        {
                            Log.Error("Unable to register port in Internet Gateway: " + ex.Message,
                                new KeyValuePair<string, object>("External Port", Registration.ExternalPort),
                                new KeyValuePair<string, object>("Protocol", "UDP"),
                                new KeyValuePair<string, object>("Local Port", Registration.LocalPort),
                                new KeyValuePair<string, object>("Local Address", this.LocalAddress.ToString()),
                                new KeyValuePair<string, object>("Application", Registration.ApplicationName));
                        }
                    }
                }
 
                await this.SetState(PeerToPeerNetworkState.Ready);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
 
                this.exception = ex;
                await this.SetState(PeerToPeerNetworkState.Error);
            }
        }
 
        protected virtual Task BeforeRegistration(InternetGatewayRegistration Registration,
            Dictionary<ushort, bool> TcpPortMapped, Dictionary<ushort, bool> UdpPortMapped)
        {
            return Task.CompletedTask;  // Do nothing by default.
        }
 
        public PeerToPeerNetworkState State => this.state;
 
        internal async Task SetState(PeerToPeerNetworkState NewState)
        {
            if (this.state != NewState)
            {
                this.state = NewState;
 
                switch (NewState)
                {
                    case PeerToPeerNetworkState.Ready:
                        this.searchTimer?.Dispose();
                        this.searchTimer = null;
                        this.ready?.Set();
                        break;
 
                    case PeerToPeerNetworkState.Error:
                        this.searchTimer?.Dispose();
                        this.searchTimer = null;
                        this.error?.Set();
 
                        this.searchTimer = new Timer(this.Reinitialize, null, 60000, Timeout.Infinite);
                        break;
                }
 
                await this.OnStateChange.Raise(this, NewState);
            }
        }
 
        public event EventHandlerAsync<PeerToPeerNetworkState> OnStateChange = null;
 
        public IPAddress ExternalAddress => this.externalAddress;
 
        public IPAddress LocalAddress => this.localAddress;
 
        public Exception Exception => this.exception;
 
        public bool Wait()
        {
            return this.Wait(10000);
        }
 
        public bool Wait(int TimeoutMilliseconds)
        {
            switch (WaitHandle.WaitAny(new WaitHandle[] { this.ready, this.error }, TimeoutMilliseconds))
            {
                case 0:
                    return true;
 
                case 1:
                default:
                    return false;
            }
        }
 
        [Obsolete("Use DisposeAsync() instead.")]
        public void Dispose()
        {
            try
            {
                this.DisposeAsync().Wait();
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public virtual async Task DisposeAsync()
        {
            this.disposed = true;
            await this.SetState(PeerToPeerNetworkState.Closed);
 
            NetworkChange.NetworkAddressChanged -= this.NetworkChange_NetworkAddressChanged;
 
            this.searchTimer?.Dispose();
            this.searchTimer = null;
 
            await this.UnregisterUPnPClient();
 
            foreach (InternetGatewayRegistration Registration in this.ports)
            {
                if (Registration.TcpRegistered)
                {
                    Registration.TcpRegistered = false;
                    try
                    {
                        Log.Notice("Deleting Internet Gateway port mapping.",
                            new KeyValuePair<string, object>("Host", string.Empty),
                            new KeyValuePair<string, object>("External Port", Registration.ExternalPort),
                            new KeyValuePair<string, object>("Protocol", "TCP"),
                            new KeyValuePair<string, object>("Local Port", Registration.LocalPort),
                            new KeyValuePair<string, object>("Application", Registration.ApplicationName));
 
                        this.internetGateway.DeletePortMapping(string.Empty, Registration.LocalPort, "TCP");
                    }
                    catch (Exception)
                    {
                        // Ignore
                    }
                }
 
                if (Registration.UdpRegistered)
                {
                    Registration.UdpRegistered = false;
                    try
                    {
                        Log.Notice("Deleting Internet Gateway port mapping.",
                            new KeyValuePair<string, object>("Host", string.Empty),
                            new KeyValuePair<string, object>("External Port", Registration.ExternalPort),
                            new KeyValuePair<string, object>("Protocol", "UDP"),
                            new KeyValuePair<string, object>("Local Port", Registration.LocalPort),
                            new KeyValuePair<string, object>("Application", Registration.ApplicationName));
 
                        this.internetGateway.DeletePortMapping(string.Empty, Registration.LocalPort, "UDP");
                    }
                    catch (Exception)
                    {
                        // Ignore
                    }
                }
            }
 
            this.internetGateway = null;
 
            this.deviceUrlsProcessed?.Clear();
            this.deviceUrlsProcessed = null;
 
            this.ready?.Dispose();
            this.ready = null;
 
            this.error?.Dispose();
            this.error = null;
        }
 
        public IPEndPoint CheckLocalRemoteEndpoint(IPEndPoint RemoteEndPoint)
        {
            if (IPAddress.Equals(RemoteEndPoint.Address, this.externalAddress))
            {
                this.internetGateway.GetSpecificPortMappingEntry(string.Empty, (ushort)RemoteEndPoint.Port, "TCP",
                    out ushort InternalPort, out string InternalClient, out bool _, out string _, out uint _);
 
                return new IPEndPoint(IPAddress.Parse(InternalClient), InternalPort);
            }
            else
                return RemoteEndPoint;
        }
 
    }
}