private void ConnectionEstablished(object sender, ConnectionEstablishedEventArgs e)
{
log.Info("TpsService: Tps Connection is established.");
peer = e.RemoteTcpPeer;
log.Info($"TpsService: Connected to [{peer.IPEndPoint}]");
TpsConnectionEstablished?.Invoke();
}
private void ConnectionListenerOnConnectionEstablished(object sender, ConnectionEstablishedEventArgs args)
{
var client = new RemoteClient(new RequestDispatcher(args.Connection, new JsonRequestParser()));
_connectedClients.Add(args.Connection, client);
OnClientConnected(new RemoteClientConnectedEventArgs(client));
}
private void ConnectionEstablished(object sender, ConnectionEstablishedEventArgs ev)
{
Debug.Print("NetworkWrapper.ConnectionEstablished");
Debug.Print("+ remote end point: {0}", ev.Server.ServerEndPoint);
OnConnectAttemptSucceeded( );
}
private void HandleConnectionEstablished(object sender, ConnectionEstablishedEventArgs ev)
{
Debug.Print("ServerWrapper.HandleConnectionEstablished");
Debug.Print("+ remote end point: {0}", ev.Server.ServerEndPoint);
Server = ev.Server;
IsConnected = true;
OnConnectSucceeded( );
}
public static void EncryptionKeyResponse(RemoteClient client, MinecraftServer server, IPacket _packet)
{
var packet = (EncryptionKeyResponsePacket)_packet;
var decryptedToken = server.CryptoServiceProvider.Decrypt(packet.VerificationToken, false);
for (int i = 0; i < decryptedToken.Length; i++)
{
if (decryptedToken[i] != client.VerificationToken[i])
{
client.Disconnect("Unable to authenticate.");
return;
}
}
client.SharedKey = server.CryptoServiceProvider.Decrypt(packet.SharedSecret, false);
// Create a hash for session verification
AsnKeyBuilder.AsnMessage encodedKey = AsnKeyBuilder.PublicKeyToX509(server.ServerKey);
byte[] shaData = Encoding.UTF8.GetBytes(client.ServerId)
.Concat(client.SharedKey)
.Concat(encodedKey.GetBytes()).ToArray();
string hash = Cryptography.JavaHexDigest(shaData);
// Talk to sessionserver.minecraft.net
if (server.Settings.OnlineMode)
{
var webClient = new WebClient();
var webReader = new StreamReader(webClient.OpenRead(
new Uri(string.Format(sessionCheckUri, client.Username, hash))));
string response = webReader.ReadToEnd();
webReader.Close();
var json = JToken.Parse(response);
if (string.IsNullOrEmpty(response))
{
client.Disconnect("Failed to verify username!");
return;
}
client.UUID = json["id"].Value <string>();
}
client.NetworkStream = new AesStream(client.NetworkClient.GetStream(), client.SharedKey);
client.NetworkManager.BaseStream = client.NetworkStream;
client.EncryptionEnabled = true;
var eventArgs = new ConnectionEstablishedEventArgs(client);
server.OnConnectionEstablished(eventArgs);
if (eventArgs.PermitConnection)
{
server.LogInPlayer(client);
}
else
{
client.Disconnect(eventArgs.DisconnectReason);
}
}
protected virtual void OnConnectionEstablished(ConnectionEstablishedEventArgs e)
{
try
{
this.ConnectionEstablished?.Invoke(this, e);
}
catch (Exception ex)
{
var ue = new ExceptionEventArgs(ex);
this.OnUnhandledException(ue);
}
}
protected virtual void OnConnectionEstablished(ConnectionEstablishedEventArgs e)
{
try
{
this.ConnectionEstablished?.Invoke(this, e);
}
catch (Exception ex)
{
var unhandledErrorEventArgs = new UnhandledErrorEventArgs(new ErrorData(ex));
this.OnUnhandledError(unhandledErrorEventArgs);
}
}
private void ConnectionEstablished(object sender, ConnectionEstablishedEventArgs ev)
{
Console.WriteLine("ConsoleHarness: ConnectionEstablished:");
Console.WriteLine("+ remote end point: {0}", ev.Server.ServerEndPoint);
Console.WriteLine( );
_serverConnector = null;
_server = ev.Server;
_protocolHandler = _server.ProtocolHandler;
_selfUser = _server.SelfUser;
_selfUser.Error += HandleError;
_selfUser.Quit += HandleSelfQuit;
_server.Registered += HandleRegistered;
_server.MotdComplete += HandleMotdComplete;
_connected = true;
}
public static void EncryptionKeyResponse(RemoteClient client, MinecraftServer server, IPacket _packet)
{
var packet = (EncryptionKeyResponsePacket)_packet;
var decryptedToken = server.CryptoServiceProvider.Decrypt(packet.VerificationToken, false);
for (int i = 0; i < decryptedToken.Length; i++)
{
if (decryptedToken[i] != client.VerificationToken[i])
{
client.Disconnect("Unable to authenticate.");
return;
}
}
client.SharedKey = server.CryptoServiceProvider.Decrypt(packet.SharedSecret, false);
// Create a hash for session verification
AsnKeyBuilder.AsnMessage encodedKey = AsnKeyBuilder.PublicKeyToX509(server.ServerKey);
byte[] shaData = Encoding.UTF8.GetBytes(client.ServerId)
.Concat(client.SharedKey)
.Concat(encodedKey.GetBytes()).ToArray();
string hash = Cryptography.JavaHexDigest(shaData);
// Talk to sessionserver.minecraft.net
if (server.Settings.OnlineMode)
{
var webClient = new WebClient();
var webReader = new StreamReader(webClient.OpenRead(
new Uri(string.Format(sessionCheckUri, client.Username, hash))));
string response = webReader.ReadToEnd();
webReader.Close();
var json = JToken.Parse(response);
if (string.IsNullOrEmpty(response))
{
client.Disconnect("Failed to verify username!");
return;
}
client.UUID = json["id"].Value<string>();
}
client.NetworkStream = new AesStream(client.NetworkClient.GetStream(), client.SharedKey);
client.NetworkManager.BaseStream = client.NetworkStream;
client.EncryptionEnabled = true;
var eventArgs = new ConnectionEstablishedEventArgs(client);
server.OnConnectionEstablished(eventArgs);
if (eventArgs.PermitConnection)
server.LogInPlayer(client);
else
client.Disconnect(eventArgs.DisconnectReason);
}
protected virtual async Task HandleNewTcpClientTask(TcpClient tcpClient, CancellationToken token)
{
using (tcpClient)
{
var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(token); // remote tcp peer controls linkedCts lifetime
var sendQueue = this.CreateSendQueueActionBlock(linkedCts.Token);
RemoteTcpPeer remoteTcpPeer;
SslStream sslStream = null;
try
{
if (this.Config.UseSsl && this.Config.X509Certificate != null)
{
sslStream = this.CreateSslStream(tcpClient);
await this.AuthenticateSslStream(tcpClient, sslStream, linkedCts.Token)
.ConfigureAwait(false);
remoteTcpPeer = this.CreateRemoteTcpPeer(tcpClient, sslStream, sendQueue, linkedCts);
}
else
{
remoteTcpPeer = this.CreateRemoteTcpPeer(tcpClient, sendQueue, linkedCts);
}
}
catch (AuthenticationException ex)
{
var e = new TcpServerExceptionEventArgs(ex);
this.OnServerExceptionOccured(e);
sendQueue.Complete();
sslStream?.Dispose();
linkedCts.Dispose();
return;
}
catch (Exception ex)
{
var e = new TcpServerExceptionEventArgs(ex);
this.OnServerExceptionOccured(e);
sendQueue.Complete();
linkedCts.Dispose();
return;
}
using (remoteTcpPeer)
{
this.AddRemoteTcpPeerToConnectedList(remoteTcpPeer);
var connectionEstablishedEventArgs = new ConnectionEstablishedEventArgs(remoteTcpPeer);
this.OnConnectionEstablished(connectionEstablishedEventArgs);
await this.HandleRemotePeerAsync(remoteTcpPeer, linkedCts.Token).ConfigureAwait(false);
sendQueue.Complete();
sslStream?.Dispose();
}
}
}
public void GivenASocketConnectionListener()
{
ConnectionListener = new TcpClientConnectionListener();
ConnectionListener.ConnectionEstablished += (sender, args) => ConnectionEstablishedEventArgs = args;
}
private void ConnectionListenerOnConnectionEstablished(object sender, ConnectionEstablishedEventArgs args)
{
var client = new RemoteClient(new RequestDispatcher(args.Connection, new JsonRequestParser()));
_connectedClients.Add(args.Connection, client);
OnClientConnected(new RemoteClientConnectedEventArgs(client));
}
// exploiting "async void" simplifies everything
protected virtual async void HandleNewTcpClientAsync(TcpClient tcpClient, CancellationToken token)
{
using (tcpClient)
using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(token))
{
var sendQueue = this.CreateSendQueueActionBlock(linkedCts.Token);
RemoteTcpPeer remoteTcpPeer;
SslStream sslStream = null;
try
{
if (this.Config.UseSsl && this.Config.X509Certificate != null)
{
sslStream = this.CreateSslStream(tcpClient);
await this.AuthenticateSslStream(tcpClient, sslStream, linkedCts.Token)
.ConfigureAwait(false);
remoteTcpPeer = this.CreateRemoteTcpPeer(tcpClient, sslStream, sendQueue, linkedCts);
}
else
{
remoteTcpPeer = this.CreateRemoteTcpPeer(tcpClient, sendQueue, linkedCts);
}
}
catch (AuthenticationException ex)
{
var serverErrorEventArgs = new TcpServerErrorEventArgs(new ErrorData(ex));
this.OnServerErrorOccured(serverErrorEventArgs);
sendQueue.Complete();
sslStream?.Dispose();
return;
}
catch (Exception)
{
sendQueue.Complete();
return;
}
using (remoteTcpPeer)
{
var connectionEstablishedEventArgs = new ConnectionEstablishedEventArgs(new ConnectionEstablishedData(remoteTcpPeer));
this.OnConnectionEstablished(connectionEstablishedEventArgs);
try
{
await this.HandleRemotePeerAsync(remoteTcpPeer, linkedCts.Token).ConfigureAwait(false);
}
catch (Exception ex)
{
var unhandledErrorEventArgs = new UnhandledErrorEventArgs(new ErrorData(ex));
this.OnUnhandledError(unhandledErrorEventArgs);
}
finally
{
sendQueue.Complete();
sslStream?.Dispose();
}
}
}
}
protected virtual async Task HandleTcpClientAsync(TcpClient tcpClient, CancellationToken token)
{
using (tcpClient)
{
var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(token); // remote tcp peer controls linkedCts lifetime
var sendQueue = this.CreateSendQueueActionBlock(linkedCts.Token);
RemoteTcpPeer remoteTcpPeer;
SslStream sslStream = null;
try
{
if (this.Config.UseSsl)
{
sslStream = this.CreateSslStream(tcpClient);
await this.AuthenticateSslStream(tcpClient, sslStream, linkedCts.Token)
.ConfigureAwait(false);
remoteTcpPeer = this.CreateRemoteTcpPeer(tcpClient, sslStream, sendQueue, linkedCts);
}
else
{
remoteTcpPeer = this.CreateRemoteTcpPeer(tcpClient, sendQueue, linkedCts);
}
}
catch (AuthenticationException ex)
{
var clientExceptionEventArgs = new TcpClientExceptionEventArgs(ex);
this.OnClientExceptionOccured(clientExceptionEventArgs);
sendQueue.Complete();
sslStream?.Dispose();
this.OnClientStopped(new TcpClientStoppedEventArgs()
{
ClientStoppedReason = ClientStoppedReason.RuntimeException,
Exception = ex
});
linkedCts.Dispose();
return;
}
catch (Exception ex)
{
sendQueue.Complete();
this.OnClientStopped(new TcpClientStoppedEventArgs()
{
ClientStoppedReason = ClientStoppedReason.RuntimeException,
Exception = ex
});
linkedCts.Dispose();
return;
}
using (remoteTcpPeer)
{
var connectionEstablishedEventArgs = new ConnectionEstablishedEventArgs(remoteTcpPeer);
this.OnConnectionEstablished(connectionEstablishedEventArgs);
await this.HandleRemotePeerAsync(remoteTcpPeer, linkedCts.Token).ConfigureAwait(false);
sendQueue.Complete();
sslStream?.Dispose();
this.OnClientStopped(new TcpClientStoppedEventArgs()
{
ClientStoppedReason = ClientStoppedReason.Disconnected,
ConnectionCloseReason = remoteTcpPeer.ConnectionCloseReason,
Exception = remoteTcpPeer.ConnectionCloseException
});
}
}
}
public static void ClientStatus(RemoteClient client, MinecraftServer server, IPacket _packet)
{
var packet = (ClientStatusPacket)_packet;
if (packet.Status == ClientStatusPacket.ClientStatus.InitialSpawn)
{
// Create a hash for session verification
AsnKeyBuilder.AsnMessage encodedKey = AsnKeyBuilder.PublicKeyToX509(server.ServerKey);
byte[] shaData = Encoding.UTF8.GetBytes(client.AuthenticationHash)
.Concat(client.SharedKey)
.Concat(encodedKey.GetBytes()).ToArray();
string hash = Cryptography.JavaHexDigest(shaData);
// Talk to session.minecraft.net
if (server.Settings.OnlineMode)
{
var webClient = new WebClient();
var webReader = new StreamReader(webClient.OpenRead(
new Uri(string.Format(sessionCheckUri, client.Username, hash))));
string response = webReader.ReadToEnd();
webReader.Close();
if (response != "YES")
{
client.Disconnect("Failed to verify username!");
return;
}
}
var eventArgs = new ConnectionEstablishedEventArgs(client);
server.OnConnectionEstablished(eventArgs);
if (eventArgs.PermitConnection)
server.LogInPlayer(client);
else
client.Disconnect(eventArgs.DisconnectReason);
}
else if (packet.Status == ClientStatusPacket.ClientStatus.Respawn)
{
var world = client.Entity.World;
client.Entity.Position = new Vector3(
client.Entity.SpawnPoint.X,
// FIXME: This seems to drop the player camera from half the height of a login spawn
client.Entity.SpawnPoint.Y,
client.Entity.SpawnPoint.Z);
client.Entity.Health = client.Entity.MaxHealth;
client.Entity.Food = 20;
client.Entity.FoodSaturation = 20;
server.EntityManager.SpawnEntity(world, client.Entity);
client.SendPacket(new UpdateHealthPacket(client.Entity.Health, client.Entity.Food, client.Entity.FoodSaturation));
client.SendPacket(new RespawnPacket(Dimension.Overworld, server.Settings.Difficulty, client.GameMode, World.Height, world.WorldGenerator.GeneratorName));
client.SendPacket(new PlayerPositionAndLookPacket(client.Entity.Position.X, client.Entity.Position.Y, client.Entity.Position.Z,
client.Entity.Position.Y + PlayerEntity.Height, client.Entity.Yaw, client.Entity.Pitch, true));
}
}
protected virtual void OnConnectionEstablished(ConnectionEstablishedEventArgs e)
{
this.ConnectionEstablished?.Invoke(this, e);
}
