public void ReceiveDisconnectMessage(string guestId) { _log.LogInformation($"-> SignalRHost.{nameof(ReceiveDisconnectMessage)}"); _log.LogDebug($"{nameof(guestId)} {guestId}"); _log.LogDebug($"Local UserId: {PeerInfo.Message.PeerId}"); var success = Guid.TryParse(guestId, out Guid guestGuid); if (!success || guestGuid == Guid.Empty) { _log.LogWarning($"GuestId is not a GUID"); return; } var existingGuest = ConnectedPeers.FirstOrDefault(g => g.PeerId == guestId); if (existingGuest == null) { _log.LogWarning("No existing guest found"); return; } ConnectedPeers.Remove(existingGuest); UpdateConnectedPeers(null); RaiseUpdateEvent(); _log.LogInformation($"SignalRHost.{nameof(ReceiveDisconnectMessage)} ->"); }
private void OnConnectToPeerWithTrackerMessage(PacketHeader packetHeader, Connection connection, ConnectToPeerWithTrackerMessage incomingObject) { Peer peerToConnect = allPeers.FirstOrDefault(peer => peer.Address.Equals(incomingObject.RecieverAddress)); if (peerToConnect != null) { if (!ConnectedPeers.Contains(peerToConnect)) { ConnectedPeers.Add(peerToConnect); } if (!peerToConnect.ConnectedPeers.Contains(this)) { peerToConnect.ConnectedPeers.Add(this); try { peerToConnect.Connection.SendObject(incomingObject.GetType().Name, incomingObject); } catch { peerToConnect.OnError(); } } } //если трекер не нашел пир адресат то отправляем отправителю дисконнект адресата else { var message = new PeerDisconnectMessage(incomingObject.SenderAddress); Connection.SendObject(message.GetType().Name, message); } }
private void UpdateConnectedPeers(PeerMessage message) { if (message != null) { ConnectedPeers.Add(message); } NamedGuests = ConnectedPeers .Where(g => !string.IsNullOrEmpty(g.CustomName) && g.CustomName != PeerMessage.AnonymousName && !g.IsHost).ToList(); AnonymousGuests = ConnectedPeers .Count(g => (string.IsNullOrEmpty(g.CustomName) || g.CustomName == PeerMessage.AnonymousName) && !g.IsHost); NamedHosts = ConnectedPeers .Where(g => !string.IsNullOrEmpty(g.CustomName) && g.CustomName != PeerMessage.AnonymousName && g.IsHost).ToList(); AnonymousHosts = ConnectedPeers .Count(g => (string.IsNullOrEmpty(g.CustomName) || g.CustomName == PeerMessage.AnonymousName) && g.IsHost); RaiseUpdateEvent(); foreach (var guest in ConnectedPeers) { _log.LogDebug($"{guest.CustomName}"); _log.LogDebug($"{guest.DisplayName}"); } }
private async void AcceptAsync() { while (true) { var client = await _uNetSock.AcceptTcpClientAsync(); var peer = new Peer(client, this, Settings); //Subscribe to peer events peer.OnPeerDisconnected += PeerDisconnect; peer.OnPacketReceived += (o, e) => { if (OnPacketReceived != null) { OnPacketReceived(o, e); } }; peer.InternalOnPacketReceived += InternalOnPacketReceived; peer.Processor.OnPacketSent += (o, e) => { if (OnPacketSent != null) { OnPacketSent(null, new PacketEventArgs(null, e.Packet, e.RawPacketSize)); } }; ConnectedPeers.Add(peer); if (_debug) { Debug.Print("Peer connected from: " + peer.RemoteEndPoint); } if (OnPeerConnected != null) { OnPeerConnected(null, new PeerConnectedEventArgs(peer)); } } }
/// <summary> /// Check the new connection <br/> /// If it is equal to the Nonce of local or any remote node, it'll return false, else we'll return true and update the Listener address of the connected remote node. /// </summary> /// <param name="actor">Remote node actor</param> /// <param name="node">Remote node</param> public bool AllowNewConnection(IActorRef actor, RemoteNode node) { if (node.Version.Magic != ProtocolSettings.Default.Magic) { return(false); } if (node.Version.Nonce == Nonce) { return(false); } // filter duplicate connections foreach (var other in RemoteNodes.Values) { if (other != node && other.Remote.Address.Equals(node.Remote.Address) && other.Version?.Nonce == node.Version.Nonce) { return(false); } } if (node.Remote.Port != node.ListenerTcpPort && node.ListenerTcpPort != 0) { ConnectedPeers.TryUpdate(actor, node.Listener, node.Remote); } return(true); }
/// <summary> /// Handle incoming packets related to connection setup /// </summary> /// <param name="message">The message to handle</param> /// <returns>A PacketResponse indicating if the message was consumed</returns> public PacketResponse HandlePacket(Message message) { switch (message.MessageType) { case MessageType.HeartbeatRequest: var msg = new Message(MessageType.Heartbeat, message.Sender) { DataAsString = Dns.GetHostName() }; Outbox.SendUnencryptedMessage(msg); if (!ConnectedPeers.ContainsKey(message.Sender)) { ConnectedPeers.Add(message.Sender, message.DataAsString); } return(PacketResponse.Accept); case MessageType.Heartbeat: if (!ConnectedPeers.ContainsKey(message.Sender)) { ConnectedPeers.Add(message.Sender, message.DataAsString); } return(PacketResponse.Accept); case MessageType.EncryptionPacket: SecurityManager.GetInstance().SetKeysFromPacket(message.Data); Inbox.GetInstance().UseEncryption = true; ConnectionDone = true; return(PacketResponse.AcceptAndFinish); default: return(PacketResponse.Decline); } }
public override void Shutdown() { // stop accepting new messages ShutdownWorker(); Thread.Sleep(100); if (WorkerThread != null) { WorkerThread.Abort(); } WorkerThread = null; lock (ConnectedPeers) { foreach (var p in ConnectedPeers) { p.Value.SocketConnection.Disconnect("shutdown"); p.Value.SocketConnection.Peer.FlushSendQueue(); p.Value.Handler.PeerDisconnected("Force Shutdown", p.Value); } ConnectedPeers.Clear(); } base.Shutdown(); }
/// <summary> /// Disconnects a peer from this channel /// </summary> /// <param name="id">The ID of the peer to disconnect</param> public void DisconnectPeer(int id) { var peer = ConnectedPeers.First(p => p.Identity.Id == id); peer.Disconnect(); lock (_lockObj) ConnectedPeers.Remove(peer); }
/// <summary> /// Disconnects a peer from this channel /// </summary> /// <param name="pred">The predicate used to determine what peer to disconnect</param> public void DisconnectPeer(Predicate <Peer.Peer> pred) { var peer = ConnectedPeers.First(new Func <Peer.Peer, bool>(pred)); peer.Disconnect(); lock (_lockObj) ConnectedPeers.Remove(peer); }
public void Send(IDataPacket data, int peerId) { var peer = ConnectedPeers.FirstOrDefault(p => p.Identity.Id == peerId); if (peer == null) { throw new PeerNotFoundException(); } peer.SendData(data, this, null); }
internal void OperationSend(IDataPacket data, Guid peerGuid, Guid operationGuid) { var peer = ConnectedPeers.FirstOrDefault(p => p.Identity.Guid == peerGuid); if (peer == null) { throw new PeerNotFoundException(); } peer.SendData(data, this, new SocketOperationContext(operationGuid)); }
public void Send(IDataPacket data, Predicate <Peer.Peer> pred) { var peer = ConnectedPeers.FirstOrDefault(new Func <Peer.Peer, bool>(pred)); if (peer == null) { throw new PeerNotFoundException(); } peer.SendData(data, this, null); }
/// <summary> /// Broadcast a packet to all currently connected peers /// </summary> /// <param name="packet">The packet to be broadcasted</param> public void Broadcast(IPacket packet) { ConnectedPeers.ForEach(x => { lock (_sendLock) { x.Processor.SendPacket(packet, x.NetStream).Wait(); } }); }
/// <summary> /// Sends a packet containing data to a specific peer /// </summary> /// <param name="packet">The packet to be sent</param> /// <param name="targetPeer">A peer will be filtered from connected peers based on this predicate</param> public void SendPacket(IPacket packet, Predicate <Peer> targetPeer) { var target = ConnectedPeers.FirstOrDefault(x => targetPeer(x)); if (target == null) { throw new Exception("No peer match for current predicate"); } lock (_sendLock) target.Processor.SendPacket(packet, target.NetStream).Wait(); }
/// <summary> /// Gets a hashcode of all statistics combined. /// </summary> /// <returns>A hashcode.</returns> public override int GetHashCode() { // HashCode.Combine() is not available on all frameworks. return (PeersCount.GetHashCode() ^ DuplicatePeers.GetHashCode() ^ ConnectedPeers.GetHashCode() ^ TotalReceivedPackets.GetHashCode() ^ TotalReceivedData.GetHashCode() ^ TotalSentPackets.GetHashCode() ^ TotalSentData.GetHashCode()); }
private void PeerDisconnect(object sender, PeerEventArgs e) { if (OnPeerDisconnected != null) { OnPeerDisconnected(null, e); } ConnectedPeers.Remove(e.Peer); if (_debug) { Debug.Print("Peer disconnected from: {0} with reason: {1}", e.Peer.RemoteEndPoint, ((PeerDisconnectedEventArgs)e).DisconnectReason); } }
/// <summary> /// Check the new connection <br/> /// If it is equal to the Nonce of local or any remote node, it'll return false, else we'll return true and update the Listener address of the connected remote node. /// </summary> /// <param name="actor">Remote node actor</param> /// <param name="node">Remote node</param> public bool AllowNewConnection(IActorRef actor, RemoteNode node) { if (node.Version.Magic != system.Settings.Magic) return false; if (node.Version.Nonce == Nonce) return false; // filter duplicate connections foreach (var other in RemoteNodes.Values) if (other != node && other.Remote.Address.Equals(node.Remote.Address) && other.Version?.Nonce == node.Version.Nonce) return false; if (node.Remote.Port != node.ListenerTcpPort && node.ListenerTcpPort != 0) ConnectedPeers.TryUpdate(actor, node.Listener, node.Remote); return true; }
protected virtual void Dispose(bool disposing) { if (IsDisposed) { return; } if (disposing) { OnPeerConnected = null; ConnectedPeers.ForEach(p => p.Disconnect()); IsActive = false; ChannelSocket.Close(); } IsDisposed = true; }
private void AcceptPeer(Peer.Peer newPeer) { newPeer.OnPeerSynchronized += (sender, e) => OnPeerConnected.Raise(this, new ChannelEventArgs(this, e.Peer)); newPeer.OnPeerDisconnected += (sender, e) => { e.Peer.Dispose(); lock (_lockObj) ConnectedPeers.Remove(e.Peer); }; newPeer.OnRawPacketReceived += RawPacketReceived; newPeer.OnSequenceFragmentReceived += (sender, e) => OnSequenceFragmentReceived.Raise(sender, e); lock (_lockObj) ConnectedPeers.Add(newPeer); }
private void OnToPeerMessage(PacketHeader packetHeader, Connection connection, ToPeerMessage incomingObject) { NetworkComms.Logger.Warn("Message: " + incomingObject.Message.Type.ToString()); if (Address.Equals(incomingObject.SenderAddress)) { Peer reciever = ConnectedPeers.FirstOrDefault(peer => peer.Address.Equals(incomingObject.RecieverAddress)); try { if (reciever != null && reciever.ConnectedPeers.Contains(this)) { reciever.Connection.SendObject(incomingObject.GetType().Name, incomingObject); } } catch { reciever.OnError(); } } }
public async Task ReceiveGuestMessage(string json) { _log.LogInformation($"-> SignalRHost.{nameof(ReceiveGuestMessage)}"); //_log.LogDebug(json); var messagePeer = JsonConvert.DeserializeObject <PeerMessage>(json); if (messagePeer == null || string.IsNullOrEmpty(messagePeer.PeerId)) { _log.LogWarning($"No PeerId found"); return; } _log.LogDebug($"PeerId: {messagePeer.PeerId}"); var success = Guid.TryParse(messagePeer.PeerId, out Guid peerId); if (!success || peerId == Guid.Empty) { _log.LogWarning($"PeerId is not a GUID"); return; } if (messagePeer.PeerId == PeerInfo.Message.PeerId) { _log.LogTrace($"Self announce received"); return; } var existingPeer = ConnectedPeers.FirstOrDefault(g => g.PeerId == messagePeer.PeerId); if (existingPeer == null) { _log.LogWarning("No existing guest found"); UpdateConnectedPeers(messagePeer); } else { _log.LogDebug($"Existing peer found: Old name {existingPeer.DisplayName}"); existingPeer.CustomName = messagePeer.CustomName; existingPeer.IsHost = messagePeer.IsHost; UpdateConnectedPeers(null); _log.LogDebug($"Existing guest found: New name {existingPeer.DisplayName}"); } // Refresh the clocks and the message (only when a guest registers) _log.LogDebug($"messagePeer.IsHost {messagePeer.IsHost}"); if (!messagePeer.IsHost) { if (IsAnyClockRunning) { await StartAllClocks(false); } await SendMessage(CurrentMessage.Value); } RaiseUpdateEvent(); _log.LogInformation($"SignalRHost.{nameof(ReceiveGuestMessage)} ->"); }
/// <summary> /// Broadcasts a message to all peers in this channel /// </summary> /// <param name="data">The packet to broadcast</param> public void Broadcast(IDataPacket data) { ConnectedPeers.ForEach(cp => cp.SendData(data, this, null)); }
/// <summary> /// Disconnects a peer from this channel /// </summary> /// <param name="peer">The peer to disconnect</param> public void DisconnectPeer(Peer.Peer peer) { peer.Disconnect(); lock (_lockObj) ConnectedPeers.Remove(peer); }