/// <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);
}
}
