Exemple #1
0
        public async Task AddPeers_PeerExchangeMessage_Private()
        {
            var peer = new byte[] { 192, 168, 0, 1, 100, 0 };
            var dotF = new byte[] { 1 << 0 | 1 << 2 }; // 0x1 means supports encryption, 0x2 means is a seeder
            var id   = PeerId.CreateNull(40);

            id.SupportsFastPeer   = true;
            id.SupportsLTMessages = true;

            var manager = TestRig.CreatePrivate();

            manager.Mode = new DownloadMode(manager, DiskManager, ConnectionManager, Settings);
            var peersTask = new TaskCompletionSource <PeerExchangePeersAdded> ();

            manager.PeersFound += (o, e) => {
                if (e is PeerExchangePeersAdded args)
                {
                    peersTask.TrySetResult(args);
                }
            };

            var exchangeMessage = new PeerExchangeMessage(13, peer, dotF, null);

            manager.Mode.HandleMessage(id, exchangeMessage);

            var addedArgs = await peersTask.Task.WithTimeout();

            Assert.AreEqual(0, addedArgs.NewPeers, "#1");
        }
Exemple #2
0
        protected virtual async void HandlePeerExchangeMessage(PeerId id, PeerExchangeMessage message)
        {
            // Ignore peer exchange messages on private toirrents
            if ((Manager.Torrent != null && Manager.Torrent.IsPrivate) || !Manager.Settings.AllowPeerExchange)
            {
                Manager.RaisePeersFound(new PeerExchangePeersAdded(Manager, 0, 0, id));
            }
            else
            {
                // If we already have lots of peers, don't process the messages anymore.
                if ((Manager.Peers.Available + Manager.OpenConnections) >= Manager.Settings.MaximumConnections)
                {
                    return;
                }

                IList <Peer> newPeers = Peer.Decode(message.Added);
                for (int i = 0; i < newPeers.Count && i < message.AddedDotF.Length; i++)
                {
                    newPeers[i].IsSeeder = (message.AddedDotF[i] & 0x2) == 0x2;
                }
                int count = await Manager.AddPeersAsync(newPeers);

                Manager.RaisePeersFound(new PeerExchangePeersAdded(Manager, count, newPeers.Count, id));
            }
        }
        public void PeerExchangeMessageDecode_Empty()
        {
            var data    = new BEncodedDictionary().Encode();
            var message = new PeerExchangeMessage();

            message.Decode(data, 0, data.Length);
            Assert.IsEmpty(message.Added, "#1");
            Assert.IsEmpty(message.AddedDotF, "#2");
            Assert.IsEmpty(message.Dropped, "#3");
        }
        public void PeerExchangeMessageTest()
        {
            var data    = new BEncodedDictionary().Encode();
            var message = new PeerExchangeMessage();

            message.Decode(data, 0, data.Length);
            Assert.IsNotNull(message.Added, "#1");
            Assert.IsNotNull(message.AddedDotF, "#1");
            Assert.IsNotNull(message.Dropped, "#1");
        }
        public void PeerExchangeMessageTest()
        {
            // Decodes as: 192.168.0.1:100
            byte[] peer = new byte[] { 192, 168, 0, 1, 100, 0 };
            byte[] supports = new byte[] { (byte)(1 | 2) }; // 1 == encryption, 2 == seeder

            byte id = OctoTorrent.Client.Messages.Libtorrent.PeerExchangeMessage.Support.MessageId;
            PeerExchangeMessage message = new PeerExchangeMessage(id, peer, supports, null);

            byte[] buffer = message.Encode();
            PeerExchangeMessage m = (PeerExchangeMessage)PeerMessage.DecodeMessage(buffer, 0, buffer.Length, this.rig.Manager);
            Assert.IsTrue(Toolbox.ByteMatch(peer, m.Added), "#1");
            Assert.IsTrue(Toolbox.ByteMatch(supports, m.AddedDotF), "#1");
        }
        public void PeerExchangeMessageDecode()
        {
            // Decodes as: 192.168.0.1:100
            byte[] peer     = { 192, 168, 0, 1, 100, 0 };
            byte[] supports = { 1 | 2 }; // 1 == encryption, 2 == seeder

            byte id = PeerExchangeMessage.Support.MessageId;
            PeerExchangeMessage message = new PeerExchangeMessage(id, peer, supports, null);

            byte[] buffer         = message.Encode();
            PeerExchangeMessage m = (PeerExchangeMessage)PeerMessage.DecodeMessage(buffer, 0, buffer.Length, null);

            Assert.IsTrue(Toolbox.ByteMatch(peer, m.Added), "#1");
            Assert.IsTrue(Toolbox.ByteMatch(supports, m.AddedDotF), "#1");
        }
