receiver.cs

破解的飞信源代码

namespace Imps.Client.Core.P2P.BlockingTransportor
{
    using Imps.Client.Core;
    using Imps.Client.Core.P2P.FileTransportor;
    using Imps.Client.Core.P2P.ICE;
    using NCindy.Session.AIO;
    using NCindy.Util.Logging;
    using System;
    using System.Diagnostics;
    using System.IO;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    using System.Threading;

    public class Receiver : TranBase
    {
        private static readonly ILogger log = LogFactory.CreateLogger(MethodBase.GetCurrentMethod().ReflectedType);
        private const int MaxRecvTimeoutCount = 0x1770;
        private readonly IPEndPoint remoteEndPoint;

        public Receiver(PunchingResult result, TransportingFile file) : base(file, result)
        {
            this.remoteEndPoint = result.Remote.FirstEndPoint;
            this.Init(result.Local.FirstEndPoint);
        }

        private void DoReceive()
        {
            Stopwatch stopwatch = Stopwatch.StartNew();
            long num = 0;
            byte[] buffer = new byte[base.BufferSize];
            int num2 = 0;
            using (FileStream stream = base.targetFile.InnerFileStream)
            {
                while (!base.stoped && (base.targetFile.CompletedSize < base.targetFile.FileSize))
                {
                    if (num2 > 0x1770)
                    {
                        throw new RecvTimeoutException();
                    }
                    base.pauseEvent.WaitOne();
                    if (!base.socket.Poll(0x186a0, SelectMode.SelectRead))
                    {
                        num2++;
                    }
                    else
                    {
                        num2 = 0;
                        int count = base.socket.Receive(buffer, buffer.Length, SocketFlags.None);
                        if (count <= 0)
                        {
                            throw new RemoteSocketClosedException();
                        }
                        stream.Write(buffer, 0, count);
                        base.transportedBytes += count;
                        base.targetFile.CompletedSize += count;
                        base.targetFile.InnerFileStream.Position = base.targetFile.CompletedSize;
                        long num4 = stopwatch.get_ElapsedMilliseconds();
                        if ((num4 - num) >= 0x3e8)
                        {
                            base.FireBlockTransported(new BlockTranEventArgs(base.targetFile.CompletedSize, this.TranFileSize, stopwatch.get_ElapsedMilliseconds()));
                            num = num4;
                        }
                    }
                }
                base.FireBlockTransported(new BlockTranEventArgs(base.targetFile.CompletedSize, this.TranFileSize, stopwatch.get_ElapsedMilliseconds()));
            }
        }

        public override void Init(IPEndPoint localEndPoint)
        {
            base.Init(localEndPoint);
            if (!base.socket.Connected)
            {
                base.socket.Connect(this.remoteEndPoint);
            }
        }

        protected override void InternalTransport()
        {
            try
            {
                this.DoReceive();
                if (!base.stoped)
                {
                    string s = "SHUTDOWN:" + Guid.NewGuid();
                    byte[] bytes = Encoding.UTF8.GetBytes(s);
                    base.socket.Send(bytes);
                    try
                    {
                        ManualResetEvent mre = new ManualResetEvent(false);
                        byte[] buffer = new byte[base.BufferSize];
                        base.socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, delegate (IAsyncResult ar) {
                            this.socket.EndReceive(ar);
                            mre.Set();
                        }, null);
                        mre.WaitOne(0x1388, true);
                    }
                    catch
                    {
                    }
                    base.FireTransportCompleted();
                }
            }
            catch (Exception exception)
            {
                base.FireTransportFailed(new TranFailedEventArgs(exception));
            }
            finally
            {
                if (log.IsDebugEnabled)
                {
                    log.Debug("InternalTransport thread exit.");
                }
            }
        }

        public int LocalPort
        {
            get
            {
                return base.socket.LocalEndPoint.Port;
            }
        }

        public override long TranFileSize
        {
            get
            {
                return base.targetFile.FileSize;
            }
        }

        public class RecvTimeoutException : Exception
        {
        }
    }
}