Beispiel #1
0
 /// <summary>
 /// 设置本客户端的端点为新的端点。用于自我端点确认。
 /// </summary>
 /// <param name="ep">要被设置为的端点。</param>
 /// <exception cref="System.ArgumentNullException">ep 为 null 时发生。</exception>
 private void SetLocalEndPoint(IPEndPoint ep)
 {
     if (ep == null)
     {
         throw new ArgumentNullException("ep");
     }
     _localEndPoint  = ep;
     _localKEndPoint = KEndPoint.FromEndPoint(_localEndPoint);
 }
 /// <summary>
 /// 设定程序认为的 BitTorrent 客户端眼中的“自己”是什么。
 /// </summary>
 /// <param name="endPoint">本地的 BitTorrent 客户端使用的端点,包括本地局域网地址(不是本地环回地址)及其监听端口。</param>
 public void SetMyself(IPEndPoint endPoint, string peerID = null)
 {
     _myself = Peer.Create(KEndPoint.FromEndPoint(endPoint), peerID);
 }
Beispiel #3
0
        /// <summary>
        /// 连接到指定的接入端点,并广播“加入分布网络”消息。
        /// <para>注意,本方法执行中会为 ConnectionList 加锁。</para>
        /// </summary>
        /// <param name="pointInsertion">要连接的端点。</param>
        /// <param name="realPort">非零表示这是接入点要连接接入点,该端口是本机正在监听的端口;零表示只是普通用户连接接入点。</param>
        /// <param name="workerThread">返回发送用的 <see cref="System.Threading.Thread"/>。</param>
        /// <returns>一个 <see cref="System.Threading.WaitHandle"/>,通过此对象可以对发送操作进行等待。</returns>
        public WaitHandle EnterNetwork(IPEndPoint pointInsertion, ushort realPort, out Thread workerThread)
        {
            Logger.Log("KClient::EnterNetwork(IPEndPoint)" + Environment.NewLine + "接入点: " + pointInsertion.ToString());
            AutoResetEvent ev     = new AutoResetEvent(false);
            Thread         thread = new Thread(delegate()
            {
                try
                {
                    // 第一次发送信息,要使用以后用来接收信息的端口,这样才能让接入点知道你映射后的接收端口
                    //TcpClient client = new TcpClient();
                    // 那么就不能采取常规的方式,而应该用 TcpListener 的 socket 发出去
                    //TcpClient client = new TcpClient(new IPEndPoint(IPAddress.Loopback, LocalEndPoint.Port));
                    Socket enterSocket;
                    if (realPort == 0)
                    {
                        // 普通用户
                        enterSocket = _listener.Server;
                        if (!enterSocket.IsBound)
                        {
                            enterSocket.Bind(new IPEndPoint(IPAddress.Any, ((IPEndPoint)_listener.LocalEndpoint).Port));
                        }
                    }
                    else
                    {
                        enterSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    }
                    //Socket enterSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    //Socket enterSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
                    //enterSocket.Bind(new IPEndPoint(IPAddress.Loopback, LocalEndPoint.Port));
                    Logger.Log("尝试连接端点: " + pointInsertion.ToString());
                    //var iar = client.BeginConnect(pointInsertion.Address, pointInsertion.Port, null, null);
                    var iar = enterSocket.BeginConnect(pointInsertion, null, null);
                    if (!iar.IsCompleted)
                    {
                        iar.AsyncWaitHandle.WaitOne(SendTimeout);
                    }
                    if (!iar.IsCompleted)
                    {
                        Logger.Log("连接超时。");
                        // 未成功连接的话,直接返回
                        //return false;
                        ev.Set();
                        ev.Dispose();
                        return;
                        // 这里好像无法直接返回连接状态
                        // 但是应该可以判断连接列表是否为空来确定是否成功,非空则成功,否则失败
                    }
                    //client.EndConnect(iar);
                    enterSocket.EndConnect(iar);
                    Logger.Log("socket 本地端点: " + enterSocket.LocalEndPoint.ToString() + " 远程端点: " + enterSocket.RemoteEndPoint.ToString());
                    // 为了不干扰连接列表的报告,先发送信息
                    Logger.Log("连接成功,发送自己进入的消息。");

                    int origPortNumber;
                    string origAddress;

                    //var bs = client.GetStream();
                    {
                        // 写入
                        //bs.WriteMessage(MessageFactory.ClientEnterNetwork(LocalKEndPoint));
                        enterSocket.WriteMessage(MessageFactory.ClientEnterNetwork(LocalKEndPoint, realPort));

                        // 接下来接收接入点返回的当前连接信息
                        // 先是读取列表数据大小
                        Logger.Log("读取返回数据: 数据长度");
                        //int dataLength = bs.ReadInt32();
                        int dataLength = enterSocket.ReadInt32();
                        Logger.Log("长度: " + dataLength.ToString());
                        // 然后读列表
                        var dataBuffer      = new byte[1024];
                        var data            = new byte[dataLength];
                        int readLength      = 0;
                        int totalReadLength = 0;
                        // 确保全部读取
                        while (totalReadLength < dataLength)
                        {
                            //readLength = bs.Read(dataBuffer, 0, dataBuffer.Length);
                            readLength = enterSocket.Receive(dataBuffer);
                            if (readLength > 0)
                            {
                                Array.Copy(dataBuffer, 0, data, totalReadLength, readLength);
                                totalReadLength += readLength;
                            }
                        }
                        Logger.Log("数据读取完毕。准备解码。");

                        origPortNumber = LocalEndPoint.Port;
                        origAddress    = LocalEndPoint.Address.ToString();

                        // 解码并将自己的连接列表和用户列表同步为接入点的数据
                        DecodeTargetInformation(data);
                        Logger.Log("他人眼中的我: " + LocalEndPoint.ToString());

                        StringBuilder sb = new StringBuilder(100);
                        sb.AppendLine("刚刚收到的连接列表如下。");
                        lock (ConnectionList)
                        {
                            foreach (var item in ConnectionList)
                            {
                                sb.AppendLine(item.ToString());
                            }
                        }
                        sb.AppendLine("刚刚收到的用户列表如下。");
                        lock (TrackerServer.Seeds)
                        {
                            foreach (var item in TrackerServer.Seeds)
                            {
                                sb.AppendLine("[" + item.Key.ToHexString() + "]");
                                foreach (var peer in item.Value)
                                {
                                    sb.AppendLine(peer.EndPoint.ToString());
                                }
                            }
                        }
                        Logger.Log(sb.ToString());
                    }

                    Logger.Log("添加对方持有的连接信息结束,将对方加入自己的连接列表。");
                    // 然后将对方加入自己的连接列表
                    try
                    {
                        AddToConnectionList(KEndPoint.FromEndPoint(pointInsertion));
                    }
                    catch (Exception)
                    {
                    }

                    // 不需要
                    //if (ConnectionList.Count > 0)
                    //{
                    //    Logger.Log("尝试广播消息,让连接列表中的客户端报告他们存活。");
                    //    // 要其他人报告他们存活
                    //    // 能发送等价于存活,所以并不期望回音,只是测试能连接而已
                    //    BroadcastMessage(MessageFactory.ReportAlive(LocalKEndPoint));
                    //}

                    //client.Close();
                    enterSocket.Disconnect(false);
                    enterSocket.Close();
                    _listener.Stop();

                    // 说到底,要 EnterNetwork(),肯定是普通客户端,那么就请求端口映射吧
                    //if (origPortNumber != LocalEndPoint.Port)
                    {
                        if (PortMapping.CanUsePortMapping)
                        {
                            try
                            {
                                if (origPortNumber == LocalEndPoint.Port)
                                {
                                    Thread.Sleep(TimeSpan.FromSeconds(0.8));
                                }
                                //PortMapping.AddPortMapping((ushort)origPortNumber, (ushort)LocalEndPoint.Port, origAddress);
                                PortMapping.AddPortMapping((ushort)origPortNumber, (ushort)LocalEndPoint.Port);
                            }
                            catch (Exception ex)
                            {
                                System.Diagnostics.Debug.Print("AddPortMapping: " + ex.Message);
                                Logger.Log("AddPortMapping: " + ex.Message);
                            }
                        }
                    }

                    ev.Set();
                    ev.Dispose();
                    //return true;
                }
                catch (Exception ex)
                {
                    Logger.Log(ex.Message + Environment.NewLine + ex.StackTrace);
                }
            });

            thread.IsBackground = true;
            thread.Start();
            workerThread = thread;
            return(ev);
        }
        /// <summary>
        /// 消息处理的核心分发过程。
        /// </summary>
        /// <param name="args">处理时需要的信息。</param>
        private void HandleMessage(HandleMessageArgs args)
        {
            Logger.Log("KClient::HandleMessage() from " + args.Message.Header.SourceEndPoint.ToString() + " with code " + args.Message.Header.Code.ToString());
            // 确保不是自己发出的消息
            if (!args.Message.Header.SourceEndPoint.Equals(_localKEndPoint))
            {
                KHandledMessage handledMessage;
                int             handledMessageIndex;
                handledMessage = HandledMessages.FindHandledMessage(args.Message, out handledMessageIndex);
                string tmpLog;
                tmpLog  = "消息代码: " + args.Message.Header.Code.ToString();
                tmpLog += Environment.NewLine + "消息唯一编码: " + args.Message.Header.MessageID.ToString();
                tmpLog += Environment.NewLine + "消息来源: " + args.Message.Header.SourceEndPoint.ToString();
                Logger.Log(tmpLog);
                // 若未处理过该消息
                if (handledMessage == null)
                {
                    Logger.Log("未处理过该消息。");
                    switch (args.Message.Header.Code)
                    {
                    case KMessageCode.ReportAlive:
                        if (!args.Message.Header.SourceEndPoint.AddressEquals(IPAddress.Loopback))
                        {
                            HandleReportAlive(args);
                            AddToConnectionList(args.Message.Header.SourceEndPoint);
                        }
                        break;

                    case KMessageCode.ClientEnterNetwork:
                        HandleClientEnterNetwork(args);
                        if (args.RealPort == 0)
                        {
                            // 这条消息是用来连接到接入点的,此时对方还未初始化完毕,所以不用判断源端点的事情
                            AddToConnectionList(KEndPoint.FromEndPoint(args.EndPoint));
                        }
                        else
                        {
                            // 这是接入点连接到接入点的请求
                            // 此时地址是真实的,监听端口由 args.RealPort 反映
                            var kep = KEndPoint.FromEndPoint(args.EndPoint);
                            kep.SetPort(args.RealPort);
                            AddToConnectionList(kep);
                        }
                        break;

                    case KMessageCode.ClientExitNetwork:
                        if (!args.Message.Header.SourceEndPoint.AddressEquals(IPAddress.Loopback))
                        {
                            HandleClientExitNetwork(args);
                            // 既然退出了为什么还要保留这个项
                            //AddToConnectionList(args.Message.Header.SourceEndPoint);
                        }
                        break;

                    case KMessageCode.PeerEnterNetwork:
                        if (!args.Message.Header.SourceEndPoint.AddressEquals(IPAddress.Loopback))
                        {
                            HandlePeerEnterNetwork(args);
                            AddToConnectionList(args.Message.Header.SourceEndPoint);
                        }
                        break;

                    case KMessageCode.PeerExitNetwork:
                        if (!args.Message.Header.SourceEndPoint.AddressEquals(IPAddress.Loopback))
                        {
                            HandlePeerExitNetwork(args);
                            AddToConnectionList(args.Message.Header.SourceEndPoint);
                        }
                        break;

                    case KMessageCode.GotPeer:
                        if (!args.Message.Header.SourceEndPoint.AddressEquals(IPAddress.Loopback))
                        {
                            HandleGotPeer(args);
                            AddToConnectionList(args.Message.Header.SourceEndPoint);
                        }
                        break;

                    default:
                        return;
                    }

                    Logger.Log("将消息加入“已处理”列表。");
                    // 对于收到的信息,都加入“已处理消息”列表
                    lock (HandledMessages)
                    {
                        HandledMessages.Add(new KHandledMessage(args.Message));
                    }
                }
                else
                {
                    Logger.Log("更新消息生命周期。");
                    // 更新生命周期,并将其移动到列表最后(因为是“刚刚加入”的)
                    handledMessage.LifeStart = DateTime.Now;
                    lock (HandledMessages)
                    {
                        // 访问这个过程的只有一个线程,所以不用担心说前面某一项先被移动到后面去了导致索引错误
                        HandledMessages.RemoveAt(handledMessageIndex);
                        HandledMessages.Add(handledMessage);
                    }
                    Logger.Log("清理“已处理”列表。");
                    SweepHandledMessages();
                }
            }
        }
        /// <summary>
        /// 处理 ClientEnterNetwork 消息。
        /// </summary>
        /// <param name="args">处理时需要的信息。</param>
        private void HandleClientEnterNetwork(HandleMessageArgs args)
        {
            Logger.Log("收到消息: 客户端加入分布网络。");
            KEndPoint remoteEndPoint   = args.Message.Header.SourceEndPoint;
            int       isMessageHandled = 0;
            ushort    realPort         = 0;

            if (args.Message.Content.Data.Length > 0)
            {
                BEncodedDictionary dict;
                dict             = BEncodedValue.Decode <BEncodedDictionary>(args.Message.Content.Data);
                isMessageHandled = (int)((dict["message handled"] as BEncodedNumber).Number);
                realPort         = (ushort)((dict["real port"] as BEncodedNumber).Number);
            }
            string enterArgsRecord = "ClientEnterNetwork Args:";

            enterArgsRecord += Environment.NewLine + "isMessageHandled: " + isMessageHandled.ToString();
            enterArgsRecord += Environment.NewLine + "realPort: " + realPort.ToString();
            Logger.Log(enterArgsRecord);
            args.RealPort = realPort;
            if (!ConnectionList.Contains(remoteEndPoint))
            {
                if (isMessageHandled == 0)
                {
                    Logger.Log("本客户端是第一个收到这条进入消息的客户端。" + Environment.NewLine + "本机的连接列表如下。");
                    StringBuilder sb = new StringBuilder(100);
                    lock (ConnectionList)
                    {
                        foreach (var item in ConnectionList)
                        {
                            sb.AppendLine(item.ToString());
                        }
                    }
                    Logger.Log(sb.ToString());

                    Logger.Log("将当前连接信息编码并发送。我眼中的对方: " + args.EndPoint.ToString());
                    // 将自己的连接列表和用户列表编码,准备发送到连接来的客户端
                    var data = EncodeTargetInformation(args.EndPoint);
                    // 然后要修正 remoteEndPoint,因为加入消息必定是 127.0.0.1:ep 形式,所以要修正为实际的 ep
                    remoteEndPoint = KEndPoint.FromEndPoint(args.EndPoint);
                    try
                    {
                        // 先返回接下来的字节大小
                        args.Stream.WriteInt32(data.Length);
                        // 然后一次性发送
                        args.Stream.Write(data, 0, data.Length);
                        args.Stream.Flush();
                    }
                    catch (Exception ex)
                    {
                        // 首次通信就失败了……
                        Logger.Log(ex.Message);
                        Logger.Log(ex.StackTrace);
                    }
                }
            }

            KMessage message = args.Message;

            if (isMessageHandled == 0)
            {
                // 注意:虽然 KMessage 是一个值类型,但是其中含有引用类型(数组),这里修改了这个引用类型
                Logger.Log("设置该消息为处理过。");
                message.Content.Data = BitConverter.GetBytes((int)1);
            }
            else
            {
                // 本客户端不是第一个处理的,那就报告存活吧
                SendMessage(remoteEndPoint, MessageFactory.ReportAlive(LocalKEndPoint));
            }
            Logger.Log("转发消息。");
            // 转发
            BroadcastMessage(message);
        }