/// <summary> /// Löscht den verlassenen Client aus der Liste der Clients /// </summary> /// <param name="client">Der Client, zu dem die Verbindung verloren wurde</param> protected override void ConnectionLost(ClientInfo client) { Log("Client " + client.Name + " has left"); OnClientLeft(client); ConnectedClients.Remove(client.ClientID); OnClientsChanged(); }
/// <summary> /// 用Guid 找 Peer /// </summary> /// <param name="guid"></param> /// <returns></returns> public MPServerPeer GetPeerFromGuid(Guid guid) // 用機器碼 找 peer { MPServerPeer peer; ConnectedClients.TryGetValue(guid, out peer); return(peer); }
public void Listen() { ListenThread = new Thread(() => { TcpListener ServerSocket = new TcpListener(IPAddress.Any, 0); ServerSocket.Start(); ListeningPort = ((IPEndPoint)ServerSocket.LocalEndpoint).Port; SendListeningPort(ListeningPort); while (running) { TcpClient tcpClient = ServerSocket.AcceptTcpClient(); var client = new Client(tcpClient) { Username = server.Receive(1024) }; ConnectedClients.Add(client); ClientConnected?.Invoke(this, new ConnectionEventArgs(client)); StartReceive(client); } ServerSocket.Stop(); }); ListenThread.Start(); }
public Client ConnectToClient(string username) { if (IsUserConnected(username)) { var user = GetUser(username); var tcpClient = new TcpClient(); tcpClient.Connect(user.Address, user.Port); var client = new Client(tcpClient) { Username = username }; ConnectedClients.Add(client); ClientConnected?.Invoke(this, new ConnectionEventArgs(client)); SendToServer($"connectedto {username}"); StartReceive(client); return(client); } return(null); }
/// <summary> /// Handle the "register" command /// </summary> /// <param name="command">Command to parse and execute</param> /// <param name="response">Message object to send to the user</param> private void HandleRegisterCommand(Command command, Message response) { // Check if user is already authenticated if (_user != null) { response.Type = MessageType.Error; response.Content = "Cannot create accounts while logged in."; return; } // Attempt to create user _user = AuthenticationService.CreateUser(command.Arguments[0], command.Arguments[1]); if (_user == null) { response.Type = MessageType.Error; response.Content = "Credentials already in use."; } else { // Add client to list of connected clients ConnectedClients.Add(_user, _tcpClient); response.Type = MessageType.Info; response.Content = $"Account created, you are now logged in as {_user.Username}."; } }
private void _OnDataReceive(IAsyncResult ar) { ClientObject Client = ar.AsyncState as ClientObject; if (Client == null) { return; } try { int ReceivedBytesCount = Client.TcpClient.Client.EndReceive(ar); if (ReceivedBytesCount <= 0) { lock (ConnectedClients) { ConnectedClients.Remove(Client.TcpClient); _Parent.NotifyClientDisconnected(Client.TcpClient); return; } } byte[] ReceivedBytes = new byte[ReceivedBytesCount]; Array.Copy(Client.Buffer, ReceivedBytes, ReceivedBytes.Length); Client.TcpClient.GetStream().BeginRead(Client.Buffer, 0, Client.Buffer.Length, _OnDataReceive, Client); _Parent.NotifyDataReceived(ReceivedBytes, Client.TcpClient); } catch { lock (ConnectedClients) { ConnectedClients.Remove(Client.TcpClient); _Parent.NotifyClientDisconnected(Client.TcpClient); } } }
public async Task ForceHandover(Predicate <Client> predicate) { foreach (var client in ConnectedClients.Where(predicate.Invoke)) { await clientsManager.SendControlMessageToClient(GetJson(new { Action = "Handover" }), client); } }
public void UpdateGuiWithNewMessage(string message) { //switch thread to GUI thread to write to GUI // Prof: sorgt dafür, dass der Thread in der GUI ausgeführt wird //damit es gleichzeitig abläuft //(Dispatcher extra erstellen => Render (Hintergrund) und GUI Threads => aktualisieren GUI) App.Current.Dispatcher.Invoke(() => { string name = message.Split(':')[0]; if (!ConnectedClients.Contains(name)) {//not in list => add it ConnectedClients.Add(name); } if (message.Contains("@quit")) { server.DisconnectOneClient(name); // Extra: ConnectedClients.Remove(name); // Client auch aus connectedClients Liste löschen } //neue Nachricht zu Nachrichten-Collection hinzufügen Messages.Add(message); // GUI informieren, dass Nachrichtenanzahl gestiegen ist RaisePropertyChanged("MessagesCnt"); }); }
private void _OnClientConnect(IAsyncResult ar) { try { TcpClient Client = Listener.EndAcceptTcpClient(ar); if (ConnectedClients.Count >= _MaxConnections || _Parent.BannedIps.Contains(((IPEndPoint)Client.Client.RemoteEndPoint).Address.ToString())) { Console.WriteLine($"[Server]Denied {((IPEndPoint)Client.Client.RemoteEndPoint).Address.ToString()}"); Client.Close(); Listener.BeginAcceptTcpClient(_OnClientConnect, Listener); } else { ClientObject ClientObject = new ClientObject() { TcpClient = Client, Buffer = new byte[_BufferSize] }; ConnectedClients.Add(Client); _Parent.NotifyClientConnected(Client); Client.GetStream().BeginRead(ClientObject.Buffer, 0, ClientObject.Buffer.Length, _OnDataReceive, ClientObject); Listener.BeginAcceptTcpClient(_OnClientConnect, Listener); } } catch (Exception ex) { if (_Parent.IsRunning) { _Parent.NotifyOnError(ex); } } }
/// <summary> /// This is the event handler attached to every client that is connected's MessageReceive event. /// This is where it checks if a client has sent the disconnetion code, and if so, disposes of them. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void ConnectedClient_MessageReceived(object sender, MessageReceivedEventArgs e) { if (e.Message == TcpOptions.EndConnectionCode.ToString()) { ConnectedClients.Remove(sender as Client); var eventargs = new ClientToggleEventArgs { ConnectedClient = sender as Client, Time = DateTime.Now }; ClientDisconnected?.Invoke(this, eventargs); } else { foreach (var response in Responses) { var willTrigger = false; switch (response.Mode) { case ContentMode.Contains: if (e.Message.Contains(response.Content)) { willTrigger = true; } break; case ContentMode.EndsWish: if (e.Message.EndsWith(response.Content)) { willTrigger = true; } break; case ContentMode.StartsWith: if (e.Message.StartsWith(response.Content)) { willTrigger = true; } break; case ContentMode.Equals: if (e.Message == response.Content) { willTrigger = true; } break; } if (willTrigger) { response.Event?.Invoke(e); } else { MessageReceived?.Invoke(sender, e); } } } }
public void AddClient(Client client) { client.OnPacketReceive += Client_OnPacketReceive; client.OnDisconnect += Client_OnDisconnect; ConnectedClients.TryAdd(client.NetworkId, client); OnClientConnect?.Invoke(this, new ClientStateChangeArgs(client.NetworkId, client)); }
//Handles messages protected override void HandleMessage(IAsyncResult result) { var state = (SocketState)result.AsyncState; try { //Check if client is still connected. //If client is disconnected, send disconnected message //and remove from clients list if (!IsConnected(state.Id)) { ClientDisconnectedInvoke(state.Id); lock (ConnectedClients) { ConnectedClients.Remove(state.Id); } } //Else start receiving and handle the message. else { var receive = state.SslStream.EndRead(result); _mreRead.Set(); //var receive = state.Listener.EndReceive(result); if (state.Flag == 0) { state.CurrentState = new InitialHandlerState(state, null, this); } if (receive > 0) { state.CurrentState.Receive(receive); } /*When the full message has been received. */ if (state.Read == state.MessageSize) { StartReceiving(state); return; } /*Check if there still are messages to be received.*/ if (receive == state.BufferSize) { StartReceiving(state); return; } //sslstream has inconsistent buffers StartReceiving(state); } } catch (Exception ex) { state.Reset(); InvokeErrorThrown(ex); StartReceiving(state); } }
void PacketHandler(IDataPacket dataPacket, ref Data data) { switch (dataPacket.ConnectionType) { case ConnectionType.Client: Logger.Instance.Log("ConnectionType is [Client]"); var clientData = (ClientDataPacket)dataPacket; clientData.Servers = GetServers(clientData.Offset); data.TcpClient.GetStream().Write(clientData.ToBytes(), 0, Packet.MAX_BYTE_LENGTH); break; case ConnectionType.Server: Logger.Instance.Log("ConnectionType is [Server]"); var serverData = (ServerDataPacket)dataPacket; if (serverData.RemoveFromCollection) { var temp = data; Logger.Instance.Log($"Server {temp.ID} @ {serverData.IPv4} Removed from collection"); ConnectedClients.Remove(ConnectedClients.First(o => o.ID == temp.ID)); break; } data.IPv4 = serverData.IPv4; data.Name = serverData.Name; data.Port = serverData.Port; serverData.ID = data.ID; var bytes = serverData.ToBytes(); data.TcpClient.GetStream().Write(bytes, 0, bytes.Length); break; case ConnectionType.Hub: Logger.Instance.Log("ConnectionType is [Hub]"); break; } }
/// <summary> /// Returns the Packet of data sent by a TcpClient /// </summary> /// <param name="serverData">Returns the ServerData object if the packet was a ServerDataPacket</param> /// <returns>The Packet sent</returns> IDataPacket ListenForPackets(out Data data) { Logger.Instance.Log("Waiting for a connection"); var client = Listener.AcceptTcpClient(); Logger.Instance.Log("Connected"); byte[] bytes = new byte[Packet.MAX_BYTE_LENGTH]; IDataPacket packet = null; if (client.GetStream().Read(bytes, 0, bytes.Length) != 0) { packet = Packet.ToPacket(bytes); } data = new Data { TcpClient = client }; if (packet is ServerDataPacket) { var sPacket = (ServerDataPacket)packet; data = new Data(ConnectedClients.Count == 0 ? 0 : ConnectedClients.Last().ID + 1) { TcpClient = client, IPv4 = sPacket.IPv4, Name = sPacket.Name, Port = sPacket.Port }; ConnectedClients.Add(data); Logger.Instance.Log($"Server @ {data.IPv4} added to collection"); } return(packet); }
/// <summary> /// Wird aufgerufen, wenn eine neue Nachricht empfangen wurde. /// An dieser Stelle werden NUR Nachrichten, die der Verbindungshaltung dienen, verarbeitet (ID kleiner als 9) /// </summary> /// <param name="msg">Die Nachricht</param> protected override void OnSMCPMessageReceived(SMCPMessage msg) { Log("Message Received: " + msg.ToString()); if (msg.ActionID <= 9) { switch ((SMCPAction)msg.ActionID) { case SMCPAction.ASSIGN_CLIENT_ID: LocalClient.ClientID = Serializer.ConvertToObject <short>(msg.Data); SMCPMessage reply = this.CreateMessage(LocalClient, false, SMCPAction.CLIENT_INFO); SendMessage(reply); break; case SMCPAction.ONLINE_CLIENTS: ConnectedClients = Serializer.ConvertToObject <Dictionary <short, ClientInfo> >(msg.Data); if (ConnectedClients.ContainsKey(0)) { if (ConnectedClients[0].IsServer) { ConnectedClients[0].TcpClient = Server.TcpClient; Server = ConnectedClients[0]; } } OnClientsChanged(); break; } } base.OnSMCPMessageReceived(msg); }
public override Task OnDisconnected(bool stopCalled) { var disconnectedUser = ConnectedClients.FirstOrDefault(x => x.Id.Equals(Context.ConnectionId)); ConnectedClients.Remove(disconnectedUser); using (var _contextDB = new db_chatjobsityEntities()) { var _objDb_disco = new Disconnected() { UserID = disconnectedUser.UserName, Fe_Salida = System.DateTime.UtcNow.AddHours(-5) }; _contextDB.Disconnected.Add(_objDb_disco); _contextDB.SaveChanges(); var _discoUser = (from x in _contextDB.Disconnected orderby x.Fe_Salida descending select x).AsEnumerable().Take(50); var _discoUserX = (from x in _discoUser select new { UserName = x.Fe_Salida.ToString("yyyy-MM-dd HH:mm:ss") + " - " + x.UserID.ToString() }).ToList(); Clients.All.updateUsers(ConnectedClients.Count(), ConnectedClients.Select(x => x.UserName), _discoUserX.Select(x => x.UserName)); } return(base.OnDisconnected(stopCalled)); }
/// <summary> /// Send a packet to all the connected clients /// </summary> /// <param name="packet">Packet to send to everyone</param> /// <returns>Returns a task that you can wait on with a dictionary containing success per client</returns> /// <remarks>This uses more memory/processing than the very similar <see cref="SendToAllAsync"/>. Use that if you don't care about the results</remarks> /// <remarks>Even though this method is async, be sure this method is not called in parallel. /// Otherwise you can get mangled packets.</remarks> public async Task <Dictionary <ServerClient, bool> > SendToAllWithResultAsync(IPacket packet) { if (!IsRunning) { Logger.Warn("The server is not running, not sending packet"); return(null); } var bytes = packet.Serialize(); var connectedClients1 = ConnectedClients.ToArray(); var tasks = new Task <bool> [connectedClients1.Length]; for (var i = 0; i < connectedClients1.Length; i++) { Logger.Debug("Sending packet to {client}: {packet}", clients[i].EndPoint, packet); tasks[i] = SendAsync(bytes, clients[i]); } var connectedClients = connectedClients1; var result = await Task.WhenAll(tasks); return(connectedClients .Zip(result, (k, v) => new { k, v }) .ToDictionary(x => x.k, x => x.v)); }
/// <summary> /// The threaded method where the server listens for client connections. Only called from <see cref="StartClientListening"/> /// </summary> private void ListenForClients() { while (!IsDisposed) { try { var connectedTCPClient = _listener.AcceptTcpClient(); var connectedClient = new Client(connectedTCPClient); connectedClient.MessageReceived += ConnectedClient_MessageReceived; ConnectedClients.Add(connectedClient); var eventargs = new ClientToggleEventArgs { ConnectedClient = connectedClient, Time = DateTime.Now }; ClientConnected?.Invoke(this, eventargs); } catch (SocketException e) { if (e.SocketErrorCode == SocketError.Interrupted) { break; } else { throw e; } } } }
private void _botClient_OnCallbackQuery(object sender, CallbackQueryEventArgs e) { try { if (!ConnectedClients.TryGetValue(e.CallbackQuery.Message.From.Id, out TelegramClientInfo clientInfo)) { clientInfo = new TelegramClientInfo(_serverBase) { ConnectedDateTime = DateTime.Now, ClientId = Guid.NewGuid().ToString(), Message = e.CallbackQuery.Message, SignalGoBotManager = this }; _serverBase.Clients.TryAdd(clientInfo.ClientId, clientInfo); ConnectedClients.TryAdd(e.CallbackQuery.Message.From.Id, clientInfo); CurrentBotStructureInfo.OnClientConnected(clientInfo, this); } if (CustomInlineButtons.TryGetValue(e.CallbackQuery.Data, out Action <TelegramClientInfo> action)) { action?.Invoke(clientInfo); } } catch (Exception ex) { Console.WriteLine(ex); } }
public async Task ToggleStateForClients(Predicate <Client> predicate) { foreach (var client in ConnectedClients.Where(predicate.Invoke)) { if (client.TestState.State != UserTestState.UserState.OnHold && client.TestState.State != UserTestState.UserState.Testing) { continue; } if (client.TestState.State == UserTestState.UserState.Testing) { await clientsManager.SendControlMessageToClient(GetJson(new { Action = "Pause" }), client); client.TestState.State = UserTestState.UserState.OnHold; } else if (client.TestState.State == UserTestState.UserState.OnHold) { await clientsManager.SendControlMessageToClient(GetJson(new { Action = "Resume" }), client); client.TestState.State = UserTestState.UserState.Testing; } ClientStatusUpdated?.Invoke(client); } }
private void OnServiceLost(object sender, ResonanceDiscoveredServiceEventArgs <ResonanceSignalRDiscoveredService <DemoServiceInformation>, DemoServiceInformation> e) { InvokeUI(() => { ConnectedClients.Remove(e.DiscoveredService.DiscoveryInfo); }); }
// try get peer from guid. public ServerPeer TryGetPeer(Guid guid) { ServerPeer peer; ConnectedClients.TryGetValue(guid, out peer); return(peer); }
// Remove peer from guid. public void RemovePeer(Guid guid) { if (ConnectedClients.ContainsKey(guid)) { ConnectedClients.Remove(guid); } }
protected override void ReceiveCallback(IAsyncResult result) { var state = (ClientMetadata)result.AsyncState; state.MreTimeout.Set(); try { //Check if client is still connected. //If client is disconnected, send disconnected message //and remove from clients list if (!IsConnected(state.Id)) { RaiseClientDisconnected(state, DisconnectReason.Unknown); lock (ConnectedClients) { ConnectedClients.Remove(state.Id); } } //Else start receiving and handle the message. else { var receive = state.SslStream.EndRead(result); if (receive > 0) { if (state.UnhandledBytes != null && state.UnhandledBytes.Length > 0) { receive += state.UnhandledBytes.Length; state.UnhandledBytes = null; } if (state.Flag == 0) { if (state.SimpleMessage == null) { state.SimpleMessage = new SimpleMessage(state, this, Debug); } state.SimpleMessage.ReadBytesAndBuildMessage(receive); } else if (receive > 0) { state.SimpleMessage.ReadBytesAndBuildMessage(receive); } } state.MreReceiving.Set(); state.MreRead.Set(); } } catch (Exception ex) { state.Reset(); RaiseLog(ex); RaiseLog("Error handling message from client with guid : " + state.Guid + "."); state.MreReceiving.Set(); RaiseErrorThrown(ex); // Receive(state); } }
protected override void OnClientConnect(IAsyncResult result) { try { IClientMetadata state; int id; lock (ConnectedClients) { id = !ConnectedClients.Any() ? 1 : ConnectedClients.Keys.Max() + 1; state = new ClientMetadata(((Socket)result.AsyncState).EndAccept(result), id); CanAcceptConnections.Set(); ConnectedClients.Add(id, state); } //If the server shouldn't accept the IP do nothing. if (!IsConnectionAllowed(state)) { Log("A blacklisted ip tried to connect to the server: ipv4:" + state.RemoteIPv4 + " ipv6: " + state.RemoteIPv6); lock (ConnectedClients) { ConnectedClients.Remove(id); } return; } Task.Run(() => { var stream = new NetworkStream(state.Listener); //Create SslStream state.SslStream = new SslStream(stream, false, AcceptCertificate); var success = Authenticate(state).Result; if (success) { RaiseClientConnected(state); Receive(state); } else { lock (ConnectedClients) { ConnectedClients.Remove(id); } Log("Unable to authenticate server."); } }, new CancellationTokenSource(10000).Token); } catch (Exception ex) { CanAcceptConnections.Set(); RaiseLog(ex); RaiseErrorThrown(ex); } }
public void Disconnect(string Reason = "") { SocketWrapper wrapp; ConnectedClients.TryRemove(IP, out wrapp); Socket.Disconnect(false); Console.WriteLine($"[{IP}] Disconnection --> Killed Protection."); }
public async Task SyncClient(Test.TestState state, Predicate <Client> clients) { foreach (var client in ConnectedClients.Where(clients.Invoke)) { await clientsManager.SendControlMessageToClient( GetJson(new { Action = "Sync", State = client.TestState }), client); } }
// Peer's operation. public void AddConenectPeer(Guid guid, ServerPeer peer) { if (!ConnectedClients.ContainsKey(guid)) { ConnectedClients.Add(guid, peer); ServerApp.Logger.Info("[ActorManager]Add peer linked. " + guid); } }
private void OnSessionTerminated(SessionInfo sessionInfo) { Application.Current.Dispatcher.Invoke(() => { var displayData = ConnectedClients.First(dd => dd.SessionId == sessionInfo.SessionId.ToString()); ConnectedClients.Remove(displayData); }); }
/// <summary> /// 类型:方法 /// 名称:RemovePeer /// 作者:taixihuase /// 作用:删除一个客户端连接 /// 编写日期:2015/7/12 /// </summary> /// <param name="guid"></param> public void RemovePeer(Guid guid) { if (ConnectedClients.ContainsKey(guid)) { ConnectedClientsToBroadcast.Remove(ConnectedClients[guid]); ConnectedClients.Remove(guid); } }