private void ClearCurrentPing()
 {
     lock (cs)
     {
         _CurrentPing = null;
         _DateSent    = default(DateTimeOffset);
         var timeout = _PingTimeoutTimer;
         if (timeout != null)
         {
             timeout.Dispose();
             _PingTimeoutTimer = null;
         }
     }
 }
Esempio n. 2
0
 private void ClearCurrentPing()
 {
     lock (this.cs)
     {
         this.currentPing = null;
         this.dateSent    = default(DateTimeOffset);
         Timer timeout = this.pingTimeoutTimer;
         if (timeout != null)
         {
             timeout.Dispose();
             this.pingTimeoutTimer = null;
         }
     }
 }
Esempio n. 3
0
        private bool OnShowStateCommand(string[] args)
        {
            var cancel = new CancellationTokenSource();

            Console.CursorVisible = false;
            Console.Clear();
            Task broadcast = Task.Run(async() =>
            {
                while (!cancel.Token.IsCancellationRequested)
                {
                    system.LocalNode.Tell(Message.Create(MessageCommand.Ping, PingPayload.Create(Blockchain.Singleton.Height)));
                    await Task.Delay(Blockchain.TimePerBlock, cancel.Token);
                }
            });
            Task task = Task.Run(async() =>
            {
                int maxLines = 0;

                while (!cancel.Token.IsCancellationRequested)
                {
                    Console.SetCursorPosition(0, 0);
                    WriteLineWithoutFlicker($"block: {Blockchain.Singleton.Height}/{Blockchain.Singleton.HeaderHeight}  connected: {LocalNode.Singleton.ConnectedCount}  unconnected: {LocalNode.Singleton.UnconnectedCount}", Console.WindowWidth - 1);

                    int linesWritten = 1;
                    foreach (RemoteNode node in LocalNode.Singleton.GetRemoteNodes().OrderByDescending(u => u.LastBlockIndex).Take(Console.WindowHeight - 2).ToArray())
                    {
                        Console.WriteLine(
                            $"  ip: {node.Remote.Address.ToString().PadRight(15)}\tport: {node.Remote.Port.ToString().PadRight(5)}\tlisten: {node.ListenerTcpPort.ToString().PadRight(5)}\theight: {node.LastBlockIndex.ToString().PadRight(7)}");
                        linesWritten++;
                    }

                    maxLines = Math.Max(maxLines, linesWritten);

                    while (linesWritten < maxLines)
                    {
                        WriteLineWithoutFlicker("", Console.WindowWidth - 1);
                        maxLines--;
                    }

                    await Task.Delay(500, cancel.Token);
                }
            });

            Console.ReadLine();
            cancel.Cancel();
            try { Task.WaitAll(task, broadcast); } catch { }
            Console.WriteLine();
            Console.CursorVisible = true;
            return(true);
        }
Esempio n. 4
0
        public void Serialize_Deserialize()
        {
            var payload     = PingPayload.Create(uint.MaxValue);
            var msg         = Message.Create(MessageCommand.Ping, payload);
            var buffer      = msg.ToArray();
            var copy        = buffer.AsSerializable <Message>();
            var payloadCopy = (PingPayload)copy.Payload;

            copy.Command.Should().Be(msg.Command);
            copy.Flags.Should().Be(msg.Flags);

            payloadCopy.LastBlockIndex.Should().Be(payload.LastBlockIndex);
            payloadCopy.Nonce.Should().Be(payload.Nonce);
            payloadCopy.Timestamp.Should().Be(payload.Timestamp);
        }
Esempio n. 5
0
    public async Task SendPingNotificationAsync(PingPayload request)
    {
        _logger.LogInformation($"Sending BeingPinged mail for post '{request.TargetPostTitle}'");

        SetEmailInfo();

        var pipeline = new TemplatePipeline().Map(nameof(request.TargetPostTitle), request.TargetPostTitle)
                       .Map(nameof(request.PingTimeUtc), request.PingTimeUtc)
                       .Map(nameof(request.Domain), request.Domain)
                       .Map(nameof(request.SourceIp), request.SourceIp)
                       .Map(nameof(request.SourceTitle), request.SourceTitle)
                       .Map(nameof(request.SourceUrl), request.SourceUrl);

        await EmailHelper.ApplyTemplate(MailMesageTypes.BeingPinged.ToString(), pipeline)
        .SendMailAsync(AdminEmail);
    }
