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); } } }
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}."; } }
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"); }); }
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(); }
/// <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> /// 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; } } } }
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); } }
// 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); } }
/// <summary> /// Handle the "login" command /// </summary> /// <param name="command">Command to parse and execute</param> /// <param name="response">Message object to send to the user</param> private void HandleLoginCommand(Command command, Message response) { // Try authentication var authUser = AuthenticationService.AuthenticateUser(command.Arguments[0], command.Arguments[1]); // Check if authentication succeeded if (authUser == null) { response.Type = MessageType.Error; response.Content = "Wrong credentials."; Net.SendMessage(_tcpClient.GetStream(), response); return; } // Check if a client is already connected to this account foreach (var user in ConnectedClients.Keys) { if (user.Username == authUser.Username) { response.Type = MessageType.Error; response.Content = "Another client is already connected to this account"; Net.SendMessage(_tcpClient.GetStream(), response); return; } } _user = authUser; // Add client to list of connected clients ConnectedClients.Add(_user, _tcpClient); response.Type = MessageType.Info; response.Content = $"Logged in as {_user.Username}."; Net.SendMessage(_tcpClient.GetStream(), response); // Gather unread private messages List <PrivateMessageRecord> privateMessages = MessageRecordService.GetPrivateMessages(_user); //if (privateMessages.Count == 0) return; // Build the private messages block StringBuilder sb = new StringBuilder(); sb.AppendLine($"=== You received {privateMessages.Count} private messages during your absence ==="); foreach (var message in privateMessages) { sb.AppendLine($"[From: {message.Sender}] - {message.Content}"); } sb.Append("========================================="); response.Type = MessageType.Message; response.Content = sb.ToString(); Net.SendMessage(_tcpClient.GetStream(), response); // Clear the list of unread private messages MessageRecordService.ClearPrivateMessages(_user); }
/// <summary> /// Client connected to the server /// </summary> /// <param name="NewClient">The client that has conneced</param> protected override void ClientConnected(ClientModel NewClient) { // Jump on the dispatcher thread var uiContext = SynchronizationContext.Current; uiContext.Send(x => ConnectedClients.Add(NewClient), null); OnClientConnected.Invoke(NewClient); }
private void OnNewSessionStarted(SessionInfo sessionInfo) { Application.Current.Dispatcher.Invoke(() => { ConnectedClients.Add(new ConnectedClientDisplayData(sessionInfo.SessionId.ToString(), sessionInfo.CreationTime.ToString(), sessionInfo.ClientAddress.ToString())); }); }
private void periodicActivityCheck(object myObject, EventArgs myEventArgs) { //ACCEPT CONNECTIONS Socket tempSocket = tcp.tcp_acceptConnection(); if (tempSocket != null) { Client client = new Client(); client.ConnectionSocket = tempSocket; ConnectedClients.Add(client); txt_clients.Text = ConnectedClients.Count.ToString(); } //RECIEVE MESSAGES for (int i = 0; i < ConnectedClients.Count; i++) { Messages.MESSAGE msg = tcp.receiveMessage(ConnectedClients[i].ConnectionSocket); #region MESSAGE DECODER switch (msg.msgID) { //Handle Error Message (Closed connection) case -1: ConnectedClients.RemoveAt(i); txt_clients.Text = ConnectedClients.Count.ToString(); txt_output.AppendText("Player Disconnected \n"); updatePlayersList(); break; case 0: break; //Initialise player case 1: decoder.initialiseClient(msg, ConnectedClients[i]); updatePlayersList(); decoder.updateAllPlayersInfo(); break; //Request to invite player recieved case 4: txt_output.AppendText("recieved request \n"); decoder.inviteClient(ConnectedClients[i].ClientID, msg); break; //invitation response recieved case 6: decoder.invitationResponse(msg); break; default: //pass message to appriopriate game sessession getGameSession(msg.gameSession).getMessage(msg, ConnectedClients[i].ClientID); break; } #endregion MESSAGE DECODER } }
/// <summary> /// Opens a port for receiving incoming connections from a client white-list /// </summary> /// <param name="validClients">Client white list</param> public void Listen(ISet <INetworkNode> validClients) { if (IsConnectionless) { throw new InvalidOperationException("Cannot establish a connection in a connectionless protocol"); } if (Self.Socket == null) { Self.Socket = new Socket(AddressScheme, SocketType.Stream, Protocol); } Self.Socket.Bind(new IPEndPoint(IPAddress.Any, Self.ListeningPort)); Self.Socket.Listen(int.MaxValue); while (true) { Socket newConn = null; if (ListenTimeOut <= 0) { newConn = Self.Socket.Accept(); } else { Thread listenerThread = new Thread(() => newConn = Self.Socket.Accept()); listenerThread.Start(); listenerThread.Join(ListenTimeOut); if (listenerThread.ThreadState != ThreadState.Stopped) { listenerThread.Abort(); } } if (newConn == null) { break; //timed out } else { INetworkNode client = Util.Container.CreateInstance <INetworkNode>(); client.Address = (newConn.RemoteEndPoint as IPEndPoint).Address.GetAddressBytes(); client.Socket = newConn; //check if it is a valid client if (validClients.Contains(client)) { Thread receiverThread = new Thread(new ParameterizedThreadStart(MessageListenerAction)); receiverThread.Start(client); ConnectedClients.Add(client, receiverThread); } else { //disconnect and raise an exception newConn.Disconnect(false); throw new SecurityException($"An unauthorized address: {(newConn.RemoteEndPoint as IPEndPoint).Address} tried to connect to server"); } } } }
private void ConnectionStateChangedCallback(IEnumerable <string> connectedClients) { ConnectedClients.Clear(); foreach (var connectedClient in connectedClients) { ConnectedClients.Add(new ListViewItemViewModel { Text = string.Format("Client connected from IP: {0}", connectedClient) }); } OnPropertyChanged("ConnectedClients"); }
public static bool AddClient(Client client) { if (!ConnectedClients.Any(tmp_client => tmp_client.ip == client.ip)) { ConnectedClients.Add(client); return(true); } else { return(false); } }
private void OnNotifyAvailableClientsRequest(IResonanceTransporter transporter, ResonanceMessage <NotifyAvailableClientsRequest> request) { InvokeUI(() => { ConnectedClients.Clear(); foreach (var client in request.Object.Clients) { ConnectedClients.Add(client); } }); }
protected override void OnClientConnect(IAsyncResult result) { if (Token.IsCancellationRequested) { return; } CanAcceptConnections.Set(); try { ISocketState state; lock (ConnectedClients) { var id = !ConnectedClients.Any() ? 1 : ConnectedClients.Keys.Max() + 1; state = new SocketState(((Socket)result.AsyncState).EndAccept(result), id); //If the server shouldn't accept the IP do nothing. if (!IsConnectionAllowed(state)) { return; } var client = ConnectedClients.FirstOrDefault(x => x.Value == state); if (client.Value == state) { id = client.Key; ConnectedClients.Remove(id); ConnectedClients.Add(id, state); } else { ConnectedClients.Add(id, state); } ClientConnectedInvoke(id, state); } StartReceiving(state); } catch (ObjectDisposedException ode) { InvokeErrorThrown(ode); } catch (SocketException se) { this.InvokeErrorThrown(se); } }
public static void HandleNewClient(SocketClient client, string connectToChat) { ConnectedClients.Add(client.SocketId, client); if (!Chats.ContainsKey(connectToChat)) { Chats.Add(connectToChat, new List <SocketClient>()); } Chats[connectToChat].Add(client); ChatsClientMapping.Add(client.SocketId, connectToChat); connectToChat = connectToChat.Split().First(); client.SendPacketIntoSocket($"Now you in {connectToChat} canal" + "\r\n"); }
public void PopulateClients() { ConnectedClients.Clear(); var filter = Builders <ClientModel> .Filter.Gte(x => x.LastSeen, DateTime.Now.AddMinutes(-5)); var onlineClients = Mongo.Get(filter).ToList(); foreach (var c in onlineClients) { ConnectedClients.Add(c); } }
public async Task ListenForClientsAsync() { while (true) { TcpClient client = await TcpListener.AcceptTcpClientAsync(); Console.WriteLine("Accepted connection from client " + client.Client.LocalEndPoint); ConnectedClients.Add(client); Guid id = Guid.NewGuid(); ClientIDs.Add(client, id); IDClients.Add(id, client); new Task(async() => await HandleClientAsync(client)).Start(); } }
protected override void OnClientConnect(IAsyncResult result) { CanAcceptConnections.Set(); try { ISocketState state; int id; lock (ConnectedClients) { id = !ConnectedClients.Any() ? 1 : ConnectedClients.Keys.Max() + 1; state = new SocketState(((Socket)result.AsyncState).EndAccept(result), id); } //If the server shouldn't accept the IP do nothing. if (!IsConnectionAllowed(state)) { return; } var stream = new NetworkStream(state.Listener); //Create SslStream state.SslStream = new SslStream(stream, false, new RemoteCertificateValidationCallback(AcceptCertificate)); Task.Run(() => { var success = Authenticate(state).Result; if (success) { lock (ConnectedClients) { ConnectedClients.Add(id, state); } ClientConnectedInvoke(id, state); StartReceiving(state); } else { throw new AuthenticationException("Unable to authenticate server."); } }, new CancellationTokenSource(10000).Token); } catch (SocketException se) { throw new Exception(se.ToString()); } }
private void OnServiceDiscovered(object sender, ResonanceDiscoveredServiceEventArgs <ResonanceSignalRDiscoveredService <DemoServiceInformation>, DemoServiceInformation> e) { if (e.DiscoveredService.DiscoveryInfo.ServiceId != _service.ServiceInformation.ServiceId) { InvokeUI(() => { ConnectedClients.Add(e.DiscoveredService.DiscoveryInfo); if (SelectedClient == null) { SelectedClient = e.DiscoveredService.DiscoveryInfo; } }); } }
public ServerViewModel(IWCFHostService hostService, IUnitOfWork db, ISettingsService settingsService, IDialogService dialogService) { this.hostService = hostService; this.db = db; this.settingsService = settingsService; this.dialogService = dialogService; Client = new ChatWCFService.Client(settingsService.Name); Port = settingsService.Port; hostService.ClientConnected += (s, e) => { DispatcherHelper.CheckBeginInvokeOnUI(() => { ConnectedClients.Add(e.Client); Notifications.Add(new Notification($"Client {e.Client.Name} connected", DateTime.Now, NotificationType.ClientConnected)); }); }; hostService.ClientDisconneced += (s, e) => { DispatcherHelper.CheckBeginInvokeOnUI(() => { var client = ConnectedClients.Where(c => c.Name == e.Client.Name).FirstOrDefault(); ConnectedClients.Remove(client); Notifications.Add(new Notification($"Client {e.Client.Name} disconnected", DateTime.Now, NotificationType.ClientDisconnected)); }); }; hostService.MessageReceived += (s, e) => { DispatcherHelper.CheckBeginInvokeOnUI(() => { Messages?.Add(new Model.Message(e.Message)); }); }; DispatcherHelper.RunAsync(async() => { var messages = (await db.Messages.GetAll()).Select(m => new Model.Message(m)); foreach (var message in messages) { Messages.Add(message); } }); Messenger.Default.Register <NotificationMessage>(this, (m) => { switch (m.Notification) { case "ServerWindowClosed": StopServer(); break; } }); }
private void PacketHandlerLoop() { while (!_stopping) { NewPacketStruct packetStruct; while (_newPackets.TryDequeue(out packetStruct)) { var stream = new BitStream(packetStruct.Data); uint type = 0; uint connectionId = 0; stream.ReadBasicHeader(ref type, ref connectionId); Console.WriteLine("[NetworkingServer] handling packet received from " + packetStruct.From.ToString() + ", connection id: " + connectionId + ", packet type: " + Convert.ToString((PacketType)type)); if (type == 0) { Console.WriteLine("[NetworkingServer] skipping invalid packet"); continue; } if (type == 1) { var par2 = stream.ReadBits(32); var version = stream.ReadBits(32); var punkbuster = stream.ReadBits(1); var unk = stream.ReadBits(32); var pass = stream.ReadString(32).Replace("\0", ""); var mod = stream.ReadString(32).Replace("\0", ""); if (mod != Config.ModName) { SendConnectDenied(packetStruct.From, 0x24); } ConnectionId++; var client = new NetworkingClient(this, packetStruct.From, ConnectionId); if (ConnectedClients.ContainsKey(packetStruct.From)) { ConnectedClients.Remove(packetStruct.From); } ConnectedClients.Add(packetStruct.From, client); SendConnectAccept(packetStruct.From, ConnectionId); continue; } if (!ConnectedClients.ContainsKey(packetStruct.From)) { continue; } ConnectedClients[packetStruct.From].Handle((PacketType)type, stream); } Thread.Sleep(1); } }
private IClient AddNotExistClientToCollection(Socket handler) { //handler.SendFile("", null, null, T) var address = handler.RemoteEndPoint.ToString(); IClient client = new Client(handler, _dataConverter); var foundClient = ConnectedClients.FirstOrDefault(p => p.Address == address); if (foundClient != null) { client = foundClient; } else { ConnectedClients.Add(client); client.SentMessage += OnSentMessage; } return(client); }
/// <summary> /// Opens a port for receiving a limited amount of incoming connections in a connection-oriented protocol /// </summary> /// <param name="maxConnections">Maximum number of connections allowed</param> public void Listen(int maxConnections) { if (IsConnectionless) { throw new InvalidOperationException("Cannot establish a connection in a connectionless protocol"); } if (Self.Socket == null) { Self.Socket = new Socket(AddressScheme, SocketType.Stream, Protocol); } Self.Socket.Bind(new IPEndPoint(IPAddress.Any, Self.ListeningPort)); Self.Socket.Listen(maxConnections); while (true) { Socket newConn = null; if (ListenTimeOut <= 0) { newConn = Self.Socket.Accept(); } else { Thread listenerThread = new Thread(() => newConn = Self.Socket.Accept()); listenerThread.Start(); listenerThread.Join(ListenTimeOut); if (listenerThread.ThreadState != ThreadState.Stopped) { listenerThread.Abort(); } } if (newConn == null) { break; //timed out } INetworkNode client = Util.Container.CreateInstance <INetworkNode>(); client.Address = (newConn.RemoteEndPoint as IPEndPoint).Address.GetAddressBytes(); client.Socket = newConn; Thread receiverThread = new Thread(new ParameterizedThreadStart(MessageListenerAction)); receiverThread.Start(client); ConnectedClients.Add(client, receiverThread); } }
private void StartServer() { if (string.IsNullOrEmpty(Client.Name)) { dialogService.ShowMessage("Server client name cannot be empty. Please enter the name in the settings."); return; } if (hostService.Start(Port, Client)) { ServerStarted = true; var clients = hostService.GetConnectedClients(); clients.ForEach((c) => ConnectedClients.Add(c)); Notifications.Add(new Notification("Server started", DateTime.Now, NotificationType.ServerStarted)); } else { dialogService.ShowMessage($"Failed to start the server. Check port availability."); Notifications.Add(new Notification("Failed to start the server. Check port availability.", DateTime.Now, NotificationType.ServerStartFailed)); } }
private void ProcessAccept(SocketAsyncEventArgs acceptEventArgs) { try { var client = new TcpSocketClient(acceptEventArgs.AcceptSocket); client.Disconnected += OnClientDisconnected; ConnectedClients.Add(client); SocketAcceptd?.Invoke(new SocketAcceptEventArgs { AcceptClient = client }); Console.WriteLine($"socket accepted, remote address:{acceptEventArgs.AcceptSocket.RemoteEndPoint}"); } catch (Exception ex) { LastException = ex; } StartAccept(acceptEventArgs); //把当前异步事件释放,等待下次连接 }
public void Connect(string _username) { Client c = new Client() { UserName = _username, Id = Context.ConnectionId }; ConnectedClients.Add(c); using (var _contextDB = new db_chatjobsityEntities()) { 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)); } }