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 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 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));
}
//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);
}
}
/// <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();
}
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;
}
}
// 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);
}
}
private void OnServiceLost(object sender, ResonanceDiscoveredServiceEventArgs <ResonanceSignalRDiscoveredService <DemoServiceInformation>, DemoServiceInformation> e)
{
InvokeUI(() =>
{
ConnectedClients.Remove(e.DiscoveredService.DiscoveryInfo);
});
}
/// <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);
}
}
}
}
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);
}
}
/// <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);
}
}
private void OnSessionTerminated(SessionInfo sessionInfo)
{
Application.Current.Dispatcher.Invoke(() =>
{
var displayData = ConnectedClients.First(dd => dd.SessionId == sessionInfo.SessionId.ToString());
ConnectedClients.Remove(displayData);
});
}
/// <summary>
/// Remove a client.
/// </summary>
/// <param name="clientAddress">The target client's mac address.</param>
public void RemoveClient(string clientAddress)
{
lock (ConnectedClients)
{
ConnectedClients.Remove(ConnectedClients.First(c => c.MacAddress == clientAddress));
}
// Keep the pending messages for this client. If it connects again, we want to be able to send the missing messages.
}
private static void Disconnect(SocketClient client)
{
ConnectedClients.Remove(client.SocketId);
ChatsClientMapping.Remove(client.SocketId);
foreach (var chat in Chats)
{
chat.Value.Remove(client);
}
}
/// <summary>
/// Client disconnected from the server
/// </summary>
/// <param name="DisconnectedClient">The client that has been disconnected</param>
protected override void ClientDisconnected(ClientModel DisconnectedClient)
{
// Jump on the dispatcher thread
var uiContext = SynchronizationContext.Current;
uiContext.Send(x => ConnectedClients.Remove(DisconnectedClient), null);
OnClientDisconnected(DisconnectedClient);
}
protected override async void ReceiveCallback(IAsyncResult result)
{
var state = (ClientMetadata)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))
{
RaiseClientDisconnected(state);
lock (ConnectedClients)
{
ConnectedClients.Remove(state.Id);
}
}
//Else start receiving and handle the message.
else
{
var receive = state.Listener.EndReceive(result);
if (state.UnhandledBytes != null && state.UnhandledBytes.Length > 0)
{
receive += state.UnhandledBytes.Length;
state.UnhandledBytes = null;
}
//Does header check
if (state.Flag == 0)
{
if (state.SimpleMessage == null)
{
state.SimpleMessage = new SimpleMessage(state, this, Debug);
}
await ParallelQueue.Enqueue(() => state.SimpleMessage.ReadBytesAndBuildMessage(receive));
}
else if (receive > 0)
{
await ParallelQueue.Enqueue(() => state.SimpleMessage.ReadBytesAndBuildMessage(receive));
}
Receive(state, state.Buffer.Length);
}
}
catch (Exception ex)
{
state.Reset();
RaiseErrorThrown(ex);
RaiseLog(ex);
RaiseLog("Error handling message from client with guid : " + state.Guid + ".");
Receive(state, state.Buffer.Length);
}
}
public void Disconnect(Client client)
{
client.NetworkStream.Write("disconnect");
client.TcpClient.Client.Shutdown(SocketShutdown.Both);
client.NetworkStream.Close();
client.TcpClient.Close();
ConnectedClients.Remove(client);
ClientDisconnected?.Invoke(this, new ConnectionEventArgs(client));
}
/// <summary>
/// Disconnects a client node from this server
/// </summary>
/// <param name="client"></param>
public void DisconnectNode(INetworkNode client)
{
if (ConnectedClients.ContainsKey(client))
{
if (client.Socket != null && client.Socket.Connected)
{
client.Socket.Disconnect(false);
ConnectedClients[client].Abort();
}
ConnectedClients.Remove(client);
}
}
private void OnClientDisconnected(SocketClientDisconnectedArgs args)
{
Console.WriteLine($"Client Disconnected, clientRemoteEndPoint : {args.DisconnectedSocketRemoteEndPoint}");
lock (ConnectedClients)
{
if (ConnectedClients.Contains(args.DisconnectedClient))
{
ConnectedClients.Remove(args.DisconnectedClient);
}
}
ClientDisconnected?.Invoke(args);
}
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);
}
}
private void closeConnection(RServer server)
{
try
{
ConnectedClients.Remove(getOthIdOfClient(server)); //UNREGISTER CLIENT
unRegisterPort(server.ServerPort); //UNREGISTER CLIENT PORT
try { server.DetachClient(); }
catch (Exception) { }
try { server.StopListening(); }
catch (Exception) { }
}
catch (Exception) { }
}
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 async Task HandleClientAsync(TcpClient client)
{
//TODO
while (client.Connected)
{
string data = await ReadData(client);
if (data != null)
{
HandleData(data, client);
}
}
await NotifyClientsOfUserLeft(client);
ConnectedClients.Remove(client);
ClientIDs.Remove(client);
}
private void WatchClients()
{
while (Listen)
{
Thread.Sleep(new TimeSpan(0, 1, 0)); //check the servers every 1 minute
ConnectedClients.AsParallel().ForAll(o => {
try {
if (o.TcpClient?.Client != null && o.TcpClient.Client.Connected)
{
/* pear to the documentation on Poll:
* When passing SelectMode.SelectRead as a parameter to the Poll method it will return
* -either- true if Socket.Listen(Int32) has been called and a connection is pending;
* -or- true if data is available for reading;
* -or- true if the connection has been closed, reset, or terminated;
* otherwise, returns false
*/
// Detect if client disconnected
if (o.TcpClient.Client.Poll(0, SelectMode.SelectRead))
{
byte[] buff = new byte[1];
if (o.TcpClient.Client.Receive(buff, SocketFlags.Peek) == 0)
{
// Client disconnected
ConnectedClients.Remove(o);
o.TcpClient.Close();
}
}
}
else
{
ConnectedClients.Remove(o);
o.TcpClient?.Close();
}
}
catch {
ConnectedClients.Remove(o);
o.TcpClient?.Close();
}
});
Thread.Sleep(16);
}
}
/// <summary>
/// Handle the "logout" command
/// </summary>
/// <param name="response">Message object to send to the user</param>
private void HandleLogoutCommand(Message response)
{
if (_user == null)
{
response.Type = MessageType.Error;
response.Content = "Cannot log out: you are not logged in.";
return;
}
// Remove user from list of connected clients
ConnectedClients.Remove(_user);
_user.LastSeenAt = DateTime.UtcNow;
UserService.Update(_user.Id, _user);
_user = null;
response.Type = MessageType.Info;
response.Content = "Logged out.";
}
/// <summary>
/// Sends the next instruction from the outgoing-queue.
/// </summary>
protected override void AsyncInstructionSendNext()
{
base.AsyncInstructionSendNext();
if (!HandlerData.HaltActive)
{
try
{
if ((HandlerData.OutgoingInstructions[0].Receiver as NetComCData).Authenticated ||
HandlerData.OutgoingInstructions[0].GetType() != typeof(InstructionLibraryEssentials.KeyExchangeServer2Client) ||
HandlerData.OutgoingInstructions[0].GetType() != typeof(InstructionLibraryEssentials.AuthenticationServer2Client))
{
Socket current = HandlerData.OutgoingInstructions[0]?.Receiver.LocalSocket;
byte[] data;
data = Encoding.UTF8.GetBytes(HandlerData.OutgoingInstructions[0].Encode());
try
{
current.Send(data);
}
catch (Exception)
{
Handler.Debug("Client disconnected > Connection lost. (101)", DebugType.Warning);
current.Close();
UserGroups.Disconnect(current);
ConnectedClients.Remove(current);
return;
}
Handler.Debug($"Sent Message to {HandlerData.OutgoingInstructions[0].Receiver.ToString()}.", DebugType.Info);
Handler.Debug(HandlerData.OutgoingInstructions[0].ToString(), DebugType.Info);
HandlerData.OutgoingInstructions.RemoveAt(0);
}
else
{
Handler.Debug($"Could not send Message to {HandlerData.OutgoingInstructions[0].Receiver.ToString()}. Authentication not valid.", DebugType.Error);
Handler.Debug($"Sending Authentication-Reminder...", DebugType.Info);
// Queues a authentication-reminder
Send(new InstructionLibraryEssentials.AuthenticationReminder(this, HandlerData.OutgoingInstructions[0].Receiver));
// moves the current instruction to the back
HandlerData.OutgoingInstructions.Add(HandlerData.OutgoingInstructions[0].Clone());
HandlerData.OutgoingInstructions.RemoveAt(0);
}
}
catch (Exception ex)
{
Handler.Debug("Halting (08)", DebugType.Warning);
if (HandlerData.ShowExceptions)
{
Handler.Debug($"({ex.GetType().Name}) {ex.Message}", DebugType.Exception);
}
if (HandlerData.TryRestartOnCrash)
{
HaltAllThreads();
}
}
}
else
{
Handler.Debug("Could not send message. Server is in halt-mode. Waiting for 5 seconds...", DebugType.Error);
Thread.Sleep(5000);
}
}
/// <summary>
/// Gets called when a message is received.
/// </summary>
/// <param name="AR">IAsyncResult</param>
private void ReceiveCallback(IAsyncResult AR)
{
try
{
Socket current = (Socket)AR.AsyncState;
int received;
try
{
received = current.EndReceive(AR);
}
catch (SocketException)
{
Handler.Debug("Client disconnected > Connection lost. (102)", DebugType.Warning);
// Don't shutdown because the socket may be disposed and its disconnected anyway.
current.Close();
UserGroups.Disconnect(current);
ConnectedClients.Remove(current);
return;
}
byte[] recBuf = new byte[received];
Array.Copy(buffer, recBuf, received);
string text = Encoding.UTF8.GetString(recBuf);
Console.ForegroundColor = ConsoleColor.Cyan;
//Debug("Received message: " + text);
Handler.Debug("Received message.", DebugType.Info);
Console.ForegroundColor = ConsoleColor.White;
InstructionBase[] instructionList = null;
try
{
instructionList = InstructionOperations.Parse(this, current, text, ConnectedClients).ToArray();
// Check for group-Addignment
foreach (InstructionBase instr in instructionList)
{
HandlerData.IncommingInstructions.Add(instr);
if (instr.GetType() != typeof(InstructionLibraryEssentials.KeyExchangeClient2Server) && !GroupAddRecords.Contains(instr.Sender.Username))
{
GroupAddRecords.Add(instr.Sender.Username);
UserGroups.TryGroupAdd(instr.Sender);
}
}
}
catch (NetComAuthenticationException ex)
{
Handler.Debug("Authentication-Error (Instruction-Parsing).", DebugType.Error);
if (HandlerData.ShowExceptions)
{
Handler.Debug($"({ex.GetType().Name}) {ex.Message}", DebugType.Exception);
}
}
catch (Exception ex)
{
Handler.Debug($"Error occured (Instruction-Parsing). ({HandlerData.LogErrorCounter})", DebugType.Error);
if (HandlerData.ShowExceptions)
{
Handler.Debug($"({ex.GetType().Name}) {ex.Message}", DebugType.Exception);
}
HandlerData.LogErrorCounter++;
}
try
{
current.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, ReceiveCallback, current);
}
catch (SocketException)
{
Handler.Debug("Client disconnected > Connection lost. (103)", DebugType.Warning);
// Don't shutdown because the socket may be disposed and its disconnected anyway.
current.Close();
UserGroups.Disconnect(current);
ConnectedClients.Remove(current);
return;
}
}
catch (Exception ex)
{
Handler.Debug("Halting (05)", DebugType.Warning);
if (HandlerData.ShowExceptions)
{
Handler.Debug($"({ex.GetType().Name}) {ex.Message}", DebugType.Exception);
}
if (HandlerData.TryRestartOnCrash)
{
HaltAllThreads();
}
}
}
protected void OnClientDisconnected(PaceClient client)
{
ConnectedClients.Remove(client);
ClientDisconnected?.Invoke(this, new ClientEventArgs(client));
}