Esempio n. 6
0
        void SetBloomFilter()
        {
            var node = AttachedNode;

            if (node != null)
            {
                _RunningPing = null;
                var filter = _Tracker.CreateBloomFilter(FalsePositiveRate);
                node.SendMessageAsync(new FilterLoadPayload(filter));
                var ping = new PingPayload()
                {
                    Nonce = RandomUtils.GetUInt64()
                };
                _RunningPing = ping;
                node.SendMessageAsync(ping);
            }
        }
Esempio n. 7
0
 private void SendPingMessage()
 {
     foreach (KeyValuePair <IActorRef, TaskSession> item in sessions)
     {
         var node    = item.Key;
         var session = item.Value;
         if (Blockchain.Singleton.Height >= session.LastBlockIndex &&
             TimeProvider.Current.UtcNow.ToTimestampMS() - PingCoolingOffPeriod >= Blockchain.Singleton.GetBlock(Blockchain.Singleton.CurrentBlockHash)?.Timestamp)
         {
             if (session.InvTasks.Remove(MemPoolTaskHash))
             {
                 node.Tell(Message.Create(MessageCommand.Mempool));
             }
             node.Tell(Message.Create(MessageCommand.Ping, PingPayload.Create(Blockchain.Singleton.Height)));
         }
     }
 }
Esempio n. 8
0
        public void Serialize_Deserialize_ByteString()
        {
            var payload = PingPayload.Create(uint.MaxValue);
            var msg     = Message.Create(MessageCommand.Ping, payload);
            var buffer  = ByteString.CopyFrom(msg.ToArray());
            var length  = Message.TryDeserialize(buffer, out var copy);

            var payloadCopy = (PingPayload)copy.Payload;

            copy.Command.Should().Be(msg.Command);
            copy.Flags.Should().Be(msg.Flags);

            payloadCopy.LastBlockIndex.Should().Be(payload.LastBlockIndex);
            payloadCopy.Nonce.Should().Be(payload.Nonce);
            payloadCopy.Timestamp.Should().Be(payload.Timestamp);

            buffer.Count.Should().Be(length);
        }
        private static async Task <bool> TryPingAsync(MySqlSession session, CancellationToken cancellationToken)
        {
            await session.SendAsync(PingPayload.Create(), cancellationToken).ConfigureAwait(false);

            try
            {
                var payload = await session.ReceiveReplyAsync(cancellationToken).ConfigureAwait(false);

                OkPayload.Create(payload);
                return(true);
            }
            catch (EndOfStreamException)
            {
            }
            catch (SocketException)
            {
            }

            return(false);
        }
        /// <summary>
        /// Emit a ping and wait the pong.
        /// </summary>
        /// <param name="cancellation"></param>
        /// <param name="peer"></param>
        /// <returns>Latency.</returns>
        public TimeSpan PingPong(NetworkPeer peer, CancellationToken cancellation = default(CancellationToken))
        {
            using (NetworkPeerListener listener = peer.CreateListener().OfType <PongPayload>())
            {
                var ping = new PingPayload()
                {
                    Nonce = RandomUtils.GetUInt64()
                };

                DateTimeOffset before = DateTimeOffset.UtcNow;
                peer.SendMessageVoidAsync(ping);

                while (listener.ReceivePayload <PongPayload>(cancellation).Nonce != ping.Nonce)
                {
                }

                DateTimeOffset after = DateTimeOffset.UtcNow;

                return(after - before);
            }
        }
Esempio n. 11
0
        /// <summary>
        /// Emit a ping and wait the pong.
        /// </summary>
        /// <param name="cancellation"></param>
        /// <param name="peer"></param>
        /// <returns>Latency.</returns>
        public async Task <TimeSpan> PingPongAsync(INetworkPeer peer, CancellationToken cancellation = default(CancellationToken))
        {
            using (var listener = new NetworkPeerListener(peer))
            {
                var ping = new PingPayload()
                {
                    Nonce = RandomUtils.GetUInt64()
                };

                DateTimeOffset before = DateTimeOffset.UtcNow;
                await peer.SendMessageAsync(ping, cancellation);

                while ((await listener.ReceivePayloadAsync <PongPayload>(cancellation).ConfigureAwait(false)).Nonce != ping.Nonce)
                {
                }

                DateTimeOffset after = DateTimeOffset.UtcNow;

                return(after - before);
            }
        }
Esempio n. 12
0
 public void CanRespondToPong()
 {
     using (var tester = new NodeServerTester())
     {
         var toS2 = tester.Node1;
         toS2.VersionHandshake();
         var ping = new PingPayload();
         CancellationTokenSource cancel = new CancellationTokenSource();
         cancel.CancelAfter(10000);
         using (var list = toS2.CreateListener())
         {
             toS2.SendMessageAsync(ping);
             while (true)
             {
                 var pong = list.ReceivePayload <PongPayload>(cancel.Token);
                 if (ping.Nonce == pong.Nonce)
                 {
                     break;
                 }
             }
         }
     }
 }
