XmppServerlessMessaging.cs

using System;
using System.Collections.Generic;
using System.Net;
using System.Threading.Tasks;
using System.Text;
using System.Xml;
using Waher.Events;
using Waher.Networking.Sniffers;
using Waher.Networking.PeerToPeer;
 
namespace Waher.Networking.XMPP.P2P
{
    public class XmppServerlessMessaging : CommunicationLayer, IDisposableAsync
    {
        private Dictionary<string, PeerState> peersByFullJid = new Dictionary<string, PeerState>(StringComparer.CurrentCultureIgnoreCase);
        private readonly Dictionary<string, AddressInfo> addressesByFullJid = new Dictionary<string, AddressInfo>(StringComparer.CurrentCultureIgnoreCase);
        private readonly Dictionary<string, Dictionary<int, AddressInfo>> addressesByExternalIPPort = new Dictionary<string, Dictionary<int, AddressInfo>>();
        private readonly Dictionary<string, Dictionary<int, AddressInfo>> addressesByLocalIPPort = new Dictionary<string, Dictionary<int, AddressInfo>>();
        private PeerToPeerNetwork p2pNetwork = null;
        private string fullJid;
        private bool disposed = false;
 
        public XmppServerlessMessaging(string ApplicationName, string FullJid, params ISniffer[] Sniffers)
            : this(ApplicationName, FullJid, PeerToPeerNetwork.DefaultPort, PeerToPeerNetwork.DefaultPort,
                  PeerToPeerNetwork.DefaultBacklog, Sniffers)
        {
        }
 
        public XmppServerlessMessaging(string ApplicationName, string FullJid, ushort LocalPort, ushort ExternalPort, params ISniffer[] Sniffers)
            : this(ApplicationName, FullJid, LocalPort, ExternalPort, PeerToPeerNetwork.DefaultBacklog, Sniffers)
        {
        }
 
        public XmppServerlessMessaging(string ApplicationName, string FullJid, ushort LocalPort, ushort ExternalPort, int Backlog,
            params ISniffer[] Sniffers)
            : base(false, Sniffers)
        {
            this.fullJid = FullJid;
            this.p2pNetwork = new PeerToPeerNetwork(ApplicationName, LocalPort, ExternalPort, Backlog, Sniffers)
            {
                EncapsulatePackets = false
            };
 
            // TODO: Implement support for NAT-PMP
 
            this.p2pNetwork.OnPeerConnected += this.P2PNetwork_OnPeerConnected;
        }
 
        public PeerToPeerNetwork Network => this.p2pNetwork;
 
        public string FullJid
        {
            get => this.fullJid;
            set => this.fullJid = value;
        }
 
        public bool Disposed => this.disposed;
 
        private Task P2PNetwork_OnPeerConnected(object Listener, PeerConnection Peer)
        {
            PeerState _ = new PeerState(Peer, this);
            this.Information("Peer connected from " + Peer.RemoteEndpoint.ToString());
            return Task.CompletedTask;
        }
 
        public async Task RemovePeerAddresses(string FullJID)
        {
            string ThisExternalIp = this.p2pNetwork.ExternalAddress is null ? string.Empty : this.p2pNetwork.ExternalAddress.ToString();
 
            lock (this.addressesByFullJid)
            {
                if (this.addressesByFullJid.TryGetValue(FullJID, out AddressInfo Info))
                {
                    this.addressesByFullJid.Remove(FullJID);
 
                    if (this.addressesByExternalIPPort.TryGetValue(Info.ExternalIp, out Dictionary<int, AddressInfo> Infos))
                    {
                        if (Infos.Remove(Info.ExternalPort) && Infos.Count == 0)
                            this.addressesByExternalIPPort.Remove(Info.ExternalIp);
                    }
 
                    if (Info.ExternalIp == ThisExternalIp)
                    {
                        if (this.addressesByLocalIPPort.TryGetValue(Info.LocalIp, out Infos))
                        {
                            if (Infos.Remove(Info.LocalPort) && Infos.Count == 0)
                                this.addressesByLocalIPPort.Remove(Info.LocalIp);
                        }
                    }
                }
                else
                    return;
            }
 
            this.Information("Removing JID from set of recognized JIDs: " + FullJID);
 
            await this.PeerAddressRemoved.Raise(this, new PeerAddressEventArgs(FullJID, string.Empty, 0, string.Empty, 0));
        }
 
