natendpointsmanager.cs

破解的飞信源代码

namespace NCindy.Protocol.RUDP.NATTraversal
{
    using System;
    using System.Collections.Generic;
    using System.Net;
    using System.Runtime.CompilerServices;

    public sealed class NATEndPointsManager
    {
        private volatile List<IPEndPoint> _generatedEndPoints;
        private readonly List<NATHistoryPoint> _history;
        private readonly List<IPEndPoint> _localEndPoints;
        private volatile List<IPAddressRecord> _remoteIPAddresses;

        public NATEndPointsManager(List<IPEndPoint> localEndPoints, List<NATHistoryPoint> history)
        {
            this._history = history;
            this._localEndPoints = localEndPoints;
        }

        private void GenerateEndPoints()
        {
            List<IPEndPoint> list = new List<IPEndPoint>();
            Dictionary<IPEndPoint, bool> dictionary = new Dictionary<IPEndPoint, bool>();
            if (this._history != null)
            {
                if (this._remoteIPAddresses == null)
                {
                    this.InitRemoteIPAddresses();
                }
                List<IPAddressRecord>.Enumerator enumerator = this._remoteIPAddresses.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        IPAddressRecord record = enumerator.get_Current();
                        List<NATHistoryPoint> history = this.GetNATHistoryPointsForIPAddress(this._history, record.IPAddress);
                        List<NATHandler> allNATHandlers = GetAllNATHandlers();
                        bool flag = false;
                        for (int i = 0; (i < allNATHandlers.get_Count()) && !flag; i++)
                        {
                            if (allNATHandlers.get_Item(i).CanHandleNAT(history))
                            {
                                List<IPEndPoint>.Enumerator enumerator2 = allNATHandlers.get_Item(i).TargetEndPoints(history).GetEnumerator();
                                try
                                {
                                    while (enumerator2.MoveNext())
                                    {
                                        IPEndPoint point = enumerator2.get_Current();
                                        if (!dictionary.ContainsKey(point))
                                        {
                                            dictionary.set_Item(point, true);
                                            list.Add(point);
                                        }
                                    }
                                }
                                finally
                                {
                                    enumerator2.Dispose();
                                }
                                flag = true;
                            }
                        }
                    }
                }
                finally
                {
                    enumerator.Dispose();
                }
            }
            List<IPEndPoint>.Enumerator enumerator3 = this._localEndPoints.GetEnumerator();
            try
            {
                while (enumerator3.MoveNext())
                {
                    IPEndPoint point2 = enumerator3.get_Current();
                    if (!dictionary.ContainsKey(point2))
                    {
                        list.Add(point2);
                    }
                }
            }
            finally
            {
                enumerator3.Dispose();
            }
            this._generatedEndPoints = list;
        }

        private static List<NATHandler> GetAllNATHandlers()
        {
            List<NATHandler> list = new List<NATHandler>(5);
            list.Add(new PublicNATHandler());
            list.Add(new ConeNATHandler());
            list.Add(new LinuxNATHandler());
            list.Add(new SymmetricNATHandler());
            list.Add(new NullNATHandler());
            return list;
        }

        private List<NATHistoryPoint> GetNATHistoryPointsForIPAddress(List<NATHistoryPoint> history, IPAddress address)
        {
            List<NATHistoryPoint> list = new List<NATHistoryPoint>();
            List<NATHistoryPoint>.Enumerator enumerator = history.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    NATHistoryPoint point = enumerator.get_Current();
                    if ((point.PeerViewOfLocalEndPoint != null) && address.Equals(point.PeerViewOfLocalEndPoint.Address))
                    {
                        list.Add(point);
                    }
                }
            }
            finally
            {
                enumerator.Dispose();
            }
            return list;
        }

        private void InitRemoteIPAddresses()
        {
            List<NATHistoryPoint> list = this._history.FindAll(new Predicate<NATHistoryPoint>(null, (IntPtr) PredicateFindAllIPAddresses));
            Dictionary<IPAddress, IPAddressRecord> dictionary = new Dictionary<IPAddress, IPAddressRecord>();
            List<NATHistoryPoint>.Enumerator enumerator = list.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    NATHistoryPoint point = enumerator.get_Current();
                    if (!dictionary.ContainsKey(point.PeerViewOfLocalEndPoint.Address))
                    {
                        IPAddressRecord record = new IPAddressRecord();
                        record.IPAddress = point.PeerViewOfLocalEndPoint.Address;
                        record.Count = 1;
                        dictionary.set_Item(point.PeerViewOfLocalEndPoint.Address, record);
                    }
                    else
                    {
                        IPAddressRecord local1 = dictionary.get_Item(point.PeerViewOfLocalEndPoint.Address);
                        local1.Count++;
                    }
                }
            }
            finally
            {
                enumerator.Dispose();
            }
            List<IPAddressRecord> list2 = new List<IPAddressRecord>();
            Dictionary<IPAddress, IPAddressRecord>.ValueCollection.Enumerator enumerator2 = dictionary.get_Values().GetEnumerator();
            try
            {
                while (enumerator2.MoveNext())
                {
                    IPAddressRecord record2 = enumerator2.get_Current();
                    list2.Add(record2);
                }
            }
            finally
            {
                enumerator2.Dispose();
            }
            list2.Sort();
            this._remoteIPAddresses = list2;
        }

        private static bool PredicateFindAllIPAddresses(NATHistoryPoint historyPoint)
        {
            return (historyPoint.PeerViewOfLocalEndPoint != null);
        }

        public List<IPEndPoint> EndPoints
        {
            get
            {
                if (this._generatedEndPoints == null)
                {
                    this.GenerateEndPoints();
                }
                return this._generatedEndPoints;
            }
        }
    }
}