Esempio n. 13
0
    public async Task Handle(PingbackNotification notification, CancellationToken cancellationToken)
    {
        var payload = new PingPayload(
            notification.TargetPostTitle,
            notification.PingTimeUtc,
            notification.Domain,
            notification.SourceIp,
            notification.SourceUrl,
            notification.SourceTitle);

        var response = await _client.SendNotification(MailMesageTypes.BeingPinged, payload);

        var respBody = await response.Content.ReadAsStringAsync(cancellationToken);

        if (response.IsSuccessStatusCode)
        {
            _logger.LogInformation($"Test email is sent, server response: '{respBody}'");
        }
        else
        {
            throw new($"Test email sending failed, response code: '{response.StatusCode}', response body: '{respBody}'");
        }
    }
Esempio n. 14
0
        public async Task <bool> TryPingAsync(IOBehavior ioBehavior, CancellationToken cancellationToken)
        {
            VerifyState(State.Connected);

            // send ping payload to verify client and server socket are still connected
            try
            {
                await SendAsync(PingPayload.Create(), ioBehavior, cancellationToken).ConfigureAwait(false);

                var payload = await ReceiveReplyAsync(ioBehavior, cancellationToken).ConfigureAwait(false);

                OkPayload.Create(payload);
                return(true);
            }
            catch (IOException)
            {
            }
            catch (SocketException)
            {
            }

            VerifyState(State.Failed);
            return(false);
        }
        void AttachedNode_MessageReceived(Node node, IncomingMessage message)
        {
            message.IfPayloadIs <InvPayload>(invPayload =>
            {
                foreach (var hash in invPayload.Where(i => i.Type == InventoryType.MSG_TX).Select(i => i.Hash))
                {
                    var tx = GetTransaction(hash, true);
                    if (tx != null)
                    {
                        tx.State = BroadcastState.Accepted;
                    }
                    Types.Transaction unused;
                    if (_BroadcastHub.BroadcastedTransaction.TryRemove(hash, out unused))
                    {
                        _BroadcastHub.OnTransactionBroadcasted(tx.Transaction);
                    }
                }
            });

            message.IfPayloadIs <RejectPayload>(reject =>
            {
                if (reject.Message == "tx")
                {
                    var tx = GetTransaction(reject.Hash, true);
                    if (tx != null)
                    {
                        tx.State = BroadcastState.Rejected;
                    }
                    Types.Transaction tx2;
                    if (_BroadcastHub.BroadcastedTransaction.TryRemove(reject.Hash, out tx2))
                    {
                        _BroadcastHub.OnTransactionRejected(tx2, reject);
                    }
                }
            });

            message.IfPayloadIs <GetDataPayload>(getData =>
            {
                foreach (var inventory in getData.Inventory.Where(i => i.Type == InventoryType.MSG_TX))
                {
                    var tx = GetTransaction(inventory.Hash, false);

                    //if (tx == null)
                    //{
                    //	tx = _BlockChain.GetTransaction(inventory.Hash);
                    //}

                    if (tx != null)
                    {
                        tx.State     = BroadcastState.Broadcasted;
                        var ping     = new PingPayload();
                        tx.PingValue = ping.Nonce;
                        _PingToTransaction.TryAdd(tx.PingValue, tx);
                        node.SendMessageAsync(tx.Transaction);
                        node.SendMessageAsync(ping);
                    }
                }
            });

            message.IfPayloadIs <PongPayload>(pong =>
            {
                var tx = GetTransaction(pong.Nonce, true);
                if (tx != null)
                {
                    tx.State = BroadcastState.Accepted;
                    Types.Transaction unused;
                    if (_BroadcastHub.BroadcastedTransaction.TryRemove(GetHash(tx.Transaction), out unused))
                    {
                        _BroadcastHub.OnTransactionBroadcasted(tx.Transaction);
                    }
                }
            });
        }