        public event EventHandlerAsync<PeerAddressEventArgs> PeerAddressRemoved = null;
 
        public async Task ReportPeerAddresses(string FullJID, string ExternalIp, int ExternalPort, string LocalIp, int LocalPort)
        {
            Dictionary<int, AddressInfo> Infos;
            string ThisExternalIp;
 
            if (this.p2pNetwork.ExternalAddress is null)
                ThisExternalIp = string.Empty;
            else
                ThisExternalIp = this.p2pNetwork.ExternalAddress.ToString();
 
            lock (this.addressesByFullJid)
            {
                if (this.addressesByFullJid.TryGetValue(FullJID, out AddressInfo Info))
                {
                    if (Info.ExternalIp == ExternalIp && Info.ExternalPort == ExternalPort &&
                        Info.LocalIp == LocalIp && Info.LocalPort == LocalPort)
                    {
                        return;
                    }
 
                    if (Info.ExternalIp != ExternalIp)
                    {
                        if (this.addressesByExternalIPPort.TryGetValue(Info.ExternalIp, out Infos))
                        {
                            if (Infos.Remove(Info.ExternalPort) && Infos.Count == 0)
                                this.addressesByExternalIPPort.Remove(Info.ExternalIp);
                        }
                    }
 
                    if (ExternalIp == ThisExternalIp && Info.LocalIp != LocalIp)
                    {
                        if (this.addressesByLocalIPPort.TryGetValue(Info.LocalIp, out Infos))
                        {
                            if (Infos.Remove(Info.LocalPort) && Infos.Count == 0)
                                this.addressesByLocalIPPort.Remove(Info.LocalIp);
                        }
                    }
                }
 
                Info = new AddressInfo(FullJID, ExternalIp, ExternalPort, LocalIp, LocalPort);
                this.addressesByFullJid[FullJID] = Info;
 
                if (!this.addressesByExternalIPPort.TryGetValue(ExternalIp, out Infos))
                {
                    Infos = new Dictionary<int, AddressInfo>();
                    this.addressesByExternalIPPort[ExternalIp] = Infos;
                }
 
                Infos[ExternalPort] = Info;
 
                if (ExternalIp == ThisExternalIp)
                {
                    if (!this.addressesByLocalIPPort.TryGetValue(LocalIp, out Infos))
                    {
                        Infos = new Dictionary<int, AddressInfo>();
                        this.addressesByLocalIPPort[LocalIp] = Infos;
                    }
 
                    Infos[LocalPort] = Info;
                }
            }
 
            this.Information("P2P information available for " + FullJID + ". External: " + ExternalIp + ":" + ExternalPort.ToString() +
                ", Local: " + LocalIp + ":" + LocalPort.ToString());
 
            await this.PeerAddressReceived.Raise(this, new PeerAddressEventArgs(FullJID, ExternalIp, ExternalPort, LocalIp, LocalPort));
        }
 
        public event EventHandlerAsync<PeerAddressEventArgs> PeerAddressReceived = null;
 
        internal string AuthenticatePeer(PeerConnection Peer, string FullJID)
        {
            AddressInfo Info;
 
            lock (this.addressesByFullJid)
            {
                if (!this.addressesByFullJid.TryGetValue(FullJID, out Info))
                    return "Peer JID " + FullJID + " not recognized.";
            }
 
            if (Info.ExternalIp == this.p2pNetwork.ExternalAddress.ToString())
            {
                if (Peer.RemoteEndpoint.Address.ToString() != Info.LocalIp)
                {
                    return "Expected connection from " + Info.LocalIp + ", but was from " +
                        Peer.RemoteEndpoint.Address.ToString();
                }
            }
            else
            {
                if (Peer.RemoteEndpoint.Address.ToString() != Info.ExternalIp)
                {
                    return "Expected connection from " + Info.ExternalIp + ", but was from " +
                        Peer.RemoteEndpoint.ToString();
                }
            }
 
            // End-to-end encryption will ensure communication is only read by the indended receiver.
 
            return null;
        }
 
