private void ClearCurrentPing() { lock (cs) { _CurrentPing = null; _DateSent = default(DateTimeOffset); var timeout = _PingTimeoutTimer; if (timeout != null) { timeout.Dispose(); _PingTimeoutTimer = null; } } }
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; } } }
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); }
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); }
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); }
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); } }
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))); } } }
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); } }
/// <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); } }
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; } } } } }
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}'"); } }
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); } } }); }
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); } } } }
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); } } }
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))); } } }
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); } } } }
private void ClearCurrentPing() { lock(cs) { _CurrentPing = null; _DateSent = default(DateTimeOffset); var timeout = _PingTimeoutTimer; if(timeout != null) { timeout.Dispose(); _PingTimeoutTimer = null; } } }
private void OnPongMessageReceived(PingPayload payload) { Context.Parent.Tell(payload); }
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); } } } }
public void OnGet() { Payload = MinecraftServerConnection.Instance.GetLatest(); }
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; } }
private void OnPing(PingPayload payload) { SendMessage(Message.Create(MessageType.Pong, PongPayload.Create(blockchain.Height, payload.Timestamp))); }