Esempio n. 16
0
        private void RequestTasks(TaskSession session)
        {
            if (session.HasTask)
            {
                return;
            }
            // If there are pending tasks of InventoryType.Block we should process them
            if (session.AvailableTasks.Count > 0)
            {
                session.AvailableTasks.Remove(knownHashes);
                // Search any similar hash that is on Singleton's knowledge, which means, on the way or already processed
                session.AvailableTasks.RemoveWhere(p => Blockchain.Singleton.ContainsBlock(p));
                HashSet <UInt256> hashes = new HashSet <UInt256>(session.AvailableTasks);
                hashes.Remove(MemPoolTaskHash);
                if (hashes.Count > 0)
                {
                    foreach (UInt256 hash in hashes.ToArray())
                    {
                        if (!IncrementGlobalTask(hash))
                        {
                            hashes.Remove(hash);
                        }
                    }
                    session.AvailableTasks.Remove(hashes);
                    foreach (UInt256 hash in hashes)
                    {
                        session.Tasks[hash] = DateTime.UtcNow;
                    }
                    foreach (InvPayload group in InvPayload.CreateGroup(InventoryType.Block, hashes.ToArray()))
                    {
                        session.RemoteNode.Tell(Message.Create(MessageCommand.GetData, group));
                    }
                    return;
                }
            }

            // When the number of AvailableTasks is no more than 0, no pending tasks of InventoryType.Block, it should process pending the tasks of headers
            // If not HeaderTask pending to be processed it should ask for more Blocks
            if ((!HasHeaderTask || globalTasks[HeaderTaskHash] < MaxConncurrentTasks) && Blockchain.Singleton.HeaderHeight < session.LastBlockIndex)
            {
                session.Tasks[HeaderTaskHash] = DateTime.UtcNow;
                IncrementGlobalTask(HeaderTaskHash);
                session.RemoteNode.Tell(Message.Create(MessageCommand.GetHeaders, GetBlocksPayload.Create(Blockchain.Singleton.CurrentHeaderHash)));
            }
            else if (Blockchain.Singleton.Height < session.LastBlockIndex)
            {
                UInt256 hash = Blockchain.Singleton.CurrentBlockHash;
                for (uint i = Blockchain.Singleton.Height + 1; i <= Blockchain.Singleton.HeaderHeight; i++)
                {
                    hash = Blockchain.Singleton.GetBlockHash(i);
                    if (!globalTasks.ContainsKey(hash))
                    {
                        hash = Blockchain.Singleton.GetBlockHash(i - 1);
                        break;
                    }
                }
                session.RemoteNode.Tell(Message.Create(MessageCommand.GetBlocks, GetBlocksPayload.Create(hash)));
            }
            else if (Blockchain.Singleton.HeaderHeight >= session.LastBlockIndex &&
                     TimeProvider.Current.UtcNow.ToTimestampMS() - PingCoolingOffPeriod >= Blockchain.Singleton.GetBlock(Blockchain.Singleton.CurrentHeaderHash)?.Timestamp)
            {
                if (session.AvailableTasks.Remove(MemPoolTaskHash))
                {
                    session.RemoteNode.Tell(Message.Create(MessageCommand.Mempool));
                }

                session.RemoteNode.Tell(Message.Create(MessageCommand.Ping, PingPayload.Create(Blockchain.Singleton.Height)));
            }
        }
		void AttachedNode_MessageReceived(Node node, IncomingMessage message)
		{
			InvPayload invPayload = message.Message.Payload as InvPayload;
			if(invPayload != null)
			{

				foreach(var hash in invPayload.Where(i => i.Type == InventoryType.MSG_TX).Select(i => i.Hash))
				{
					var tx = GetTransaction(hash, true);
					if(tx != null)
						tx.State = BroadcastState.Accepted;
					Transaction unused;
					if(_BroadcastHub.BroadcastedTransaction.TryRemove(hash, out unused))
					{
						_BroadcastHub.OnTransactionBroadcasted(tx.Transaction);
					}
				}
			}
			RejectPayload reject = message.Message.Payload as RejectPayload;
			if(reject != null && reject.Message == "tx")
			{
				var tx = GetTransaction(reject.Hash, true);
				if(tx != null)
					tx.State = BroadcastState.Rejected;
				Transaction tx2;
				if(_BroadcastHub.BroadcastedTransaction.TryRemove(reject.Hash, out tx2))
				{
					_BroadcastHub.OnTransactionRejected(tx2, reject);
				}

			}

			GetDataPayload getData = message.Message.Payload as GetDataPayload;
			if(getData != null)
			{
				foreach(var inventory in getData.Inventory.Where(i => i.Type == InventoryType.MSG_TX))
				{
					var tx = GetTransaction(inventory.Hash, false);
					if(tx != null)
					{
						tx.State = BroadcastState.Broadcasted;
						var ping = new PingPayload();
						tx.PingValue = ping.Nonce;
						_PingToTransaction.TryAdd(tx.PingValue, tx);
						node.SendMessageAsync(new TxPayload(tx.Transaction));
						node.SendMessageAsync(ping);
					}
				}
			}

			PongPayload pong = message.Message.Payload as PongPayload;
			if(pong != null)
			{
				var tx = GetTransaction(pong.Nonce, true);
				if(tx != null)
				{
					tx.State = BroadcastState.Accepted;
					Transaction unused;
					if(_BroadcastHub.BroadcastedTransaction.TryRemove(tx.Transaction.GetHash(), out unused))
					{
						_BroadcastHub.OnTransactionBroadcasted(tx.Transaction);
					}
				}
			}
		}