        internal void PeerAuthenticated(PeerState State)
        {
            lock (this.peersByFullJid)
            {
                this.peersByFullJid[State.RemoteFullJid] = State;
            }
 
            this.Information("Peer authenticated: " + State.RemoteFullJid);
        }
 
        internal async Task NewXmppClient(XmppClient Client, string LocalJid, string RemoteJid)
        {
            this.Information("Serverless XMPP connection established with " + RemoteJid);
 
            /*foreach (ISniffer Sniffer in this.Sniffers)
                Client.Add(Sniffer);*/
 
            await this.OnNewXmppClient.Raise(this, new PeerConnectionEventArgs(Client, null, LocalJid, RemoteJid));
        }
 
        public event EventHandlerAsync<PeerConnectionEventArgs> OnNewXmppClient = null;
 
        internal void PeerClosed(PeerState State)
        {
            this.Information("Serverless XMPP connection with " + State.RemoteFullJid + " closed.");
 
            if (!(this.peersByFullJid is null))
            {
                lock (this.peersByFullJid)
                {
                    if (this.peersByFullJid.TryGetValue(State.RemoteFullJid, out PeerState State2) && State2 == State)
                        this.peersByFullJid.Remove(State.RemoteFullJid);
                }
            }
        }
 
        public Task GetPeerConnection(string FullJID, EventHandlerAsync<PeerConnectionEventArgs> Callback, object State)
        {
            return this.GetPeerConnection(FullJID, Callback, State, this.OnResynch);
        }
 
        public async Task<PeerConnectionEventArgs> GetPeerConnectionAsync(string FullJID)
        {
            TaskCompletionSource<PeerConnectionEventArgs> Result = new TaskCompletionSource<PeerConnectionEventArgs>();
 
            await this.GetPeerConnection(FullJID, (Sender, e) =>
            {
                Result.TrySetResult(e);
                return Task.CompletedTask;
            }, null);
 
            return await Result.Task;
        }
 
        public event EventHandlerAsync<ResynchEventArgs> OnResynch = null;
 
        public bool CanConnectToPeer(string FullJID)
        {
            AddressInfo Info;
 
            lock (this.addressesByFullJid)
            {
                if (!this.addressesByFullJid.TryGetValue(FullJID, out Info))
                    return false;
            }
 
            return !string.IsNullOrEmpty(Info.ExternalIp);
        }
 
        public bool TryGetAddressInfo(string FullJID, out AddressInfo Address)
        {
            lock (this.addressesByFullJid)
            {
                return this.addressesByFullJid.TryGetValue(FullJID, out Address);
            }
        }
 
