/// <summary>
/// Reconnects a client after an error or if it's offline. Reconnecting, instead of creating a completely new connection,
/// saves time.
/// </summary>
public async Task Reconnect()
{
try
{
this.secondTimer?.Dispose();
this.secondTimer = null;
if (this.state == MqttState.Connected)
{
await this.DISCONNECT();
}
this.DisposeClient();
}
catch (Exception)
{
// Ignore
}
finally
{
this.secondTimer = null;
this.client = null;
}
this.state = MqttState.Offline;
await this.BeginConnect();
}
/// <summary>
/// Reconnects a client after an error or if it's offline. Reconnecting, instead of creating a completely new connection,
/// saves time.
/// </summary>
public void Reconnect()
{
try
{
if (this.secondTimer != null)
{
this.secondTimer.Dispose();
}
if (this.state == MqttState.Connected)
{
this.DISCONNECT();
}
this.DisposeClient();
}
catch (Exception)
{
// Ignore
}
finally
{
this.secondTimer = null;
this.client = null;
}
this.state = MqttState.Offline;
Task.Run(this.BeginConnect);
}
private Task Client_OnSent(object Sender, byte[] Buffer, int Offset, int Count)
{
if (this.HasSniffers)
this.TransmitBinary(BinaryTcpClient.ToArray(Buffer, Offset, Count));
return Task.FromResult<bool>(true);
}
/// <summary>
/// Connect to the remote host and port using a binary protocol over TCP.
/// </summary>
/// <param name="Sniffers">Sniffers</param>
/// <returns>Binary TCP transport.</returns>
public async Task <BinaryTcpClient> ConnectTcp(params ISniffer[] Sniffers)
{
BinaryTcpClient Client = new BinaryTcpClient(Sniffers);
await Client.ConnectAsync(this.Host, this.port);
return(Client);
}
/// <summary>
/// Connects to a peer in the peer-to-peer network. If the remote end point resides behind the same firewall as the current application,
/// a direct connection to the local peer is made, for improved performance.
/// </summary>
/// <param name="RemoteEndPoint">Remote End-point.</param>
/// <returns>Peer connection</returns>
public async Task <PeerConnection> ConnectToPeer(IPEndPoint RemoteEndPoint)
{
if (this.State != PeerToPeerNetworkState.Ready)
{
throw new IOException("Peer-to-peer network not ready.");
}
BinaryTcpClient Client = new BinaryTcpClient();
IPEndPoint RemoteEndPoint2 = RemoteEndPoint;
try
{
RemoteEndPoint2 = this.CheckLocalRemoteEndpoint(RemoteEndPoint);
await Client.ConnectAsync(RemoteEndPoint2.Address, RemoteEndPoint2.Port, true);
}
catch (Exception ex)
{
Client.Dispose();
System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(ex).Throw();
}
PeerConnection Result = new PeerConnection(Client, this, RemoteEndPoint2, this.encapsulatePackets);
Result.StartIdleTimer();
return(Result);
}
public ClientRequestHandler(BinaryTcpClient client,
string logsSourcePath, string logsDestPath,
ILogger logger)
{
this.client = client;
this.logsSourcePath = logsSourcePath;
this.logsDestPath = logsDestPath;
this.logger = logger;
}
/// <summary>
/// <see cref="IDisposable.Dispose"/>
/// </summary>
public void Dispose()
{
if (!this.disposed)
{
this.disposed = true;
this.State = Socks5State.Offline;
this.client?.Dispose();
this.client = null;
}
}
protected override void OnAcceptClient(BinaryTcpClient client)
{
logger.Log("Connection received");
ThreadPool.QueueUserWorkItem(stateInfo =>
{
new ClientHandler(
client, logSourcePath, logDestPath, logger)
.HandleClient();
});
logger.Log("Created thread for user");
}
internal HttpClientConnection(HttpServer Server, BinaryTcpClient Client, bool Encrypted, params ISniffer[] Sniffers)
: base(Sniffers)
{
this.server = Server;
this.client = Client;
this.encrypted = Encrypted;
this.client.OnDisconnected += Client_OnDisconnected;
this.client.OnError += Client_OnError;
this.client.OnReceived += Client_OnReceived;
}
/// <summary>
/// <see cref="IDisposable.Dispose"/>
/// </summary>
public void Dispose()
{
if (!this.disposed)
{
this.disposed = true;
Task _ = this.SetState(Socks5State.Offline);
this.client?.Dispose();
this.client = null;
}
}
/// <summary>
/// <see cref="IDisposable.Dispose"/>
/// </summary>
public void Dispose()
{
this.disposed = true;
this.idleTimer?.Dispose();
this.idleTimer = null;
this.tcpConnection?.Dispose();
this.tcpConnection = null;
this.Closed();
}
public ClientHandler(BinaryTcpClient client,
string logsSourcePath, string logsDestPath,
ILogger logger)
{
this.client = client;
this.logsSourcePath = logsSourcePath;
this.logsDestPath = logsDestPath;
this.logger = logger;
requestHandler = new ClientRequestHandler(
client, logsSourcePath, logsDestPath, this.logger);
decoder = new MessageDecoder();
categorizationStrategy = GetCategorizationStrategy();
}
/// <summary>
/// Client used for SOCKS5 communication.
/// </summary>
/// <param name="Host">Host of SOCKS5 stream host.</param>
/// <param name="Port">Port of SOCKS5 stream host.</param>
/// <param name="JID">JID of SOCKS5 stream host.</param>
/// <param name="Sniffers">Optional set of sniffers.</param>
public Socks5Client(string Host, int Port, string JID, params ISniffer[] Sniffers)
: base(Sniffers)
{
this.host = Host;
this.port = Port;
this.jid = JID;
Task _ = this.SetState(Socks5State.Connecting);
this.Information("Connecting to " + this.host + ":" + this.port.ToString());
this.client = new BinaryTcpClient();
this.Connect();
}
internal PeerConnection(BinaryTcpClient TcpConnection, PeerToPeerNetwork Network, IPEndPoint RemoteEndpoint,
bool EncapsulatePackets)
{
this.network = Network;
this.remoteEndpoint = RemoteEndpoint;
this.tcpConnection = TcpConnection;
this.encapsulatePackets = EncapsulatePackets;
this.tcpConnection.OnDisconnected += TcpConnection_OnDisconnected;
this.tcpConnection.OnError += TcpConnection_OnError;
this.tcpConnection.OnReceived += TcpConnection_OnReceived;
this.tcpConnection.OnSent += TcpConnection_OnSent;
}
private async Task<bool> Client_OnReceived(object Sender, byte[] Buffer, int Offset, int Count)
{
if (this.HasSniffers)
this.ReceiveBinary(BinaryTcpClient.ToArray(Buffer, Offset, Count));
try
{
await this.ParseIncoming(Buffer, Offset, Count);
return true;
}
catch (Exception ex)
{
Log.Critical(ex);
return false;
}
}
private Task <bool> Client_OnReceived(object Sender, byte[] Buffer, int Offset, int Count)
{
if (this.HasSniffers)
{
this.ReceiveBinary(BinaryTcpClient.ToArray(Buffer, Offset, Count));
}
try
{
this.ParseIncoming(Buffer, Offset, Count);
}
catch (Exception ex)
{
Log.Critical(ex);
}
return(Task.FromResult <bool>(true));
}
public void Dispose()
{
if (!this.disposed)
{
this.disposed = true;
this.webSocket?.Dispose();
this.webSocket = null;
this.headerStream?.Dispose();
this.headerStream = null;
this.dataStream?.Dispose();
this.dataStream = null;
this.client?.DisposeWhenDone();
this.client = null;
}
}
private async Task BeginConnect()
{
try
{
this.Information("Connecting to " + Host + ":" + Port.ToString());
this.DisposeClient();
this.State = MqttState.Connecting;
this.client = new BinaryTcpClient();
await this.client.ConnectAsync(Host, Port, this.tls);
if (this.tls)
{
this.State = MqttState.StartingEncryption;
#if WINDOWS_UWP
await this.client.UpgradeToTlsAsClient(SocketProtectionLevel.Tls12, this.trustServer);
#else
await this.client.UpgradeToTlsAsClient(this.clientCertificate, SslProtocols.Tls12, this.trustServer);
#endif
this.client.Continue();
}
this.client.OnSent += this.Client_OnSent;
this.client.OnReceived += this.Client_OnReceived;
this.client.OnDisconnected += this.Client_OnDisconnected;
this.client.OnError += this.ConnectionError;
await this.CONNECT(KeepAliveTimeSeconds);
}
catch (Exception ex)
{
await this.ConnectionError(this, ex);
}
}
private async Task <bool> Client_OnReceived(object Sender, byte[] Buffer, int Offset, int Count)
{
if (this.HasSniffers)
{
this.ReceiveBinary(BinaryTcpClient.ToArray(Buffer, Offset, Count));
}
byte b;
bool Result = true;
while (Count-- > 0)
{
b = Buffer[Offset++];
switch (this.inputState)
{
case 0:
this.inputPacket = new MemoryStream();
this.inputPacket.WriteByte(b);
this.inputPacketType = (MqttControlPacketType)(b >> 4);
this.inputRemainingLength = 0;
this.inputOffset = 0;
this.inputState++;
break;
case 1:
this.inputRemainingLength |= ((b & 127) << this.inputOffset);
this.inputOffset += 7;
this.inputPacket.WriteByte(b);
if ((b & 128) == 0)
{
switch (this.inputPacketType)
{
case MqttControlPacketType.CONNECT:
case MqttControlPacketType.CONNACK:
case MqttControlPacketType.PINGREQ:
case MqttControlPacketType.PINGRESP:
case MqttControlPacketType.DISCONNECT:
case MqttControlPacketType.PUBLISH:
default:
if (this.inputRemainingLength == 0)
{
this.inputState = 0;
if (!await this.ProcessInputPacket())
{
Result = false;
}
}
else
{
this.inputState += 3;
}
break;
case MqttControlPacketType.PUBACK:
case MqttControlPacketType.PUBREC:
case MqttControlPacketType.PUBREL:
case MqttControlPacketType.PUBCOMP:
case MqttControlPacketType.SUBSCRIBE:
case MqttControlPacketType.SUBACK:
case MqttControlPacketType.UNSUBSCRIBE:
case MqttControlPacketType.UNSUBACK:
this.inputState++;
break;
}
}
break;
case 2:
this.inputPacket.WriteByte(b);
this.inputState++;
this.inputRemainingLength--;
break;
case 3:
this.inputPacket.WriteByte(b);
this.inputRemainingLength--;
if (this.inputRemainingLength == 0)
{
this.inputState = 0;
if (!await this.ProcessInputPacket())
{
Result = false;
}
}
else
{
this.inputState++;
}
break;
case 4:
this.inputPacket.WriteByte(b);
this.inputRemainingLength--;
if (this.inputRemainingLength == 0)
{
this.inputState = 0;
if (!await this.ProcessInputPacket())
{
Result = false;
}
}
break;
}
}
return(Result);
}
public void HandleClient(BinaryTcpClient client, ILogger logger)
{
}
private void DisposeClient()
{
this.client?.Dispose();
this.client = null;
}
public void HandleClientThreaded(BinaryTcpClient client, ILogger logger)
{
ThreadPool.QueueUserWorkItem(s => HandleClient(client, logger));
}
protected override void OnAcceptClient(BinaryTcpClient client)
{
logger.Log("Client connected");
clientHandler.HandleClientThreaded(client, logger);
}
private Task <bool> Connection_OnReceived(object Sender, byte[] Buffer, int Offset, int Count)
{
PeerConnection Connection = (PeerConnection)Sender;
Guid PlayerId;
IPAddress PlayerRemoteAddress;
IPEndPoint PlayerRemoteEndpoint;
try
{
BinaryInput Input = new BinaryInput(BinaryTcpClient.ToArray(Buffer, Offset, Count));
PlayerId = Input.ReadGuid();
PlayerRemoteAddress = IPAddress.Parse(Input.ReadString());
PlayerRemoteEndpoint = new IPEndPoint(PlayerRemoteAddress, Input.ReadUInt16());
}
catch (Exception)
{
Connection.Dispose();
return(Task.FromResult <bool>(true));
}
Player Player = (Player)Connection.StateObject;
lock (this.remotePlayersByEndpoint)
{
if (!this.playersById.TryGetValue(PlayerId, out Player Player2) || Player2.PlayerId != Player.PlayerId)
{
Connection.Dispose();
return(Task.FromResult <bool>(true));
}
Player.Connection = Connection;
}
Connection.RemoteEndpoint = Player.GetExpectedEndpoint(this.p2pNetwork);
Connection.OnReceived -= this.Connection_OnReceived;
Connection.OnReceived += this.Peer_OnReceived;
Connection.OnSent += this.Connection_OnSent;
BinaryOutput Output = new BinaryOutput();
Output.WriteGuid(this.localPlayer.PlayerId);
Output.WriteString(this.ExternalAddress.ToString());
Output.WriteUInt16((ushort)this.ExternalEndpoint.Port);
Connection.SendTcp(Output.GetPacket());
MultiPlayerEnvironmentPlayerInformationEventHandler h = this.OnPlayerConnected;
if (h != null)
{
try
{
h(this, Player);
}
catch (Exception ex)
{
Events.Log.Critical(ex);
}
}
return(Task.FromResult <bool>(true));
}
private Task <bool> Peer_OnReceived(object Sender, byte[] Buffer, int Offset, int Count)
{
PeerConnection Connection = (PeerConnection)Sender;
Player Player;
byte[] Packet;
if (Connection.StateObject is null)
{
BinaryInput Input = new BinaryInput(BinaryTcpClient.ToArray(Buffer, Offset, Count));
Guid PlayerId;
IPAddress PlayerRemoteAddress;
IPEndPoint PlayerRemoteEndpoint;
try
{
PlayerId = Input.ReadGuid();
PlayerRemoteAddress = IPAddress.Parse(Input.ReadString());
PlayerRemoteEndpoint = new IPEndPoint(PlayerRemoteAddress, Input.ReadUInt16());
}
catch (Exception)
{
Connection.Dispose();
return(Task.FromResult <bool>(true));
}
if (Input.BytesLeft == 0)
{
Packet = null;
}
else
{
Packet = Input.GetRemainingData();
}
bool AllConnected;
lock (this.remotePlayersByEndpoint)
{
if (!this.playersById.TryGetValue(PlayerId, out Player))
{
Connection.Dispose();
return(Task.FromResult <bool>(true));
}
if (Player.Connection is null)
{
this.connectionCount++;
}
else
{
Player.Connection.Dispose();
}
Player.Connection = Connection;
Connection.StateObject = Player;
Connection.RemoteEndpoint = Player.GetExpectedEndpoint(this.p2pNetwork);
AllConnected = this.connectionCount + 1 == this.playerCount;
}
MultiPlayerEnvironmentPlayerInformationEventHandler h = this.OnPlayerConnected;
if (h != null)
{
try
{
h(this, Player);
}
catch (Exception ex)
{
Events.Log.Critical(ex);
}
}
if (AllConnected)
{
this.State = MultiPlayerState.Ready;
}
if (Packet is null)
{
return(Task.FromResult <bool>(true));
}
}
else
{
Player = (Player)Connection.StateObject;
Packet = BinaryTcpClient.ToArray(Buffer, Offset, Count);
}
this.GameDataReceived(Player, Connection, Packet);
return(Task.FromResult <bool>(true));
}
private async void AcceptTcpClients()
{
try
{
while (!this.disposed && !(this.tcpListener is null))
{
try
{
TcpClient TcpClient;
try
{
TcpClient = await this.tcpListener.AcceptTcpClientAsync();
if (this.disposed)
{
return;
}
}
catch (InvalidOperationException)
{
this.State = PeerToPeerNetworkState.Error;
this.tcpListener?.Stop();
this.tcpListener = null;
this.udpClient?.Dispose();
this.udpClient = null;
return;
}
if (!(TcpClient is null))
{
PeerConnection Connection = null;
try
{
BinaryTcpClient Client = new BinaryTcpClient(TcpClient);
Client.Bind(true);
Connection = new PeerConnection(Client, this,
(IPEndPoint)TcpClient.Client.RemoteEndPoint, this.encapsulatePackets);
this.State = PeerToPeerNetworkState.Ready;
this.PeerConnected(Connection);
Connection.Start();
}
catch (Exception)
{
Connection?.Dispose();
}
}
}
catch (SocketException)
{
// Ignore
}
catch (ObjectDisposedException)
{
// Ignore
}
catch (NullReferenceException)
{
// Ignore
}
catch (Exception ex)
{
Log.Critical(ex);
}
}
}
catch (Exception ex)
{
if (this.disposed)
{
return;
}
Log.Critical(ex);
}
}