Esempio n. 18
0
		void Ping(object unused)
		{
			if(Monitor.TryEnter(cs))
			{
				try
				{
					var node = AttachedNode;
					if(node == null)
						return;
					if(!PingVersion())
						return;
					if(node.State != NodeState.HandShaked)
						return;
					if(_CurrentPing != null)
						return;
					_CurrentPing = new PingPayload();
					_DateSent = DateTimeOffset.UtcNow;
					node.SendMessageAsync(_CurrentPing);
					_PingTimeoutTimer = new Timer(PingTimeout, _CurrentPing, (int)TimeoutInterval.TotalMilliseconds, Timeout.Infinite);
				}
				finally
				{
					Monitor.Exit(cs);
				}
			}
		}
Esempio n. 19
0
 private void RequestTasks(TaskSession session)
 {
     if (!_expiredTimes.TryGetValue(session.RemoteNode.Path, out var expireTime) || expireTime < DateTime.UtcNow)
     {
         session.RemoteNode.Tell(Message.Create("ping", PingPayload.Create(Blockchain.Singleton.Height)));
         _expiredTimes[session.RemoteNode.Path] = DateTime.UtcNow.AddSeconds(PingCoolingOffPeriod);
     }
     if (session.HasTask)
     {
         return;
     }
     if (session.AvailableTasks.Count > 0)
     {
         session.AvailableTasks.Remove(knownHashes);
         session.AvailableTasks.RemoveWhere(p => Blockchain.Singleton.ContainsBlock(p));
         HashSet <UInt256> hashes = new HashSet <UInt256>(session.AvailableTasks);
         if (hashes.Count > 0)
         {
             foreach (UInt256 hash in hashes.ToArray())
             {
                 if (!IncrementGlobalTask(hash))
                 {
                     hashes.Remove(hash);
                 }
             }
             session.AvailableTasks.Remove(hashes);
             foreach (UInt256 hash in hashes)
             {
                 session.Tasks[hash] = DateTime.UtcNow;
             }
             foreach (InvPayload group in InvPayload.CreateGroup(InventoryType.Block, hashes.ToArray()))
             {
                 session.RemoteNode.Tell(Message.Create("getdata", group));
             }
             return;
         }
     }
     if ((!HasHeaderTask || globalTasks[HeaderTaskHash] < MaxConncurrentTasks) && Blockchain.Singleton.HeaderHeight < session.LastBlockIndex)
     {
         session.Tasks[HeaderTaskHash] = DateTime.UtcNow;
         IncrementGlobalTask(HeaderTaskHash);
         session.RemoteNode.Tell(Message.Create("getheaders", GetBlocksPayload.Create(Blockchain.Singleton.CurrentHeaderHash)));
     }
     else if (Blockchain.Singleton.Height < session.LastBlockIndex)
     {
         UInt256 hash = Blockchain.Singleton.CurrentBlockHash;
         for (uint i = Blockchain.Singleton.Height + 1; i <= Blockchain.Singleton.HeaderHeight; i++)
         {
             hash = Blockchain.Singleton.GetBlockHash(i);
             if (!globalTasks.ContainsKey(hash))
             {
                 hash = Blockchain.Singleton.GetBlockHash(i - 1);
                 break;
             }
         }
         session.RemoteNode.Tell(Message.Create("getblocks", GetBlocksPayload.Create(hash)));
     }
     if (!HasStateRootTask)
     {
         if (Blockchain.Singleton.ExpectStateRootIndex < Blockchain.Singleton.Height)
         {
             var state_root_state = Blockchain.Singleton.GetStateRoot(Blockchain.Singleton.ExpectStateRootIndex);
             if (state_root_state is null || state_root_state.Flag == StateRootVerifyFlag.Invalid)
             {
                 return;
             }
             var start_index = Blockchain.Singleton.ExpectStateRootIndex;
             var count       = Math.Min(Blockchain.Singleton.Height - start_index, StateRootsPayload.MaxStateRootsCount);
             StateRootSyncTime = DateTime.UtcNow;
             IncrementGlobalTask(StateRootTaskHash);
             system.LocalNode.Tell(Message.Create("getroots", GetStateRootsPayload.Create(start_index, count)));
         }
     }
 }