        private async Task GetPeerConnection(string FullJID, EventHandlerAsync<PeerConnectionEventArgs> Callback, object State, EventHandlerAsync<ResynchEventArgs> ResynchMethod)
        {
            PeerState Result;
            PeerState Old = null;
            AddressInfo Info;
            string Header = null;
            bool b;
 
            if (this.p2pNetwork is null || this.p2pNetwork.State != PeerToPeerNetworkState.Ready)
            {
                await Callback.Raise(this, new PeerConnectionEventArgs(null, State, this.fullJid, FullJID));
                return;
            }
 
            lock (this.addressesByFullJid)
            {
                b = this.addressesByFullJid.TryGetValue(FullJID, out Info);
            }
 
            if (!b)
            {
                await Callback.Raise(this, new PeerConnectionEventArgs(null, State, this.fullJid, FullJID));
                return;
            }
 
            lock (this.peersByFullJid)
            {
                b = this.peersByFullJid.TryGetValue(FullJID, out Result);
 
                if (b)
                {
                    if (Result.AgeSeconds >= 30 && (Result.HasCallbacks || Result.XmppClient is null || !Result.Peer.Tcp.Connected))
                    {
                        this.peersByFullJid.Remove(FullJID);
                        Old = Result;
                        Result = null;
                        b = false;
                    }
                    else if (Result.State != XmppState.Connected)
                    {
                        Result.AddCallback(Callback, State);
                        return;
                    }
                }
 
                if (!b)
                {
                    Header = "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' from='" +
                        this.fullJid + "' to='" + FullJID + "' version='1.0'>";
 
                    Result = new PeerState(null, this, FullJID, Header, "</stream:stream>", string.Empty, 1.0, Callback, State);
                    this.peersByFullJid[FullJID] = Result;
                }
            }
 
            if (b)
            {
                await Callback.Raise(this, new PeerConnectionEventArgs(Result.XmppClient, State, this.fullJid, FullJID));
                return;
            }
            else if (!(Old is null))
            {
                await Old.CallCallbacks();
                await Old.DisposeAsync();
            }
 
            _ = Task.Run(async () =>
            {
                PeerConnection Connection;
 
                try
                {
                    Connection = await this.ConnectToAsync(FullJID, Info);
                }
                catch (Exception ex)
                {
                    this.Exception(ex);
                    Connection = null;
 
                    if (!(ResynchMethod is null))
                    {
                        try
                        {
                            ResynchEventArgs e = new ResynchEventArgs(FullJID, async (sender, e2) =>
                            {
                                try
                                {
                                    if (e2.Ok)
                                        await this.GetPeerConnection(FullJID, Callback, State, null);
                                    else
                                    {
                                        lock (this.peersByFullJid)
                                        {
                                            this.peersByFullJid.Remove(FullJID);
                                        }
 
                                        await Result.CallCallbacks();
                                    }
                                }
                                catch (Exception ex2)
                                {
                                    Log.Exception(ex2);
                                }
                            });
 
                            await ResynchMethod(this, e);
                        }
                        catch (Exception ex2)
                        {
                            Log.Exception(ex2);
                        }
 
                        return;
                    }
                }
 
                if (Connection is null)
                {
                    lock (this.peersByFullJid)
                    {
                        this.peersByFullJid.Remove(FullJID);
                    }
 
                    await Result.CallCallbacks();
                }
                else
                {
                    Result.Peer = Connection;
                    Connection.Start(async (Sender, e) =>
                    {
                        if (!(ResynchMethod is null))
                        {
                            if (!await ResynchMethod.Raise(this, new ResynchEventArgs(FullJID, async (sender2, e2) =>
                            {
                                try
                                {
                                    if (e2.Ok)
                                    {
                                        Result.Peer = null;
                                        Connection = await this.ConnectToAsync(FullJID, Info);
                                        Result.Peer = Connection;
                                        Connection.Start();
                                        Result.HeaderSent = true;
                                        await Result.SendAsync(Header);
                                        this.TransmitText(Header);
                                    }
                                    else
                                        await Result.CallCallbacks();
                                }
                                catch (Exception ex)
                                {
                                    this.Exception(ex);
                                }
                            }), false))
                            {
                                await Result.CallCallbacks();
                            }
                        }
                        else
                            await Result.CallCallbacks();
                    });
 
                    Result.HeaderSent = true;
                    await Result.SendAsync(Header);
                    this.TransmitText(Header);
                }
            });
        }
 
