private void getAddrMsgHandle(P2PState state) { var peers = this.p2pComponent.GetNodes(); var peer = peers.Where(p => p.IP == state.IP && p.Port == state.Port).FirstOrDefault(); if (peer != null && peer.IsConnected) { var data = new GetAddrMsg(); int index = 0; data.Deserialize(state.Command.Payload, ref index); if (data.Count <= 0 || data.Count > 100) { data.Count = 100; } var list = peers.Where(p => p.IP != state.IP || p.Port != state.Port).OrderByDescending(p => p.LastHeartbeat).Take(data.Count).ToList(); var payload = new AddrMsg(); foreach (var item in list) { payload.AddressList.Add(new AddrMsg.AddressInfo() { Ip = item.IP, Port = item.Port, Identity = item.Identity }); } var addrCommand = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.P2P.Addr, payload); this.p2pComponent.SendCommand(state.IP, state.Port, addrCommand); } }
private void sendGetTransaction(string address, int port, List <string> txHashList) { for (int i = txHashList.Count - 1; i >= 0; i--) { var hash = txHashList[i]; if (this.txsInSynchronizing.ContainsKey(hash)) { if (Time.EpochTime - this.txsInSynchronizing[hash] > 60 * 1000) { txsInSynchronizing[hash] = Time.EpochTime; } else { txHashList.RemoveAt(i); } } else { txsInSynchronizing.Add(hash, Time.EpochTime); } } var payload = new GetTxsMsg(); payload.Hashes.AddRange(txHashList); var cmd = P2PCommand.CreateCommand(CommandNames.Transaction.GetTx, payload); p2pComponent.SendCommand(address, port, cmd); }
private void receivedGetTransaction(string address, int port, GetTxsMsg msg, int nonce) { if (!GlobalParameters.IsPool) { var txList = new List <TransactionMsg>(); foreach (var hash in msg.Hashes) { var tx = this.txComponent.GetTransactionMsgByHash(hash); if (tx != null) { txList.Add(tx); } } if (txList.Count > 0) { var payload = new TxsMsg(); payload.Transactions.AddRange(txList); var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Transaction.Tx, payload); this.p2pComponent.SendCommand(address, port, cmd); } else { this.sendDataNoFoundCommand(address, port, nonce); } } }
private void receivedBlocksMessage(string address, int port, BlocksMsg msg) { foreach (var block in msg.Blocks) { this.saveBlockToDB(block); if (this.blocksInSynchronizing.ContainsKey(block.Header.Height)) { blocksInSynchronizing.Remove(block.Header.Height); } if (this.newBlocksInDownloading.Contains(block.Header.Height)) { var nodes = this.p2pComponent.GetNodes(); //Broadcast to other node foreach (var node in nodes) { if (node.IsConnected && !node.IsTrackerServer && node.IP != address) { var cmd = P2PCommand.CreateCommand(CommandNames.Block.NewBlock, msg); this.p2pComponent.SendCommand(node.IP, node.Port, cmd); } } newBlocksInDownloading.Remove(block.Header.Height); } } }
private void receivedTransactionMessage(string address, int port, TxsMsg msg) { foreach (var tx in msg.Transactions) { if (this.txsInSynchronizing.ContainsKey(tx.Hash)) { txsInSynchronizing.Remove(tx.Hash); } if (this.newTxInDownloading.Contains(tx.Hash)) { var nodes = this.p2pComponent.GetNodes(); //Broadcast to other node foreach (var node in nodes) { if (node.IsConnected && !node.IsTrackerServer && node.IP != address) { var payload = new NewTxMsg(); payload.Hash = tx.Hash; var cmd = P2PCommand.CreateCommand(CommandNames.Transaction.NewTx, payload); this.p2pComponent.SendCommand(node.IP, node.Port, cmd); } } newTxInDownloading.Remove(tx.Hash); } this.txComponent.AddTransactionToPool(tx); } }
private void receivedGetTransaction(string address, int port, GetTxsMsg msg, int nonce) { var txList = new List <TransactionMsg>(); foreach (var hash in msg.Hashes) { var tx = this.txComponent.GetTransactionMsgFromPool(hash); LogHelper.Info("Get Transaction:" + hash + ":" + tx == null ? "Not found" : "be found"); if (tx != null) { txList.Add(tx); } } if (txList.Count > 0) { var payload = new TxsMsg(); payload.Transactions.AddRange(txList); var cmd = P2PCommand.CreateCommand(CommandNames.Transaction.Tx, payload); this.p2pComponent.SendCommand(address, port, cmd); } else { this.sendDataNoFoundCommand(address, port, nonce); } }
private void getAddrMsgHandle(P2PState state) { var peer = this.Peers.Where(p => p.IP == state.IP && p.Port == state.Port).FirstOrDefault(); if (peer != null && peer.IsConnected) { var data = new GetAddrMsg(); int index = 0; data.Deserialize(state.Command.Payload, ref index); if (data.Count <= 0 || data.Count > 100) { data.Count = 100; } var list = this.Peers.Where(p => p.IP != state.IP || p.Port != state.Port).OrderByDescending(p => p.LastHeartbeat).Take(data.Count).ToList(); var payload = new AddrMsg(); foreach (var item in list) { payload.AddressList.Add(new KeyValuePair <string, int>(item.IP, item.Port)); } var addrCommand = P2PCommand.CreateCommand(CommandNames.P2P.Addr, payload); this.Send(addrCommand, state.IP, state.Port); } }
private void sendHeartbeat(string address, int port) { var msg = new HeightMsg(); msg.Height = this.LocalHeight; msg.BlockTime = this.LocalLatestBlockTime; var command = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.P2P.Heartbeat, msg); p2pComponent.SendCommand(address, port, command); }
private void sendGetHeaders(string address, int port, List <long> heightList) { var payload = new GetHeadersMsg(); payload.Heights.AddRange(heightList); var cmd = P2PCommand.CreateCommand(CommandNames.Block.GetHeaders, payload); p2pComponent.SendCommand(address, port, cmd); }
private void receivedGetHeaders(string address, int port, GetHeadersMsg msg, int nonce) { var headers = this.blockComponent.GetBlockHeaderMsgByHeights(msg.Heights); var payload = new HeadersMsg(); payload.Headers.AddRange(headers); var cmd = P2PCommand.CreateCommand(CommandNames.Block.Headers, nonce, payload); this.p2pComponent.SendCommand(address, port, cmd); }
private void sendGetBlocks(string address, int port, List <long> heightList) { if (heightList.Count > 0) { var payload = new GetBlocksMsg(); payload.Heights.AddRange(heightList); var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Block.GetBlocks, payload); p2pComponent.SendCommand(address, port, cmd); } }
private void receivedGetTransactionPool(string address, int port, int nonce) { var hashes = this.txComponent.GetAllHashesFromPool(); var payload = new TxPoolMsg(); payload.Hashes.AddRange(hashes); var cmd = P2PCommand.CreateCommand(CommandNames.Transaction.TxPool, nonce, payload); this.p2pComponent.SendCommand(address, port, cmd); }
private void receivedGetBlocks(string address, int port, GetBlocksMsg msg, int nonce) { List <BlockMsg> blocks; try { blocks = this.blockComponent.GetBlockMsgByHeights(msg.Heights); } catch (Exception ex) { LogHelper.Error("GetBlocksMsg Message is Empty"); throw; } if (blocks.Count > 0) { int maxLength = 1000 * 1024; //max 100KB; int totalLength = 0; var payload = new BlocksMsg(); foreach (var block in blocks) { totalLength += block.Serialize().Length; if (payload.Blocks.Count == 0 || totalLength <= maxLength) { payload.Blocks.Add(block); } else { break; } } try { var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Block.Blocks, nonce, payload); this.p2pComponent.SendCommand(address, port, cmd); } catch (Exception ex) { LogHelper.Error("GetBlocksMsg Result is Empty"); } } else { var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Other.NotFound, nonce, null); this.p2pComponent.SendCommand(address, port, cmd); } }
private void receivedGetHeight(string address, int port, int nonce) { var height = this.blockComponent.GetLatestHeight(); var block = this.blockComponent.GetBlockMsgByHeight(height); if (block != null) { var payload = new HeightMsg(); payload.Height = height; payload.BlockTime = block.Header.Timestamp; var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Block.Height, nonce, payload); this.p2pComponent.SendCommand(address, port, cmd); } }
private void receivedNewTransactionMessage(string address, int port, NewTxMsg msg) { if (!this.txComponent.CheckBlackTxExisted(msg.Hash) && !this.txComponent.CheckTxExisted(msg.Hash)) { if (!this.newTxInDownloading.Contains(msg.Hash)) { newTxInDownloading.Add(msg.Hash); var payload = new GetTxsMsg(); payload.Hashes.Add(msg.Hash); var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Transaction.GetTx, payload); this.p2pComponent.SendCommand(address, port, cmd); } } }
private void receivedNewBlockMessage(string address, int port, NewBlockMsg msg, int nonce) { if (this.blockComponent.GetBlockMsgByHash(msg.Header.Hash) == null) { if (!this.newBlocksInDownloading.Contains(msg.Header.Height)) { this.newBlocksInDownloading.Add(msg.Header.Height); var payload = new GetBlocksMsg(); payload.Heights.Add(msg.Header.Height); var cmd = P2PCommand.CreateCommand(CommandNames.Block.GetBlocks, nonce, payload); this.p2pComponent.SendCommand(address, port, cmd); } } }
private void receivedNewBlockMessage(string address, int port, NewBlockMsg msg, int nonce) { if (RemoteLatestHeight - LocalHeight <= 10 && msg.Header.Height - LocalHeight <= 10 && !this.tempBlockList.Any(b => b.Header.Height == msg.Header.Height) && !this.blockComponent.CheckBlockExists(msg.Header.Hash)) { if (!this.newBlocksInDownloading.Contains(msg.Header.Height) && !blockedBlockHashList.Contains(msg.Header.Hash)) { this.newBlocksInDownloading.Add(msg.Header.Height); var payload = new GetBlocksMsg(); payload.Heights.Add(msg.Header.Height); var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Block.GetBlocks, nonce, payload); this.p2pComponent.SendCommand(address, port, cmd); } } }
public void BroadcastNewBlockMessage(BlockHeaderMsg blockHeader) { var nodes = this.p2pComponent.GetNodes(); foreach (var node in nodes) { if (node.IsConnected && !node.IsTrackerServer) { var payload = new NewBlockMsg(); payload.Header = blockHeader; var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Block.NewBlock, payload); this.p2pComponent.SendCommand(node.IP, node.Port, cmd); } } }
private void pongMsgHandle(P2PState state) { var peer = this.Peers.Where(p => p.IP == state.IP && p.Port == state.Port).FirstOrDefault(); if (peer != null) { var verPayload = new VersionMsg(); verPayload.Version = Versions.EngineVersion; verPayload.Timestamp = Time.EpochTime; var versionCommand = P2PCommand.CreateCommand(CommandNames.P2P.Version, verPayload); this.Send(versionCommand, state.IP, state.Port); //peer.IsConnected = true; //peer.ConnectedTime = Time.EpochTime; //peer.LatestHeartbeat = Time.EpochTime; } }
public void BroadcastNewTransactionMessage(string txHash) { var nodes = this.p2pComponent.GetNodes(); //Broadcast to other node foreach (var node in nodes) { if (node.IsConnected && !node.IsTrackerServer) { var payload = new NewTxMsg(); payload.Hash = txHash; var cmd = P2PCommand.CreateCommand(CommandNames.Transaction.NewTx, payload); this.p2pComponent.SendCommand(node.IP, node.Port, cmd); } } }
private void receivedGetHeaders(string address, int port, GetHeadersMsg msg, int nonce) { var headers = this.blockComponent.GetBlockHeaderMsgByHeights(msg.Heights); if (headers.Count > 0) { var payload = new HeadersMsg(); payload.Headers.AddRange(headers); var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Block.Headers, nonce, payload); this.p2pComponent.SendCommand(address, port, cmd); } else { var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Other.NotFound, nonce, null); this.p2pComponent.SendCommand(address, port, cmd); } }
private void receivedGetBlocks(string address, int port, GetBlocksMsg msg, int nonce) { var blocks = this.blockComponent.GetBlockMsgByHeights(msg.Heights); if (blocks.Count > 0) { var payload = new BlocksMsg(); payload.Blocks.AddRange(blocks); var cmd = P2PCommand.CreateCommand(CommandNames.Block.Blocks, nonce, payload); this.p2pComponent.SendCommand(address, port, cmd); } else { var cmd = P2PCommand.CreateCommand(CommandNames.Other.NotFound, nonce, null); this.p2pComponent.SendCommand(address, port, cmd); } }
private void versionMsgHandle(P2PState state) { var peer = this.Peers.Where(p => p.IP == state.IP && p.Port == state.Port).FirstOrDefault(); if (peer != null) { var versionMsg = new VersionMsg(); int index = 0; versionMsg.Deserialize(state.Command.Payload, ref index); bool checkResult; if (versionMsg.Version < Versions.MinimumSupportVersion) { checkResult = false; var data = new RejectMsg(); data.ReasonCode = ErrorCode.Engine.P2P.Connection.P2P_VERSION_NOT_BE_SUPPORT_BY_REMOTE_PEER; var rejectCommand = P2PCommand.CreateCommand(CommandNames.Other.Reject, data); this.Send(rejectCommand, state.IP, state.Port); this.RemovePeer(state.IP, state.Port); } else if (Math.Abs(Time.EpochTime - versionMsg.Timestamp) > 2 * 60 * 60 * 1000) { checkResult = false; var data = new RejectMsg(); data.ReasonCode = ErrorCode.Engine.P2P.Connection.TIME_NOT_MATCH_WITH_RMOTE_PEER; var rejectCommand = P2PCommand.CreateCommand(CommandNames.Other.Reject, data); this.Send(rejectCommand, state.IP, state.Port); } else { peer.Version = versionMsg.Version; checkResult = true; } if (checkResult) { var verAckCommand = P2PCommand.CreateCommand(CommandNames.P2P.VerAck, null); this.Send(verAckCommand, state.IP, state.Port); } } }
private void sendGetTransaction(string address, int port, List <string> txHashList) { if (RemoteLatestHeight - GlobalParameters.LocalHeight > 10) { return; } for (int i = txHashList.Count - 1; i >= 0; i--) { var hash = txHashList[i]; if (this.txsInSynchronizing.ContainsKey(hash)) { if (Time.EpochTime - this.txsInSynchronizing[hash] > 60 * 1000 && !this.txComponent.CheckBlackTxExisted(hash)) { txsInSynchronizing[hash] = Time.EpochTime; } else { txHashList.RemoveAt(i); } } else { if (!this.txComponent.CheckBlackTxExisted(hash)) { txsInSynchronizing.Add(hash, Time.EpochTime); } else { txHashList.RemoveAt(i); } } } if (txHashList.Count > 0) { var payload = new GetTxsMsg(); payload.Hashes.AddRange(txHashList); var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Transaction.GetTx, payload); p2pComponent.SendCommand(address, port, cmd); } }
private void receivedNewMiningPoolMessage(P2PState state, NewMiningPoolMsg msg) { if (msg == null || state == null) { return; } if (new MiningPoolComponent().AddMiningToPool(msg.MinerInfo)) { var nodes = this.p2pComponent.GetNodes(); nodes.ForEach(peer => { if (!peer.IsTrackerServer) { var command = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.MiningPool.NewMiningPool, msg); this.p2pComponent.SendCommand(peer.IP, peer.Port, command); } }); } }
private void receivedMiningPoolsMessage(MiningPoolMsg msg) { var newMsgs = (new MiningPoolComponent()).UpdateMiningPools(msg.MinerInfos); if (newMsgs == null || !newMsgs.Any()) { return; } var nodes = this.p2pComponent.GetNodes(); nodes.ForEach(peer => { if (!peer.IsTrackerServer) { var command = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.MiningPool.MiningPools, msg); this.p2pComponent.SendCommand(peer.IP, peer.Port, command); } }); }
private void receivedGetMiningPoolsMessage(string address, int port) { var list = (new MiningPoolComponent()).GetAllMiningPools(); var payload = new MiningPoolMsg(); foreach (var item in list) { MiningMsg itemMsg = new MiningMsg(); itemMsg.Name = item.Name; itemMsg.PublicKey = item.PublicKey; itemMsg.Signature = item.Signature; payload.MinerInfos.Add(itemMsg); } var command = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.MiningPool.MiningPools, payload); this.p2pComponent.SendCommand(address, port, command); }
private void receivedBlocksMessage(string address, int port, BlocksMsg msg) { this.syncManager.CloseGetBlocksTask(address, port); foreach (var block in msg.Blocks) { try { if (!this.tempBlockList.Any(t => t.Header.Hash == block.Header.Hash) && block.Header.Hash == block.Header.GetHash() && block.Header.Height > GlobalParameters.LocalHeight) { this.tempBlockList.Add(block); } } catch { LogHelper.Error(string.Format("Error IP at {0}:{1}", address, port)); } if (this.newBlocksInDownloading.Contains(block.Header.Height)) { var nodes = this.p2pComponent.GetNodes(); var newMsg = new NewBlockMsg(); newMsg.Header = block.Header; //Broadcast to other node foreach (var node in nodes) { if (node.IsConnected && !node.IsTrackerServer && node.IP != address) { var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Block.NewBlock, newMsg); this.p2pComponent.SendCommand(node.IP, node.Port, cmd); } } newBlocksInDownloading.Remove(block.Header.Height); } } }
private void verAckMsgHandle(P2PState state) { var peer = this.Peers.Where(p => p.IP == state.IP && p.Port == state.Port).FirstOrDefault(); if (peer != null) { peer.IsConnected = true; peer.ConnectedTime = Time.EpochTime; peer.LastHeartbeat = Time.EpochTime; if (peer.IsTrackerServer) { var payload = new GetAddrMsg(); payload.Count = this.maxConnections; var command = P2PCommand.CreateCommand(CommandNames.P2P.GetAddr, payload); this.Send(command, peer.IP, peer.Port); } else { this.raiseNodeConnectionStateChanged(peer); } } }
public void SendGetHeight(string address, int port) { var cmd = P2PCommand.CreateCommand(this.Identity.ToString(), CommandNames.Block.GetHeight, null); p2pComponent.SendCommand(address, port, cmd); }