Esempio n. 20
0
        void AttachedNode_MessageReceived(Node node, IncomingMessage message)
        {
            if (message.Message.Payload is InvPayload invPayload)
            {
                foreach (uint256 hash in invPayload.Where(i => i.Type == InventoryType.MSG_TX).Select(i => i.Hash))
                {
                    TransactionBroadcast tx = GetTransaction(hash, true);
                    if (tx != null)
                    {
                        tx.State = BroadcastState.Accepted;
                    }

                    Transaction unused;
                    if (this.BroadcastHub.BroadcastedTransaction.TryRemove(hash, out unused))
                    {
                        this.BroadcastHub.OnTransactionBroadcasted(tx.Transaction);
                    }
                }
            }

            if ((message.Message.Payload is RejectPayload reject) && (reject.Message == "tx"))
            {
                TransactionBroadcast tx = GetTransaction(reject.Hash, true);
                if (tx != null)
                {
                    tx.State = BroadcastState.Rejected;
                }

                Transaction tx2;
                if (this.BroadcastHub.BroadcastedTransaction.TryRemove(reject.Hash, out tx2))
                {
                    this.BroadcastHub.OnTransactionRejected(tx2, reject);
                }
            }

            if (message.Message.Payload is GetDataPayload getData)
            {
                foreach (InventoryVector inventory in getData.Inventory.Where(i => i.Type == InventoryType.MSG_TX))
                {
                    TransactionBroadcast tx = GetTransaction(inventory.Hash, false);
                    if (tx != null)
                    {
                        tx.State = BroadcastState.Broadcasted;
                        var ping = new PingPayload();
                        tx.PingValue = ping.Nonce;
                        this.pingToTransaction.TryAdd(tx.PingValue, tx);
                        node.SendMessageAsync(new TxPayload(tx.Transaction));
                        node.SendMessageAsync(ping);
                    }
                }
            }

            if (message.Message.Payload is PongPayload pong)
            {
                TransactionBroadcast tx = GetTransaction(pong.Nonce, true);
                if (tx != null)
                {
                    tx.State = BroadcastState.Accepted;
                    Transaction unused;
                    if (this.BroadcastHub.BroadcastedTransaction.TryRemove(tx.Transaction.GetHash(), out unused))
                    {
                        this.BroadcastHub.OnTransactionBroadcasted(tx.Transaction);
                    }
                }
            }
        }
Esempio n. 21
0
		private void ClearCurrentPing()
		{
			lock(cs)
			{
				_CurrentPing = null;
				_DateSent = default(DateTimeOffset);
				var timeout = _PingTimeoutTimer;
				if(timeout != null)
				{
					timeout.Dispose();
					_PingTimeoutTimer = null;
				}
			}
		}
Esempio n. 22
0
 private void OnPongMessageReceived(PingPayload payload)
 {
     Context.Parent.Tell(payload);
 }