Exemple #7
0
        public void PeerExchangeMessageTest()
        {
            // Decodes as: 192.168.0.1:100
            var peer     = new byte[] { 192, 168, 0, 1, 100, 0 };
            var supports = new[] { (byte)(1 | 2) }; // 1 == encryption, 2 == seeder

            var id      = PeerExchangeMessage.Support.MessageId;
            var message = new PeerExchangeMessage(id, peer, supports, null);

            var buffer = message.Encode();
            var m      = (PeerExchangeMessage)PeerMessage.DecodeMessage(buffer, 0, buffer.Length, _rig.Manager);

            Assert.IsTrue(Toolbox.ByteMatch(peer, m.Added), "#1");
            Assert.IsTrue(Toolbox.ByteMatch(supports, m.AddedDotF), "#1");
        }
        public void PeerExchangeMessageTest()
        {
            // Decodes as: 192.168.0.1:100
            byte[] peer     = new byte[] { 192, 168, 0, 1, 100, 0 };
            byte[] supports = new byte[] { (byte)(1 | 2) }; // 1 == encryption, 2 == seeder

            byte id = System.Net.BitTorrent.Client.Messages.Libtorrent.PeerExchangeMessage.Support.MessageId;
            PeerExchangeMessage message = new PeerExchangeMessage(id, peer, supports, null);

            byte[] buffer         = message.Encode();
            PeerExchangeMessage m = (PeerExchangeMessage)PeerMessage.DecodeMessage(buffer, 0, buffer.Length, this.rig.Manager);

            Assert.True(Toolbox.ByteMatch(peer, m.Added), "#1");
            Assert.True(Toolbox.ByteMatch(supports, m.AddedDotF), "#1");
        }
        public void PeerExchangeMessageTest()
        {
            // Decodes as: 192.168.0.1:100
            var peer = new byte[] { 192, 168, 0, 1, 100, 0 };
            var supports = new[] { (byte)(1 | 2) }; // 1 == encryption, 2 == seeder

            var id = PeerExchangeMessage.Support.MessageId;
            var message = new PeerExchangeMessage(id, peer, supports, null);

            var buffer = message.Encode();
            var m = (PeerExchangeMessage)PeerMessage.DecodeMessage(buffer, 0, buffer.Length, _rig.Manager);

            Assert.IsTrue(Toolbox.ByteMatch(peer, m.Added), "#1");
            Assert.IsTrue(Toolbox.ByteMatch(supports, m.AddedDotF), "#1");
        }
        public void TestWithSomePeersToSend()
        {
            PeerExchangeMessage sentMessage = new PeerExchangeMessage();
            var messageHandler = new PeerExchangeMessageHandler(Mock.Of <ILogger <PeerExchangeMessageHandler> >(), Mock.Of <ITcpTransportProtocol>());

            var context = new Mock <IExtensionProtocolMessageReceivedContext>();

            context.Setup(x => x.Message).Returns(MockMessage());
            context.Setup(x => x.Peers).Returns(MockPeers());
            context.Setup(x => x.SendMessage(It.IsAny <IExtensionProtocolMessage>())).Callback <IExtensionProtocolMessage>(message => sentMessage = (PeerExchangeMessage)message);

            var metadata = new PeerExchangeMetadata
            {
                ConnectedPeersSnapshot = new List <string>
                {
                    "192.168.1.20:8080",
                    "192.168.1.21:8080",
                    "192.168.1.25:8080",
                },
            };

            context.Setup(x => x.GetValue <PeerExchangeMetadata>(PeerExchangeMetadata.Key)).Returns(metadata);

            messageHandler.MessageReceived(context.Object);

            context.Verify(x => x.Message, Times.Once);
            context.Verify(x => x.PeersAvailable(It.IsAny <IEnumerable <ITransportStream> >()), Times.Once);
            context.Verify(x => x.GetValue <PeerExchangeMetadata>(PeerExchangeMetadata.Key), Times.Once);
            context.Verify(x => x.Peers, Times.Once);
            context.Verify(x => x.SendMessage(It.IsAny <PeerExchangeMessage>()), Times.Once);
            context.Verify(x => x.SetValue(PeerExchangeMetadata.Key, It.IsAny <PeerExchangeMetadata>()), Times.Once);
            context.VerifyNoOtherCalls();

            var expectedSentMessage = new PeerExchangeMessage
            {
                Added = new List <IPEndPoint>
                {
                    new IPEndPoint(new IPAddress(new byte[] { 192, 168, 1, 22 }), 8080),
                    new IPEndPoint(new IPAddress(new byte[] { 192, 168, 1, 23 }), 8080),
                },
                Dropped = new List <IPEndPoint>
                {
                    new IPEndPoint(new IPAddress(new byte[] { 192, 168, 1, 25 }), 8080),
                },
            };

            sentMessage.Should().BeEquivalentTo(expectedSentMessage);
        }
