private void ParsePacket(AsyncResultEventArgs <byte[]> args)
{
try
{
if (args.Error != null)
{
throw args.Error;
}
if (args.Result == null)
{
if (Habbo.LoggedIn)
{
Habbo.LoggedIn = false;
}
Disconnect("Socket read error!");
return;
}
ParseByteData(args.Result);
}
catch (Exception)
{
if (args.Error != null)
{
string dumpPath = CoreManager.ServerCore.DumpException(args.Error);
CoreManager.ServerCore.ConsoleManager.Error("Game Socket Manager", CoreManager.ServerCore.StringLocale.GetString("CORE:ERROR_NETWORK_CONNECTION_KILLED"));
CoreManager.ServerCore.ConsoleManager.Error("Game Socket Manager", " An exception dump has been saved to " + dumpPath);
}
}
}
private void IncomingConnectedAccepted(AsyncResultEventArgs <ServerChildTcpSocket> args)
{
if (args.Error != null)
{
// TODO: Die safely?
CoreManager.ServerCore.StandardOut.Error("Game Socket Manager", "Incoming connection failed!!");
// TODO: Pretty exception reporting
Console.WriteLine();
Console.WriteLine(args.Error.Message);
Console.WriteLine(args.Error.StackTrace);
_listeningSocket.AcceptAsync();
return;
}
ServerChildTcpSocket internalSocket = args.Result;
GameSocket socket = new GameSocket(internalSocket, Protocol);
CancelReasonEventArgs connectionEventArgs = new CancelReasonEventArgs();
CoreManager.ServerCore.OfficalEventFirer.Fire("incoming_game_connection", EventPriority.Before, socket, connectionEventArgs);
if (connectionEventArgs.Cancel)
{
socket.Disconnect("Connection rejected from " + internalSocket.RemoteEndPoint + "(" + connectionEventArgs.CancelReason + ")");
return;
}
socket.Start();
CoreManager.ServerCore.OfficalEventFirer.Fire("incoming_game_connection", EventPriority.After, socket, connectionEventArgs);
CoreManager.ServerCore.StandardOut.Notice("Game Socket Manager", "Incoming connection accepted: " + internalSocket.RemoteEndPoint);
_listeningSocket.AcceptAsync();
}
private void IncomingConnectedAccepted(AsyncResultEventArgs<ServerChildTcpSocket> args)
{
if(args.Error != null)
{
string dumpPath = CoreManager.ServerCore.DumpException(args.Error);
CoreManager.ServerCore.ConsoleManager.Error("Game Socket Manager", "Incoming connection failed!!");
CoreManager.ServerCore.ConsoleManager.Error("Game Socket Manager", " An exception dump has been saved to " + dumpPath);
_listeningSocket.AcceptAsync();
return;
}
ServerChildTcpSocket internalSocket = args.Result;
GameSocket socket = new GameSocket(internalSocket, this);
GameSocketEventArgs eventArgs = new GameSocketEventArgs(socket);
CoreManager.ServerCore.OfficalEventFirer.Fire("incoming_game_connection:before", eventArgs);
if (eventArgs.IsCancelled)
{
socket.Disconnect("Connection rejected from " + internalSocket.RemoteEndPoint + "(" + eventArgs.CancelReason + ")");
return;
}
socket.Start();
CoreManager.ServerCore.OfficalEventFirer.Fire("incoming_game_connection:after", eventArgs);
CoreManager.ServerCore.ConsoleManager.Notice("Game Socket Manager", "Incoming connection accepted: " + internalSocket.RemoteEndPoint);
_listeningSocket.AcceptAsync();
}
public void Exception_ForFailedArgs_IsPreserved()
{
Exception error = new Exception();
var test = new AsyncResultEventArgs <int>(error);
Assert.AreSame(error, test.Error, "Failed event args did not preserve exception");
}
public void UserState_ForSuccessfulArgsFullConstructor_IsPreserved()
{
object state = new object();
var test = new AsyncResultEventArgs <int>(13, null, false, state);
Assert.AreSame(state, test.UserState, "Successful event args did not preserve user state");
}
public void UserState_ForFailedArgsFullConstructor_IsPreserved()
{
object state = new object();
var test = new AsyncResultEventArgs <int>(0, new Exception(), false, state);
Assert.AreSame(state, test.UserState, "Failed event args did not preserve user state");
}
public void Exception_ForFailedArgsFullConstructor_IsPreserved()
{
Exception error = new Exception();
var test = new AsyncResultEventArgs <int>(0, error, false, null);
Assert.AreSame(error, test.Error, "Failed event args did not preserve exception");
}
private void IncomingConnectedAccepted(AsyncResultEventArgs<ServerChildTcpSocket> args)
{
if(args.Error != null)
{
// TODO: Die safely?
CoreManager.ServerCore.StandardOut.Error("Game Socket Manager", "Incoming connection failed!!");
// TODO: Pretty exception reporting
Console.WriteLine();
Console.WriteLine(args.Error.Message);
Console.WriteLine(args.Error.StackTrace);
_listeningSocket.AcceptAsync();
return;
}
ServerChildTcpSocket internalSocket = args.Result;
GameSocket socket = new GameSocket(internalSocket, Protocol);
CancelReasonEventArgs connectionEventArgs = new CancelReasonEventArgs();
CoreManager.ServerCore.OfficalEventFirer.Fire("incoming_game_connection", EventPriority.Before, socket, connectionEventArgs);
if (connectionEventArgs.Cancel)
{
socket.Disconnect("Connection rejected from " + internalSocket.RemoteEndPoint + "(" + connectionEventArgs.CancelReason + ")");
return;
}
socket.Start();
CoreManager.ServerCore.OfficalEventFirer.Fire("incoming_game_connection", EventPriority.After, socket, connectionEventArgs);
CoreManager.ServerCore.StandardOut.Notice("Game Socket Manager", "Incoming connection accepted: " + internalSocket.RemoteEndPoint);
_listeningSocket.AcceptAsync();
}
public void UserState_ForCancelledArgsFullConstructor_IsPreserved()
{
object state = new object();
var test = new AsyncResultEventArgs <int>(0, null, true, state);
Assert.AreSame(state, test.UserState, "Cancelled event args did not preserve user state");
}
private void ParsePacket(AsyncResultEventArgs <byte[]> args)
{
try
{
if (args.Error != null)
{
throw args.Error;
}
if (args.Result == null)
{
if (Habbo.LoggedIn)
{
Habbo.LoggedIn = false;
}
Disconnect("Socket read error!");
return;
}
ParseByteData(args.Result);
}
catch (Exception)
{
if (args.Error != null)
{
CoreManager.ServerCore.StandardOut.Error("Game Socket Manager", CoreManager.ServerCore.StringLocale.GetString("CORE:ERROR_NETWORK_CONNECTION_KILLED"));
Console.WriteLine();
Console.WriteLine(args.Error.Message);
Console.WriteLine(args.Error.StackTrace);
}
}
}
private void IncomingConnectedAccepted(AsyncResultEventArgs <ServerChildTcpSocket> args)
{
if (args.Error != null)
{
string dumpPath = CoreManager.ServerCore.DumpException(args.Error);
CoreManager.ServerCore.ConsoleManager.Error("Game Socket Manager", "Incoming connection failed!!");
CoreManager.ServerCore.ConsoleManager.Error("Game Socket Manager", " An exception dump has been saved to " + dumpPath);
_listeningSocket.AcceptAsync();
return;
}
ServerChildTcpSocket internalSocket = args.Result;
GameSocket socket = new GameSocket(internalSocket, this);
GameSocketEventArgs eventArgs = new GameSocketEventArgs(socket);
CoreManager.ServerCore.OfficalEventFirer.Fire("incoming_game_connection:before", eventArgs);
if (eventArgs.IsCancelled)
{
socket.Disconnect("Connection rejected from " + internalSocket.RemoteEndPoint + "(" + eventArgs.CancelReason + ")");
return;
}
socket.Start();
CoreManager.ServerCore.OfficalEventFirer.Fire("incoming_game_connection:after", eventArgs);
CoreManager.ServerCore.ConsoleManager.Notice("Game Socket Manager", "Incoming connection accepted: " + internalSocket.RemoteEndPoint);
_listeningSocket.AcceptAsync();
}
private void ListeningSocket_ConnectionArrived(AsyncResultEventArgs <SimpleServerChildTcpSocket> e)
{
// Check for errors
if (e.Error != null)
{
ResetListeningSocket();
textBoxLog.AppendText("Socket error during Accept: [" + e.Error.GetType().Name + "] " + e.Error.Message + Environment.NewLine);
RefreshDisplay();
return;
}
SimpleServerChildTcpSocket socket = e.Result;
try
{
// Save the new child socket connection
ChildSockets.Add(socket, ChildSocketState.Connected);
socket.PacketArrived += (args) => ChildSocket_PacketArrived(socket, args);
socket.WriteCompleted += (args) => ChildSocket_WriteCompleted(socket, args);
socket.ShutdownCompleted += (args) => ChildSocket_ShutdownCompleted(socket, args);
// Display the connection information
textBoxLog.AppendText("Connection established to " + socket.RemoteEndPoint.ToString() + Environment.NewLine);
}
catch (Exception ex)
{
ResetChildSocket(socket);
textBoxLog.AppendText("Socket error accepting connection: [" + ex.GetType().Name + "] " + ex.Message + Environment.NewLine);
}
finally
{
RefreshDisplay();
}
}
/// <summary>
/// Handles the <see cref="ServerTcpSocket.AcceptCompleted"/> event by restarting the accept operation and notifying the user of a listen
/// operation completion.
/// </summary>
/// <param name="e">The results of the accept operation.</param>
private void SocketAcceptCompleted(AsyncResultEventArgs <ServerChildTcpSocket> e)
{
Socket.AcceptAsync();
if (ConnectionArrived != null)
{
ConnectionArrived(ConvertArgs(e));
}
}
/// <summary>
/// Converts the results of an accept operation on a <see cref="ServerTcpSocket"/> to the results of a listen operation on a
/// <see cref="SimpleServerTcpSocket"/>.
/// </summary>
/// <param name="e">The results of the accept operation.</param>
/// <returns>The results of the listen operation.</returns>
private static AsyncResultEventArgs <SimpleServerChildTcpSocket> ConvertArgs(AsyncResultEventArgs <ServerChildTcpSocket> e)
{
if (e.Error != null)
{
return(new AsyncResultEventArgs <SimpleServerChildTcpSocket>(e.Error));
}
return(new AsyncResultEventArgs <SimpleServerChildTcpSocket>(new SimpleServerChildTcpSocket(e.Result)));
}
private void SocketReadCompleted(AsyncResultEventArgs <int> args)
{
if (args.Error != null)
{
if (PacketArrived != null)
{
PacketArrived.Invoke(new AsyncResultEventArgs <byte[]>(args.Error));
}
return;
}
_bytesReceived += args.Result;
if (args.Result == 0)
{
if (PacketArrived != null)
{
PacketArrived.Invoke(new AsyncResultEventArgs <byte[]>(null as byte[]));
}
return;
}
if (_dataBuffer == null)
{
if (_bytesReceived != Protocol.Reader.LengthBytes)
{
ContinueReading();
}
else
{
int length = Protocol.Reader.ParseLength(_lengthBuffer);
_dataBuffer = new byte[length];
_bytesReceived = 0;
ContinueReading();
}
}
else
{
if (_bytesReceived != _dataBuffer.Length)
{
ContinueReading();
}
else
{
if (PacketArrived != null)
{
PacketArrived.Invoke(new AsyncResultEventArgs <byte[]>(_dataBuffer));
}
_dataBuffer = null;
_bytesReceived = 0;
ContinueReading();
}
}
}
private void ChildSocket_PacketArrived(ServerChildTcpSocket socket, AsyncResultEventArgs <byte[]> e)
{
try
{
// Check for errors
if (e.Error != null)
{
textBoxLog.AppendText("Client socket error during Read from " + socket.RemoteEndPoint.ToString() + ": [" + e.Error.GetType().Name + "] " + e.Error.Message + Environment.NewLine);
ResetChildSocket(socket);
}
else if (e.Result == null)
{
// PacketArrived completes with a null packet when the other side gracefully closes the connection
textBoxLog.AppendText("Socket graceful close detected from " + socket.RemoteEndPoint.ToString() + Environment.NewLine);
// Close the socket and remove it from the list
ResetChildSocket(socket);
}
else
{
// At this point, we know we actually got a message.
// Deserialize the message
object message = Messages.Util.Deserialize(e.Result);
// Handle the message
Messages.StringMessage stringMessage = message as Messages.StringMessage;
if (stringMessage != null)
{
textBoxLog.AppendText("Socket read got a string message from " + socket.RemoteEndPoint.ToString() + ": " + stringMessage.Message + Environment.NewLine);
return;
}
Messages.ComplexMessage complexMessage = message as Messages.ComplexMessage;
if (complexMessage != null)
{
textBoxLog.AppendText("Socket read got a complex message from " + socket.RemoteEndPoint.ToString() + ": (UniqueID = " + complexMessage.UniqueID.ToString() +
", Time = " + complexMessage.Time.ToString() + ", Message = " + complexMessage.Message + ")" + Environment.NewLine);
return;
}
textBoxLog.AppendText("Socket read got an unknown message from " + socket.RemoteEndPoint.ToString() + " of type " + message.GetType().Name + Environment.NewLine);
}
}
catch (Exception ex)
{
textBoxLog.AppendText("Error reading from socket " + socket.RemoteEndPoint.ToString() + ": [" + ex.GetType().Name + "] " + ex.Message + Environment.NewLine);
ResetChildSocket(socket);
}
finally
{
RefreshDisplay();
}
}
private void ListeningSocket_AcceptCompleted(AsyncResultEventArgs <ServerChildTcpSocket> e)
{
// Check for errors
if (e.Error != null)
{
ResetListeningSocket();
textBoxLog.AppendText("Socket error during Accept: [" + e.Error.GetType().Name + "] " + e.Error.Message + Environment.NewLine);
RefreshDisplay();
return;
}
// Always continue listening for other connections
ListeningSocket.AcceptAsync();
ServerChildTcpSocket socket = e.Result;
try
{
// Save the new child socket connection, and create a packetizer for it
SocketPacketProtocol protocol = new SocketPacketProtocol(socket);
ChildSocketContext context = new ChildSocketContext();
context.Protocol = protocol;
context.State = ChildSocketState.Connected;
ChildSockets.Add(socket, context);
protocol.PacketArrived += (args) => ChildSocket_PacketArrived(socket, args);
socket.WriteCompleted += (args) => ChildSocket_WriteCompleted(socket, args);
socket.ShutdownCompleted += (args) => ChildSocket_ShutdownCompleted(socket, args);
// Display the connection information
textBoxLog.AppendText("Connection established to " + socket.RemoteEndPoint.ToString() + Environment.NewLine);
// Start reading data from the connection
protocol.Start();
}
catch (Exception ex)
{
ResetChildSocket(socket);
textBoxLog.AppendText("Socket error accepting connection: [" + ex.GetType().Name + "] " + ex.Message + Environment.NewLine);
}
finally
{
RefreshDisplay();
}
}
private void ChildSocket_PacketArrived(SimpleServerChildTcpSocket socket, AsyncResultEventArgs<byte[]> e)
{
try
{
// Check for errors
if (e.Error != null)
{
ConsoleService.Write("Client socket error during Read from " + socket.RemoteEndPoint + ": [" + e.Error.GetType().Name + "] " + e.Error.Message);
ResetChildSocket(socket);
}
else if (e.Result == null)
{
// PacketArrived completes with a null packet when the other side gracefully closes the connection
ConsoleService.Write("Socket graceful close detected from " + socket.RemoteEndPoint);
// Close the socket and remove it from the list
ResetChildSocket(socket);
}
else
{
// At this point, we know we actually got a message.
// Deserialize the message
object message = SerializationHelper.Deserialize(e.Result);
// Handle the message
if(HandleMessage(message, socket) == false)
{
ConsoleService.Write("Socket read got an unknown message from " + socket.RemoteEndPoint + " of type " + message.GetType().Name);
}
}
}
catch (Exception ex)
{
ConsoleService.Write("Error reading from socket " + socket.RemoteEndPoint + ": [" + ex.GetType().Name + "] " + ex.Message);
ResetChildSocket(socket);
}
finally
{
RefreshDisplay();
}
}
private void ClientSocket_PacketArrived(AsyncResultEventArgs<byte[]> e)
{
try
{
// Check for errors
if (e.Error != null)
{
ResetSocket();
Console.WriteLine("Socket error during Read: [" + e.Error.GetType().Name + "] " + e.Error.Message);
}
else if (e.Result == null)
{
// PacketArrived completes with a null packet when the other side gracefully closes the connection
Console.WriteLine("Socket graceful close detected");
// Close the socket and handle the state transition to disconnected.
ResetSocket();
}
else
{
// At this point, we know we actually got a message.
// Deserialize the message
object message = SerializationHelper.Deserialize(e.Result);
if(HandleMessages(message) == false)
{
Console.WriteLine("Socket read got an unknown message of type " + message.GetType().Name);
}
}
}
catch (Exception ex)
{
ResetSocket();
Console.WriteLine("Error reading from socket: [" + ex.GetType().Name + "] " + ex.Message);
}
finally
{
RefreshDisplay();
}
}
private void ListeningSocket_ConnectionArrived(AsyncResultEventArgs<SimpleServerChildTcpSocket> e)
{
// Check for errors
if (e.Error != null)
{
ResetListeningSocket();
ConsoleService.Write("Socket error during Accept: [" + e.Error.GetType().Name + "] " + e.Error.Message);
RefreshDisplay();
return;
}
SimpleServerChildTcpSocket socket = e.Result;
try
{
// Save the new child socket connection
Server.ChildSockets.Add(socket, ChildSocketState.Connected);
Server.Clients.Add(socket, new ClientModel
{
RemoteEndPoint = socket.RemoteEndPoint.ToString()
});
if (OnClientAddedHandler != null) OnClientAddedHandler(this, new OnClientAddedEventArgs(Server.Clients[socket]));
socket.PacketArrived += args => ChildSocket_PacketArrived(socket, args);
socket.WriteCompleted += args => ChildSocket_WriteCompleted(socket, args);
socket.ShutdownCompleted += args => ChildSocket_ShutdownCompleted(socket, args);
// Display the connection information
ConsoleService.Write("Connection established to " + socket.RemoteEndPoint);
}
catch (Exception ex)
{
ResetChildSocket(socket);
ConsoleService.Write("Socket error accepting connection: [" + ex.GetType().Name + "] " + ex.Message);
}
finally
{
RefreshDisplay();
}
}
/// <summary>
/// Converts the results of an accept operation on a <see cref="ServerTcpSocket"/> to the results of a listen operation on a
/// <see cref="SimpleServerTcpSocket"/>.
/// </summary>
/// <param name="e">The results of the accept operation.</param>
/// <returns>The results of the listen operation.</returns>
private static AsyncResultEventArgs<SimpleServerChildTcpSocket> ConvertArgs(AsyncResultEventArgs<ServerChildTcpSocket> e)
{
if (e.Error != null)
return new AsyncResultEventArgs<SimpleServerChildTcpSocket>(e.Error);
return new AsyncResultEventArgs<SimpleServerChildTcpSocket>(new SimpleServerChildTcpSocket(e.Result));
}
public void Result_ForSuccessfulArgsFullConstructor_IsPreserved()
{
var test = new AsyncResultEventArgs<int>(13, null, false, null);
Assert.AreEqual(13, test.Result, "Successful event args did not preserve result");
}
public void ReadingResult_ForFailedArgsFullConstructor_ThrowsTargetInvocationException()
{
var test = new AsyncResultEventArgs<int>(0, new Exception(), false, null);
Trace.WriteLine(test.Result);
}
public void Result_ForSuccessfulArgs_IsPreserved()
{
var test = new AsyncResultEventArgs<int>(13);
Assert.AreEqual(13, test.Result, "Successful event args did not preserve result");
}
public void Result_ForSuccessfulArgsFullConstructor_IsPreserved()
{
var test = new AsyncResultEventArgs <int>(13, null, false, null);
Assert.AreEqual(13, test.Result, "Successful event args did not preserve result");
}
public void CancelledProperty_ForCancelledArgsFullConstructor_IsTrue()
{
var test = new AsyncResultEventArgs<int>(0, null, true, null);
Assert.IsTrue(test.Cancelled, "Cancelled event args should be cancelled");
}
private void ChildSocket_PacketArrived(SimpleServerChildTcpSocket socket, AsyncResultEventArgs<byte[]> e)
{
try
{
// Check for errors
if (e.Error != null)
{
ConsoleService.Write("Client socket error during Read from " + socket.RemoteEndPoint + ": [" + e.Error.GetType().Name + "] " + e.Error.Message);
ResetChildSocket(socket);
}
else if (e.Result == null)
{
// PacketArrived completes with a null packet when the other side gracefully closes the connection
ConsoleService.Write("Socket graceful close detected from " + socket.RemoteEndPoint);
// Close the socket and remove it from the list
ResetChildSocket(socket);
}
else
{
// At this point, we know we actually got a message.
// Deserialize the message
object message = SerializationHelper.Deserialize(e.Result);
// Handle the message
if(HandleMessage(message, socket) == false)
{
ConsoleService.Write("Socket read got an unknown message from " + socket.RemoteEndPoint + " of type " + message.GetType().Name);
}
}
}
catch (Exception ex)
{
ConsoleService.Write("Error reading from socket " + socket.RemoteEndPoint + ": [" + ex.GetType().Name + "] " + ex.Message);
ResetChildSocket(socket);
}
finally
{
RefreshDisplay();
}
}
private void ListeningSocket_ConnectionArrived(AsyncResultEventArgs<SimpleServerChildTcpSocket> e)
{
// Check for errors
if (e.Error != null)
{
ResetListeningSocket();
ConsoleService.Write("Socket error during Accept: [" + e.Error.GetType().Name + "] " + e.Error.Message);
RefreshDisplay();
return;
}
SimpleServerChildTcpSocket socket = e.Result;
try
{
// Save the new child socket connection
Server.ChildSockets.Add(socket, ChildSocketState.Connected);
Server.Clients.Add(socket, new ClientModel
{
RemoteEndPoint = socket.RemoteEndPoint.ToString()
});
if (OnClientAddedHandler != null) OnClientAddedHandler(this, new OnClientAddedEventArgs(Server.Clients[socket]));
socket.PacketArrived += args => ChildSocket_PacketArrived(socket, args);
socket.WriteCompleted += args => ChildSocket_WriteCompleted(socket, args);
socket.ShutdownCompleted += args => ChildSocket_ShutdownCompleted(socket, args);
// Display the connection information
ConsoleService.Write("Connection established to " + socket.RemoteEndPoint);
}
catch (Exception ex)
{
ResetChildSocket(socket);
ConsoleService.Write("Socket error accepting connection: [" + ex.GetType().Name + "] " + ex.Message);
}
finally
{
RefreshDisplay();
}
}
public void CancelledProperty_ForSuccessfulArgs_IsFalse()
{
var test = new AsyncResultEventArgs<int>(13);
Assert.IsFalse(test.Cancelled, "Successful event args should not be cancelled");
}
public void CancelledProperty_ForSuccessfulArgsFullConstructor_IsFalse()
{
var test = new AsyncResultEventArgs<int>(13, null, false, null);
Assert.IsFalse(test.Cancelled, "Successful event args should not be cancelled");
}
public void Error_ForCancelledArgsFullConstructor_IsNull()
{
var test = new AsyncResultEventArgs<int>(0, null, true, null);
Assert.IsNull(test.Error, "Cancelled event args should not preserve exception");
}
public void Error_ForSuccessfulArgsFullConstructor_IsNull()
{
var test = new AsyncResultEventArgs<int>(13, null, false, null);
Assert.IsNull(test.Error, "Successful event args should not preserve exception");
}
/// <summary>
/// Called when a socket read completes. Parses the received data and calls <see cref="PacketArrived"/> if necessary.
/// </summary>
/// <param name="e">Argument object containing the number of bytes read.</param>
/// <exception cref="System.IO.InvalidDataException">If the data received is not a packet.</exception>
private void SocketReadCompleted(AsyncResultEventArgs<int> e)
{
// Pass along read errors verbatim
if (e.Error != null)
{
if (PacketArrived != null)
{
PacketArrived(new AsyncResultEventArgs<byte[]>(e.Error));
}
return;
}
// Get the number of bytes read into the buffer
_bytesReceived += e.Result;
// If we get a zero-length read, then that indicates the remote side graciously closed the connection
if (e.Result == 0)
{
if (PacketArrived != null)
{
PacketArrived(new AsyncResultEventArgs<byte[]>((byte[])null));
}
return;
}
// Loop thorugh received transactions and split them into Modbus responses, calling client OnResponseData for each
int resultptr = 0;
while (resultptr < e.Result)
{
byte[] data;
ushort id = SwapUInt16(BitConverter.ToUInt16(_tcpAsyClBuffer, resultptr));
byte unit = _tcpAsyClBuffer[resultptr + 6];
byte function = _tcpAsyClBuffer[resultptr + 7];
switch (function)
{
// Text Read data - always 128 bytes + 12 byte header
case 65:
data = new byte[128];
Array.Copy(_tcpAsyClBuffer, resultptr + 12, data, 0, 128);
resultptr = resultptr + 140;
break;
case 1:
data = new byte[_tcpAsyClBuffer[resultptr + 5] + 6];
Array.Copy(_tcpAsyClBuffer, resultptr, data, 0, _tcpAsyClBuffer[resultptr + 5] + 6);
resultptr = resultptr + _tcpAsyClBuffer[resultptr + 5] + 6;
break;
//data = new byte[1];
//Array.Copy(_tcpAsyClBuffer, resultptr + 9, data, 0, 1);
//resultptr = resultptr + 10;
//break;
case 3:
//00 01 00 00 00 06 01 03 00 20 00 01
//00 01 00 00 00 06 01 03 1B B1 00 01
data = new byte[_tcpAsyClBuffer[resultptr + 5] + 6];
Array.Copy(_tcpAsyClBuffer, resultptr, data, 0, _tcpAsyClBuffer[resultptr + 5] + 6);
resultptr = resultptr + _tcpAsyClBuffer[resultptr + 5] + 6;
break;
//data = new byte[tcpAsyClBuffer[resultptr + 8]];
//Array.Copy(tcpAsyClBuffer, resultptr + 9, data, 0, tcpAsyClBuffer[resultptr + 8]);
//resultptr = resultptr + 9 + tcpAsyClBuffer[resultptr + 8];
//break;
default:
// Any other write operation returns address written to
data = new byte[2];
Array.Copy(_tcpAsyClBuffer, resultptr + 10, data, 0, 2);
resultptr = resultptr + 10;
break;
}
if (PacketArrived != null)
{
PacketArrived(new AsyncResultEventArgs<byte[]>(data));
}
}
_bytesReceived = 0;
ContinueReading();
}
public void Exception_ForFailedArgs_IsPreserved()
{
Exception error = new Exception();
var test = new AsyncResultEventArgs<int>(error);
Assert.AreSame(error, test.Error, "Failed event args did not preserve exception");
}
public void UserState_ForFailedArgsFullConstructor_IsPreserved()
{
object state = new object();
var test = new AsyncResultEventArgs<int>(0, new Exception(), false, state);
Assert.AreSame(state, test.UserState, "Failed event args did not preserve user state");
}
public void Exception_ForFailedArgsFullConstructor_IsPreserved()
{
Exception error = new Exception();
var test = new AsyncResultEventArgs<int>(0, error, false, null);
Assert.AreSame(error, test.Error, "Failed event args did not preserve exception");
}
public void ReadingResult_ForFailedArgsFullConstructor_ThrowsTargetInvocationException()
{
var test = new AsyncResultEventArgs <int>(0, new Exception(), false, null);
Trace.WriteLine(test.Result);
}
public void CancelledProperty_ForFailedArgsFullConstructor_IsFalse()
{
var test = new AsyncResultEventArgs <int>(0, new Exception(), false, null);
Assert.IsFalse(test.Cancelled, "Failed event args should not be cancelled");
}
public void Error_ForCancelledArgsFullConstructor_IsNull()
{
var test = new AsyncResultEventArgs <int>(0, null, true, null);
Assert.IsNull(test.Error, "Cancelled event args should not preserve exception");
}
public void UserState_ForSuccessfulArgsFullConstructor_IsPreserved()
{
object state = new object();
var test = new AsyncResultEventArgs<int>(13, null, false, state);
Assert.AreSame(state, test.UserState, "Successful event args did not preserve user state");
}
public void ReadingResult_ForCancelledArgsFullConstructor_ThrowsInvalidOperationException()
{
var test = new AsyncResultEventArgs<int>(0, null, true, null);
Trace.WriteLine(test.Result);
}
public void ReadingResult_ForFailedArgs_ThrowsTargetInvocationException()
{
var test = new AsyncResultEventArgs <int>(new Exception());
Trace.WriteLine(test.Result);
}
public void CancelledProperty_ForFailedArgs_IsFalse()
{
var test = new AsyncResultEventArgs<int>(new Exception());
Assert.IsFalse(test.Cancelled, "Failed event args should not be cancelled");
}
public void CancelledProperty_ForCancelledArgsFullConstructor_IsTrue()
{
var test = new AsyncResultEventArgs <int>(0, null, true, null);
Assert.IsTrue(test.Cancelled, "Cancelled event args should be cancelled");
}
public void CancelledProperty_ForSuccessfulArgsFullConstructor_IsFalse()
{
var test = new AsyncResultEventArgs <int>(13, null, false, null);
Assert.IsFalse(test.Cancelled, "Successful event args should not be cancelled");
}
public void UserState_ForCancelledArgsFullConstructor_IsPreserved()
{
object state = new object();
var test = new AsyncResultEventArgs<int>(0, null, true, state);
Assert.AreSame(state, test.UserState, "Cancelled event args did not preserve user state");
}
public void Error_ForSuccessfulArgs_IsNull()
{
var test = new AsyncResultEventArgs <int>(13);
Assert.IsNull(test.Error, "Successful event args should not preserve exception");
}
private void ClientSocket_PacketArrived(AsyncResultEventArgs<byte[]> e)
{
try
{
// Check for errors
if (e.Error != null)
{
ResetSocket();
Console.WriteLine("Socket error during Read: [" + e.Error.GetType().Name + "] " + e.Error.Message);
}
else if (e.Result == null)
{
// PacketArrived completes with a null packet when the other side gracefully closes the connection
Console.WriteLine("Socket graceful close detected");
// Close the socket and handle the state transition to disconnected.
ResetSocket();
}
else
{
// At this point, we know we actually got a message.
// Deserialize the message
object message = SerializationHelper.Deserialize(e.Result);
if(HandleMessages(message) == false)
{
Console.WriteLine("Socket read got an unknown message of type " + message.GetType().Name);
}
}
}
catch (Exception ex)
{
ResetSocket();
Console.WriteLine("Error reading from socket: [" + ex.GetType().Name + "] " + ex.Message);
}
finally
{
RefreshDisplay();
}
}
public void Error_ForSuccessfulArgsFullConstructor_IsNull()
{
var test = new AsyncResultEventArgs <int>(13, null, false, null);
Assert.IsNull(test.Error, "Successful event args should not preserve exception");
}
/// <summary>
/// Handles the <see cref="ServerTcpSocket.AcceptCompleted"/> event by restarting the accept operation and notifying the user of a listen
/// operation completion.
/// </summary>
/// <param name="e">The results of the accept operation.</param>
private void SocketAcceptCompleted(AsyncResultEventArgs<ServerChildTcpSocket> e)
{
Socket.AcceptAsync();
if (ConnectionArrived != null)
ConnectionArrived(ConvertArgs(e));
}
public void CancelledProperty_ForFailedArgsFullConstructor_IsFalse()
{
var test = new AsyncResultEventArgs<int>(0, new Exception(), false, null);
Assert.IsFalse(test.Cancelled, "Failed event args should not be cancelled");
}
public void ReadingResult_ForFailedArgs_ThrowsTargetInvocationException()
{
var test = new AsyncResultEventArgs<int>(new Exception());
Trace.WriteLine(test.Result);
}
public void CancelledProperty_ForFailedArgs_IsFalse()
{
var test = new AsyncResultEventArgs <int>(new Exception());
Assert.IsFalse(test.Cancelled, "Failed event args should not be cancelled");
}
/// <summary>
/// Called when a socket read completes. Parses the received data and calls <see cref="PacketArrived"/> if necessary.
/// </summary>
/// <param name="e">Argument object containing the number of bytes read.</param>
/// <exception cref="System.IO.InvalidDataException">If the data received is not a packet.</exception>
private void SocketReadCompleted(AsyncResultEventArgs <int> e)
{
// Pass along read errors verbatim
if (e.Error != null)
{
if (this.PacketArrived != null)
{
this.PacketArrived(new AsyncResultEventArgs <byte[]>(e.Error));
}
return;
}
// Get the number of bytes read into the buffer
this.bytesReceived += e.Result;
// If we get a zero-length read, then that indicates the remote side graciously closed the connection
if (e.Result == 0)
{
if (this.PacketArrived != null)
{
this.PacketArrived(new AsyncResultEventArgs <byte[]>((byte[])null));
}
return;
}
if (this.dataBuffer == null)
{
// (We're currently receiving the length buffer)
if (this.bytesReceived != sizeof(int))
{
// We haven't gotten all the length buffer yet
this.ContinueReading();
}
else
{
// We've gotten the length buffer
int length = BitConverter.ToInt32(this.lengthBuffer, 0);
// Sanity check for length < 0
// This check will catch 50% of transmission errors that make it past both the IP and Ethernet checksums
if (length < 0)
{
if (this.PacketArrived != null)
{
this.PacketArrived(new AsyncResultEventArgs <byte[]>(new System.IO.InvalidDataException("Packet length less than zero (corrupted message)")));
}
return;
}
// Zero-length packets are allowed as keepalives
if (length == 0)
{
this.bytesReceived = 0;
this.ContinueReading();
}
else
{
// Create the data buffer and start reading into it
this.dataBuffer = new byte[length];
this.bytesReceived = 0;
this.ContinueReading();
}
}
}
else
{
if (this.bytesReceived != this.dataBuffer.Length)
{
// We haven't gotten all the data buffer yet
this.ContinueReading();
}
else
{
// We've gotten an entire packet
if (this.PacketArrived != null)
{
this.PacketArrived(new AsyncResultEventArgs <byte[]>(this.dataBuffer));
}
// Start reading the length buffer again
this.dataBuffer = null;
this.bytesReceived = 0;
this.ContinueReading();
}
}
}
public void Result_ForSuccessfulArgs_IsPreserved()
{
var test = new AsyncResultEventArgs <int>(13);
Assert.AreEqual(13, test.Result, "Successful event args did not preserve result");
}
private void ParsePacket(AsyncResultEventArgs<byte[]> args)
{
try
{
if (args.Error != null)
throw args.Error;
if (args.Result == null)
{
if (Habbo.LoggedIn)
Habbo.LoggedIn = false;
Disconnect("Socket read error!");
return;
}
ParseByteData(args.Result);
}
catch (Exception)
{
if (args.Error != null)
{
CoreManager.ServerCore.StandardOut.Error("Game Socket Manager", CoreManager.ServerCore.StringLocale.GetString("CORE:ERROR_NETWORK_CONNECTION_KILLED"));
Console.WriteLine();
Console.WriteLine(args.Error.Message);
Console.WriteLine(args.Error.StackTrace);
}
}
}
public void Error_ForSuccessfulArgs_IsNull()
{
var test = new AsyncResultEventArgs<int>(13);
Assert.IsNull(test.Error, "Successful event args should not preserve exception");
}
/// <summary>
/// Called when a socket read completes. Parses the received data and calls <see cref="PacketArrived"/> if necessary.
/// </summary>
/// <param name="e">Argument object containing the number of bytes read.</param>
/// <exception cref="System.IO.InvalidDataException">If the data received is not a packet.</exception>
private void SocketReadCompleted(AsyncResultEventArgs<int> e)
{
// Pass along read errors verbatim
if (e.Error != null)
{
if (PacketArrived != null)
{
PacketArrived(new AsyncResultEventArgs<byte[]>(e.Error));
}
return;
}
// Get the number of bytes read into the buffer
bytesReceived += e.Result;
// If we get a zero-length read, then that indicates the remote side graciously closed the connection
if (e.Result == 0)
{
if (PacketArrived != null)
{
PacketArrived(new AsyncResultEventArgs<byte[]>((byte[])null));
}
return;
}
if (dataBuffer == null)
{
// (We're currently receiving the length buffer)
if (bytesReceived != sizeof(int))
{
// We haven't gotten all the length buffer yet
ContinueReading();
}
else
{
// We've gotten the length buffer
int length = BitConverter.ToInt32(lengthBuffer, 0);
// Sanity check for length < 0
// This check will catch 50% of transmission errors that make it past both the IP and Ethernet checksums
if (length < 0)
{
if (PacketArrived != null)
{
PacketArrived(new AsyncResultEventArgs<byte[]>(new InvalidDataException("Packet length less than zero (corrupted message)")));
}
return;
}
// Zero-length packets are allowed as keepalives
if (length == 0)
{
bytesReceived = 0;
ContinueReading();
}
else
{
// Create the data buffer and start reading into it
dataBuffer = new byte[length];
bytesReceived = 0;
ContinueReading();
}
}
}
else
{
if (bytesReceived != dataBuffer.Length)
{
// We haven't gotten all the data buffer yet
ContinueReading();
}
else
{
// We've gotten an entire packet
if (PacketArrived != null)
{
PacketArrived(new AsyncResultEventArgs<byte[]>(dataBuffer));
}
// Start reading the length buffer again
dataBuffer = null;
bytesReceived = 0;
ContinueReading();
}
}
}
private void SocketReadCompleted(AsyncResultEventArgs<int> args)
{
if (args.Error != null)
{
if (PacketArrived != null)
PacketArrived.Invoke(new AsyncResultEventArgs<byte[]>(args.Error));
return;
}
_bytesReceived += args.Result;
if (args.Result == 0)
{
if (PacketArrived != null)
PacketArrived.Invoke(new AsyncResultEventArgs<byte[]>(null as byte[]));
return;
}
if (_dataBuffer == null)
{
if (_bytesReceived != Protocol.Reader.LengthBytes)
{
ContinueReading();
}
else
{
int length = Protocol.Reader.ParseLength(_lengthBuffer);
_dataBuffer = new byte[length];
_bytesReceived = 0;
ContinueReading();
}
}
else
{
if (_bytesReceived != _dataBuffer.Length)
{
ContinueReading();
}
else
{
if (PacketArrived != null)
PacketArrived.Invoke(new AsyncResultEventArgs<byte[]>(_dataBuffer));
_dataBuffer = null;
_bytesReceived = 0;
ContinueReading();
}
}
}