Esempio n. 23
0
 private void OnPingMessageReceived(PingPayload payload)
 {
     Context.Parent.Tell(payload);
     Context.Parent.Tell(Message.Create(MessageCommand.Pong, PingPayload.Create(Blockchain.Singleton.Height, payload.Nonce)));
 }
        /// <inheritdoc/>
        public Message[] GetReply(Message msg)
        {
            if (!Enum.TryParse(Encoding.ASCII.GetString(msg.PayloadName.TrimEnd()), ignoreCase: true, out PayloadType plt))
            {
                // Undefined payload type
                nodeStatus.AddSmallViolation();
            }
            else
            {
                if (nodeStatus.HandShake != HandShakeState.Finished)
                {
                    if (plt == PayloadType.Verack)
                    {
                        var verack = new VerackPayload();
                        if (!verack.TryDeserialize(new FastStreamReader(msg.PayloadData), out _))
                        {
                            nodeStatus.AddSmallViolation();
                        }
                        else if (nodeStatus.HandShake == HandShakeState.None ||
                                 nodeStatus.HandShake == HandShakeState.Finished ||
                                 nodeStatus.HandShake == HandShakeState.SentAndConfirmed)
                        {
                            nodeStatus.AddMediumViolation();
                        }
                        else if (nodeStatus.HandShake == HandShakeState.ReceivedAndReplied ||
                                 nodeStatus.HandShake == HandShakeState.SentAndReceived)
                        {
                            nodeStatus.HandShake = HandShakeState.Finished;
                        }
                        else if (nodeStatus.HandShake == HandShakeState.Sent)
                        {
                            nodeStatus.HandShake = HandShakeState.SentAndConfirmed;
                        }
                    }
                    else if (plt == PayloadType.Version)
                    {
                        var version = new VersionPayload();
                        if (!version.TryDeserialize(new FastStreamReader(msg.PayloadData), out _))
                        {
                            nodeStatus.AddSmallViolation();
                        }
                        else if (nodeStatus.HandShake == HandShakeState.None)
                        {
                            nodeStatus.HandShake = HandShakeState.ReceivedAndReplied;
                            return(new Message[2]
                            {
                                new Message(new VerackPayload(), settings.Network),
                                GetVersionMsg(version.TransmittingNodeNetworkAddress)
                            });
                        }
                        else if (nodeStatus.HandShake == HandShakeState.Sent)
                        {
                            nodeStatus.HandShake = HandShakeState.SentAndReceived;
                            return(new Message[1]
                            {
                                new Message(new VerackPayload(), settings.Network)
                            });
                        }
                        else if (nodeStatus.HandShake == HandShakeState.SentAndConfirmed)
                        {
                            nodeStatus.HandShake = HandShakeState.Finished;
                            return(new Message[1]
                            {
                                new Message(new VerackPayload(), settings.Network)
                            });
                        }
                        else if (nodeStatus.HandShake == HandShakeState.ReceivedAndReplied ||
                                 nodeStatus.HandShake == HandShakeState.SentAndReceived ||
                                 nodeStatus.HandShake == HandShakeState.Finished)
                        {
                            nodeStatus.AddMediumViolation();
                        }
                    }
                    else
                    {
                        // HandShake is not complete but the other node is sending other types of messages
                        nodeStatus.AddMediumViolation();
                    }
                }
                else
                {
                    switch (plt)
                    {
                    case PayloadType.Addr:
                        break;

                    case PayloadType.Alert:
                        // Alert messages are ignored
                        break;

                    case PayloadType.Block:
                        break;

                    case PayloadType.BlockTxn:
                        break;

                    case PayloadType.CmpctBlock:
                        break;

                    case PayloadType.FeeFilter:
                        break;

                    case PayloadType.FilterAdd:
                        break;

                    case PayloadType.FilterClear:
                        break;

                    case PayloadType.FilterLoad:
                        break;

                    case PayloadType.GetAddr:
                        break;

                    case PayloadType.GetBlocks:
                        break;

                    case PayloadType.GetBlockTxn:
                        break;

                    case PayloadType.GetData:
                        break;

                    case PayloadType.GetHeaders:
                        break;

                    case PayloadType.Headers:
                        break;

                    case PayloadType.Inv:
                        break;

                    case PayloadType.MemPool:
                        break;

                    case PayloadType.MerkleBlock:
                        break;

                    case PayloadType.NotFound:
                        break;

                    case PayloadType.Ping:
                        var ping = new PingPayload();
                        if (!ping.TryDeserialize(new FastStreamReader(msg.PayloadData), out _))
                        {
                            nodeStatus.AddSmallViolation();
                            break;
                        }
                        return(new Message[1] {
                            new Message(new PongPayload(ping.Nonce), settings.Network)
                        });

                    case PayloadType.Pong:
                        var pong = new PongPayload();
                        if (!pong.TryDeserialize(new FastStreamReader(msg.PayloadData), out _))
                        {
                            nodeStatus.AddSmallViolation();
                            break;
                        }
                        break;

                    case PayloadType.Reject:
                        // Reject messages are ignored
                        break;

                    case PayloadType.SendCmpct:
                        break;

                    case PayloadType.SendHeaders:
                        break;

                    case PayloadType.Tx:
                        break;

                    case PayloadType.Verack:
                    case PayloadType.Version:
                        nodeStatus.AddMediumViolation();
                        break;

                    default:
                        break;
                    }
                }
            }

            nodeStatus.UpdateTime();
            return(null);
        }
        void AttachedNode_MessageReceived(Node node, IncomingMessage message)
        {
            InvPayload invPayload = message.Message.Payload as InvPayload;

            if (invPayload != null)
            {
                foreach (var hash in invPayload.Where(i => i.Type == InventoryType.MSG_TX).Select(i => i.Hash))
                {
                    var tx = GetTransaction(hash, true);
                    if (tx != null)
                    {
                        tx.State = BroadcastState.Accepted;
                    }
                    Transaction unused;
                    if (_BroadcastHub.BroadcastedTransaction.TryRemove(hash, out unused))
                    {
                        _BroadcastHub.OnTransactionBroadcasted(tx.Transaction);
                    }
                }
            }
            RejectPayload reject = message.Message.Payload as RejectPayload;

            if (reject != null && reject.Message == "tx")
            {
                var tx = GetTransaction(reject.Hash, true);
                if (tx != null)
                {
                    tx.State = BroadcastState.Rejected;
                }
                Transaction tx2;
                if (_BroadcastHub.BroadcastedTransaction.TryRemove(reject.Hash, out tx2))
                {
                    _BroadcastHub.OnTransactionRejected(tx2, reject);
                }
            }

            GetDataPayload getData = message.Message.Payload as GetDataPayload;

            if (getData != null)
            {
                foreach (var inventory in getData.Inventory.Where(i => i.Type == InventoryType.MSG_TX))
                {
                    var tx = GetTransaction(inventory.Hash, false);
                    if (tx != null)
                    {
                        tx.State = BroadcastState.Broadcasted;
                        var ping = new PingPayload();
                        tx.PingValue = ping.Nonce;
                        _PingToTransaction.TryAdd(tx.PingValue, tx);
                        node.SendMessageAsync(new TxPayload(tx.Transaction));
                        node.SendMessageAsync(ping);
                    }
                }
            }

            PongPayload pong = message.Message.Payload as PongPayload;

            if (pong != null)
            {
                var tx = GetTransaction(pong.Nonce, true);
                if (tx != null)
                {
                    tx.State = BroadcastState.Accepted;
                    Transaction unused;
                    if (_BroadcastHub.BroadcastedTransaction.TryRemove(tx.Transaction.GetHash(), out unused))
                    {
                        _BroadcastHub.OnTransactionBroadcasted(tx.Transaction);
                    }
                }
            }
        }
