public void DisconnectHandler(Client client, DisconnectReason reason)
{
try
{
if (ClientManager.ContainsKey(client.Account.AccountId))
{
ClientManager.TryRemove(client.Account.AccountId, out ClientData _disposableCData);
Log.Info($"[({(int) reason}) {reason.ToString()}] Disconnect player '{_disposableCData.Client.Account.Name} (Account ID: {_disposableCData.Client.Account.AccountId})'.");
_disposableCData.Client.Save();
_disposableCData.Client.State = ProtocolState.Disconnected;
_disposableCData.Client.Socket.Close();
_disposableCData.Client.Dispose();
}
else
{
Log.Info($"[({(int) reason}) {reason.ToString()}] Disconnect player '{client.Account.Name} (Account ID: {client.Account.AccountId})'.");
client.Save();
client.State = ProtocolState.Disconnected;
client.Dispose();
}
}
catch (NullReferenceException) { }
}
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
var remoteAddress = this.RemoteIP + ":" + this.RemotePort;
PhotonWireApplicationBase.Instance.Logger.InboundPeerOnDisconnect(PhotonWireApplicationBase.Instance.ApplicationName, remoteAddress, this.ConnectionId, reasonCode.ToString(), reasonDetail);
PeerManager.InboundServerConnections.Remove(this);
List<Exception> exceptions = new List<Exception>();
Action<int, string>[] copy;
lock (disconnectActions)
{
if (disconnectActions.Count == 0) return;
copy = new Action<int, string>[disconnectActions.Count];
disconnectActions.CopyTo(copy);
}
foreach (var item in copy)
{
try
{
item((int)reasonCode, reasonDetail);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
if (exceptions.Count > 0)
{
throw new AggregateException(exceptions);
}
}
public void Disconnect(DisconnectReason reason, bool sendingRequired)
{
if (_udpSocket.State == SocketState.Disconnecting || _udpSocket.State == SocketState.Disconnected)
{
return;
}
Log(LogLevel.Debug, "Disconnect Reson[{0}]", reason.ToString());
if (sendingRequired)
{
_udpSocket.Disconnecting();
var buffer = ByteBufferFactory.NewBuffer();
buffer.WriteInt((int)reason);
EnqueueOutgoingCommand(new OutgoingCommand(CommandType.Disconnect, (byte)(ChannelCount - 1), buffer.ToArray()));
FlushSendQueues();
}
_udpSocket.Dispose();
if (_listener != null)
{
switch (reason)
{
case DisconnectReason.Timeout:
case DisconnectReason.ServerUserLimit:
case DisconnectReason.ServerLogic:
case DisconnectReason.QueueFull:
case DisconnectReason.InvalidConnection:
case DisconnectReason.InvalidDataFormat:
case DisconnectReason.ClientDisconnect:
case DisconnectReason.ApplicationStop:
_listener.OnStatusChanged(StatusCode.Disconnected, string.Format("Disconnected by {0}", reason));
break;
case DisconnectReason.ConnectionFailed:
_listener.OnStatusChanged(StatusCode.FailedToConnect, string.Format("Failed to connect to {0}:{1}", RemoteEndPoint.Address, RemoteEndPoint.Port));
break;
default:
_listener.OnStatusChanged(StatusCode.Disconnected, "Disconnected by unknown error");
break;
}
_listener.OnClose();
}
if (_sendAckBackgroundThread != null)
{
_sendAckBackgroundThread.Abort();
_sendAckBackgroundThread = null;
}
LogMessageRecevied = null;
_isAckThreadRunning = false;
}
public void _(string accId, Socket skt, DisconnectReason type)
{
string response = $"[{time[1]}] [{nameof(Client)}] [({(int)type}) {type.ToString()}] Disconnect\t->\tplayer id {accId} to {skt.RemoteEndPoint.ToString().Split(':')[0]}";
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(response);
Console.ResetColor();
}
public void RemoveClient(Client client, DisconnectReason reason)
{
try
{
if (Clients.ContainsKey(client.Account.AccountId))
{
Clients.TryRemove(client.Account.AccountId, out Client oldclient);
Log.Info($"[({(int)reason}) {reason.ToString()}] Disconnect player '{oldclient.Account.Name} (Account ID: {oldclient.Account.AccountId})'.");
using (oldclient)
{
oldclient.Save();
var player = oldclient.Player;
if (player != null)
{
player.Owner.LeaveWorld(player);
}
oldclient.State = ProtocolState.Disconnected;
oldclient.Socket.Close();
}
}
else
{
Log.Info($"[({(int)reason}) {reason.ToString()}] Disconnect player '{client.Account.Name} (Account ID: {client.Account.AccountId})'.");
using (client)
{
client.Save();
var player = client.Player;
if (player != null)
{
player.Owner.LeaveWorld(player);
}
client.State = ProtocolState.Disconnected;
}
}
}
catch { }
}
private void ReceiveDisconnect(BinaryReader reader)
{
DisconnectReason reason = (DisconnectReason)reader.ReadByte();
String message = reader.ReadString();
State = ServerState.Disconnected;
GameClient.ClientMessage("You were dropped from the server (" + reason.ToString() + ")\n");
}
private void DisconnectUnauthClient(NetIncomingMessage inc, UnauthenticatedClient unauthClient, DisconnectReason reason, string message)
{
inc.SenderConnection.Disconnect(reason.ToString() + "/ " + TextManager.GetServerMessage(message));
if (unauthClient.SteamID > 0)
{
Steam.SteamManager.StopAuthSession(unauthClient.SteamID);
}
if (unauthClient != null)
{
unauthenticatedClients.Remove(unauthClient);
}
}
public async ValueTask DisconnectAsync(DisconnectReason reason, string?message = null)
{
if (!Connection.IsConnected)
{
return;
}
using var writer = MessageWriter.Get();
MessageDisconnect.Serialize(writer, true, reason, message);
await Connection.DisconnectAsync(message ?? reason.ToString(), writer);
}
public async ValueTask DisconnectAsync(DisconnectReason reason, string?message = null)
{
if (!Connection.IsConnected)
{
return;
}
using var packet = MessageWriter.Get(MessageType.Reliable);
Message01JoinGameS2C.SerializeError(packet, false, reason, message);
await Connection.SendAsync(packet);
// Need this to show the correct message, otherwise it shows a generic disconnect message.
await Task.Delay(TimeSpan.FromMilliseconds(250));
await Connection.DisconnectAsync(message ?? reason.ToString());
}
public static void RemoveClient(ClientBase client, DisconnectReason reason = DisconnectReason.ClientDisconnect)
{
if (client != null && myClients[client.ID] == client)
{
myClients[client.ID] = null;
--myClientCount;
if (client.CurrentMap != null)
{
client.CurrentMap.RemoveEntity(client.PlayerEntity);
}
Log(client.Nickname + " has left the game (" + reason.ToString() + ")\n");
for (int i = 0; i < myMaxClients; ++i)
{
if (myClients[i] != null && client.CurrentMap == myClients[i].CurrentMap)
{
myClients[i].SendPlayerLeave(client);
}
}
}
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
static async Task ServerClientDisconnected(string ipPort, DisconnectReason reason)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("Server detected disconnection from client: " + ipPort + " [" + reason.ToString() + "]");
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
private static async Task ServerClientDisconnected(string ipPort, DisconnectReason reason)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
connectionCount--;
Console.WriteLine("[server] disconnection from " + ipPort + " [now " + connectionCount + "]: " + reason.ToString());
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
private static async Task ClientDisconnected(string ipPort, DisconnectReason reason)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
Console.WriteLine("Client disconnected: " + ipPort + ": " + reason.ToString());
}
private static void Client_Disconnected(ClientManager client, DisconnectReason r)
{
if (Clients.ContainsKey(client.ClientInfo[0]))
{
Clients.Remove(client.ClientInfo[0]);
}
else if (Clients.ContainsKey(client.ClientInfo[2]))
{
Clients.Remove(client.ClientInfo[2]);
}
Log(logType.Warning, string.Format("Client Disconnected. REASON:[{0}] CLIENT[{1}]", r.ToString().ToUpper(), client.ClientInfo[0]));
Console.Title = $"Commander [{Clients.Count} client(s)]";
}
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
var remoteAddress = this.RemoteIP + ":" + this.RemotePort;
PhotonWireApplicationBase.Instance.Logger.ClientPeerOnDisconnect(PhotonWireApplicationBase.Instance.ApplicationName, remoteAddress, this.ConnectionId, reasonCode.ToString(), reasonDetail);
List <Exception> exceptions = new List <Exception>();
PeerManager.ClientConnections.Remove(this);
Action <int, string>[] copy;
lock (disconnectActions)
{
if (disconnectActions.Count == 0)
{
return;
}
copy = new Action <int, string> [disconnectActions.Count];
disconnectActions.CopyTo(copy);
}
foreach (var item in copy)
{
try
{
item((int)reasonCode, reasonDetail);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
if (exceptions.Count > 0)
{
throw new AggregateException(exceptions);
}
}
public void DisconnectByReason(DisconnectReason reason)
{
ToLog(reason.ToString());
Disconnect();
}
void Communication_Disconnected(DisconnectReason reason)
{
Debug.WriteLine("Opponent disconnected, reason: " + reason.ToString());
}
public static void Update <T>(T peer) where T : NetPeer, IGamePeer
{
while (peer.ReadMessage(out NetIncomingMessage message))
{
switch (message.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
peer.InvokeDiscoveryRequest(peer, message);
break;
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)message.ReadByte();
string fullReason = message.ReadString();
string reason = fullReason.Contains(";") ? fullReason.Substring(0, fullReason.IndexOf(";")) : fullReason;
string additionalInfo = fullReason.Contains(";") ? fullReason.Substring(fullReason.IndexOf(";") + 1) : null;
DisconnectReason?enumReason = null;
int enumReasonInt;
if (int.TryParse(reason, out enumReasonInt))
{
enumReason = (DisconnectReason)enumReasonInt;
}
if (status == NetConnectionStatus.Connected)
{
peer.InvokeConnected(peer, new ConnectedEventArgs {
Connection = message.SenderConnection
});
}
else if (status == NetConnectionStatus.Disconnected)
{
Logger.LogDebug($"{message.SenderEndPoint} new status: {status} ({enumReason?.ToString() ?? reason})" + $" {additionalInfo}");
peer.InvokeDisconnected(peer, new DisconnectedEventArgs {
Connection = message.SenderConnection, Reason = enumReason ?? DisconnectReason.Invalid, ReasonString = reason, AdditionalInfo = additionalInfo
});
}
break;
case NetIncomingMessageType.Data:
if (message.Data.Length == 0)
{
message.SenderConnection.Disconnect(DisconnectReason.InvalidMessage);
break;
}
peer.InvokeDataReceived(peer, new DataReceivedEventArgs {
Message = message, MessageType = (MessageType)message.ReadByte()
});
break;
}
}
}
public NtrNetworkException(DisconnectReason reason) : base(reason.ToString())
{
}
public void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
_serverCollection.Disconnect(this);
Log.DebugFormat("Server Disconnected {0} - {1}", reasonCode.ToString(), reasonDetail);
}
public override void OnSessionClosed(DisconnectReason reason)
{
Console.WriteLine($"{LogMessage.OnSessionClose}\n{LogMessage.CloseReason}: {reason.ToString()}");
}
//客户端断开的操作（一般做一些清理操作）
protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail)
{
ServerTools.log.Info(ip + "断开链接" + reasonCode.ToString());
}
private void OnDisconnect(DisconnectReason reason)
{
onDisconnect?.Invoke(reason.ToString());
}
private async Task ClientDisconnected(string ipPort, DisconnectReason reason)
{
Log("[" + ipPort + "] client disconnected function: " + reason.ToString());
_Clients[ipPort].ClientDisconnected();
}