Exemple #11
0
        protected virtual void HandlePeerExchangeMessage(PeerId id, PeerExchangeMessage message)
        {
            // Ignore peer exchange messages on private torrents
            if (id.TorrentManager.Torrent.IsPrivate || !id.TorrentManager.Settings.EnablePeerExchange)
            {
                return;
            }

            // If we already have lots of peers, don't process the messages anymore.
            if ((Manager.Peers.Available + Manager.OpenConnections) >= manager.Settings.MaxConnections)
            {
                return;
            }

            IList <Peer> peers = Peer.Decode((BEncodedString)message.Added);
            int          count = id.TorrentManager.AddPeersCore(peers);

            id.TorrentManager.RaisePeersFound(new PeerExchangePeersAdded(id.TorrentManager, count, peers.Count, id));
        }
Exemple #12
0
        public async Task AddPeers_PeerExchangeMessage()
        {
            var peer = new byte[] { 192, 168, 0, 1, 100, 0, 192, 168, 0, 2, 101, 0 };
            var dotF = new byte[] { 0, 1 << 1 }; // 0x2 means is a seeder
            var id   = PeerId.CreateNull(40);

            id.SupportsFastPeer   = true;
            id.SupportsLTMessages = true;

            Mode[] modes =
            {
                new DownloadMode(Manager, DiskManager, ConnectionManager, Settings),
                new MetadataMode(Manager, DiskManager, ConnectionManager, Settings, "")
            };

            foreach (var mode in modes)
            {
                var peersTask = new TaskCompletionSource <PeerExchangePeersAdded> ();
                Manager.PeersFound += (o, e) => {
                    if (e is PeerExchangePeersAdded args)
                    {
                        peersTask.TrySetResult(args);
                    }
                };

                Manager.Peers.ClearAll();
                var exchangeMessage = new PeerExchangeMessage(13, peer, dotF, null);
                Manager.Mode = mode;
                Manager.Mode.HandleMessage(id, exchangeMessage);

                var addedArgs = await peersTask.Task.WithTimeout();

                Assert.AreEqual(2, addedArgs.NewPeers, "#1");
                Assert.IsFalse(Manager.Peers.AvailablePeers[0].IsSeeder, "#2");
                Assert.IsTrue(Manager.Peers.AvailablePeers[1].IsSeeder, "#3");
            }
        }
Exemple #13
0
 protected override void HandlePeerExchangeMessage(PeerId id, PeerExchangeMessage message)
 {
     // Nothing
 }
 public void PeerExchangeMessageTest()
 {
     var data = new BEncodedDictionary ().Encode ();
     var message = new PeerExchangeMessage ();
     message.Decode (data, 0, data.Length);
     Assert.IsNotNull (message.Added, "#1");
     Assert.IsNotNull (message.AddedDotF, "#1");
     Assert.IsNotNull (message.Dropped, "#1");
 }
Exemple #15
0
        protected virtual void HandlePeerExchangeMessage(PeerId id, PeerExchangeMessage message)
        {
            // Ignore peer exchange messages on private torrents
            if (id.TorrentManager.Torrent.IsPrivate || !id.TorrentManager.Settings.EnablePeerExchange)
                return;

            // If we already have lots of peers, don't process the messages anymore.
            if ((Manager.Peers.Available + Manager.OpenConnections) >= _manager.Settings.MaxConnections)
                return;

            IList<Peer> peers = Peer.Decode(message.Added);
            var count = id.TorrentManager.AddPeersCore(peers);
            id.TorrentManager.RaisePeersFound(new PeerExchangePeersAdded(id.TorrentManager, count, peers.Count, id));
        }