Esempio n. 26
0
 public void OnGet()
 {
     Payload = MinecraftServerConnection.Instance.GetLatest();
 }
Esempio n. 27
0
        internal void ReadPacket(byte[] receivedData)
        {
            IsValidPacket = false;
            BufferedData  = receivedData;
            // TODO READ PACKET HERE <---------->

            var packetSize = ReadVarInt();
            var packetID   = ReadVarInt();

            Console.WriteLine("Reading packet...");
            Console.WriteLine("Packet: " + packetID.ToString("X2") + " Size: " + packetSize);

            switch (packetID)
            {
            case 0:
                Console.WriteLine("Handshake-Packet!");

                var    protocol  = ReadVarInt();
                string host      = ReadString();
                ushort port      = ReadUShort();
                var    nextState = ReadVarInt();

                Console.WriteLine("======= Client Handshake =======");
                Console.WriteLine("Protocol: " + protocol);
                Console.WriteLine("Host: " + host);
                Console.WriteLine("Port: " + port);
                Console.WriteLine("State: " + nextState);
                Console.WriteLine("================================");

                _bffr.Clear();
                _bffr = receivedData.ToList();
                SetDataSize(receivedData.Length);
                IsValidPacket = true;
                currentState  = nextState;

                break;

            case 1:
                Console.WriteLine("Ping-Packet");
                break;

            case 122:
                Console.WriteLine("Request - Packet");
                _bffr.Clear();
                // status request
                Console.WriteLine("STATUS REQUEST");
                Console.WriteLine("Building Handshake-Response...");
                PingPayload    pingPayload    = new PingPayload();
                VersionPayload versionPayload = new VersionPayload();
                versionPayload.name        = "1.17.1";
                versionPayload.protocol    = 756;
                pingPayload.versionPayload = versionPayload;

                PlayerPayload playerPayload = new PlayerPayload();
                playerPayload.max         = -1;
                playerPayload.online      = 0;
                playerPayload.sample      = new List <Player>();
                pingPayload.playerPayload = playerPayload;

                DescriptionPayload descriptionPayload = new DescriptionPayload();
                descriptionPayload.text        = "BambooCraft DEV Server!";
                pingPayload.descriptionPayload = descriptionPayload;

                pingPayload.favicon = "data:image/png;base64,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";

                string json       = JsonConvert.SerializeObject(pingPayload);
                byte[] packetData = Encoding.UTF8.GetBytes(json);

                WriteInt(0);
                WriteVarInt(packetData.Length);
                WriteString(json);
                SetDataSize(packetData.ToArray().Length);
                IsValidPacket = true;
                break;
            }
        }
Esempio n. 28
0
 private void OnPing(PingPayload payload)
 {
     SendMessage(Message.Create(MessageType.Pong, PongPayload.Create(blockchain.Height, payload.Timestamp)));
 }