        private async Task<PeerConnection> ConnectToAsync(string FullJID, AddressInfo Info)
        {
            PeerConnection Connection;
            string Ip;
            int Port;
 
            if (Info.ExternalIp == this.p2pNetwork.ExternalAddress.ToString())
            {
                Ip = Info.LocalIp;
                Port = Info.LocalPort;
            }
            else
            {
                Ip = Info.ExternalIp;
                Port = Info.ExternalPort;
            }
 
            if (IPAddress.TryParse(Ip, out IPAddress Addr))
            {
                this.Information("Connecting to " + Ip + ":" + Port.ToString() + " (" + FullJID + ")");
                Connection = await this.p2pNetwork.ConnectToPeer(new IPEndPoint(Addr, Port));
                this.Information("Connected to to " + Ip + ":" + Port.ToString() + " (" + FullJID + ")");
            }
            else
                Connection = null;
 
            return Connection;
        }
 
        [Obsolete("Use the DisposeAsync() method.")]
        public void Dispose()
        {
            this.DisposeAsync().Wait();
        }
 
        public async Task DisposeAsync()
        {
            if (!this.disposed)
            {
                if (!(this.p2pNetwork is null))
                {
                    await this.p2pNetwork.DisposeAsync();
                    this.p2pNetwork = null;
                }
 
                if (!(this.peersByFullJid is null))
                {
                    PeerState[] States;
 
                    lock (this.peersByFullJid)
                    {
                        States = new PeerState[this.peersByFullJid.Count];
                        this.peersByFullJid.Values.CopyTo(States, 0);
 
                        this.peersByFullJid.Clear();
                    }
 
                    this.peersByFullJid = null;
 
                    foreach (PeerState State in States)
                    {
                        State.ClearCallbacks();
                        await State.Close();
                    }
                }
 
                this.disposed = true;
            }
        }
 
        public void AppendP2pInfo(StringBuilder Xml)
        {
            if (!(this.p2pNetwork is null) &&
                this.p2pNetwork.State == PeerToPeerNetworkState.Ready &&
                !(this.p2pNetwork.ExternalEndpoint is null) &&
                !this.p2pNetwork.OnPublicNetwork())
            {
                Xml.Append("<p2p xmlns='");
                Xml.Append(EndpointSecurity.IoTHarmonizationP2PCurrent);
                Xml.Append("' extIp='");
                Xml.Append(this.p2pNetwork.ExternalAddress.ToString());
                Xml.Append("' extPort='");
                Xml.Append(this.p2pNetwork.ExternalEndpoint.Port.ToString());
                Xml.Append("' locIp='");
                Xml.Append(this.p2pNetwork.LocalAddress.ToString());
                Xml.Append("' locPort='");
                Xml.Append(this.p2pNetwork.LocalEndpoint.Port.ToString());
                Xml.Append("'/>");
            }
        }
 
        public async Task<bool> AddPeerAddressInfo(string FullJID, XmlElement P2P)
        {
            string ExtIp = null;
            int? ExtPort = null;
            string LocIp = null;
            int? LocPort = null;
 
            if (!(P2P is null))
            {
                foreach (XmlAttribute Attr in P2P.Attributes)
                {
                    switch (Attr.Name)
                    {
                        case "extIp":
                            if (IPAddress.TryParse(Attr.Value, out IPAddress Addr) &&
                                InternetGatewayRegistrator.IsPublicAddress(Addr))
                            {
                                ExtIp = Attr.Value;
                            }
                            break;
 
                        case "extPort":
                            if (int.TryParse(Attr.Value, out int i) && i >= 0 && i < 65536)
                                ExtPort = i;
                            else
                                return false;
                            break;
 
                        case "locIp":
                            LocIp = Attr.Value;
                            break;
 
                        case "locPort":
                            if (int.TryParse(Attr.Value, out i) && i >= 0 && i < 65536)
                                LocPort = i;
                            else
                                return false;
                            break;
                    }
                }
            }
 
            if (!(ExtIp is null) && ExtPort.HasValue && !(LocIp is null) && LocPort.HasValue)
            {
                await this.ReportPeerAddresses(FullJID, ExtIp, ExtPort.Value, LocIp, LocPort.Value);
                return true;
            }
            else
            {
                await this.RemovePeerAddresses(FullJID);
                return false;
            }
        }
 
    }
}