public async void Read()
{
try
{
while (true)
{
var buffer = new byte[2];
var bytesRead = await _nstream.ReadAsync(buffer, 0, 2);
if (bytesRead != 2)
{
throw new Exception("Wrong packet");
}
var length = BitConverter.ToInt16(buffer, 0);
buffer = new byte[length];
bytesRead = await _nstream.ReadAsync(buffer, 0, length);
if (bytesRead != length)
{
throw new Exception("Wrong packet");
}
_packetHandler.Handle(new Packet(1, buffer), this);
}
}
catch (Exception e)
{
Log.Error($"ServerThread: {e.Message}");
Termination();
}
}
/// <summary>
/// Handle new connection messages
/// </summary>
/// <param name="connection">Connection that send the message</param>
/// <param name="data">Message raw data</param>
private void NewConnectionHandler(InputConnection connection, MemoryStream data)
{
try
{
List <Packet> messages = PacketHandler.Handle(data);
Packet firstMessage = messages.FirstOrDefault();
_logger.Trace($"Client => Server: {firstMessage?.ToString()}");
switch (firstMessage?.Type) // FIX: RequestID is always an only packet?
{
case PacketType.HttpRequest:
if (this._httpServerPort > 0)
{
connection.Send(Encoding.ASCII.GetBytes(
"HTTP/1.1 301 Moved Permanently\nLocation: http://" +
this._localEndPoint.Address.ToString() +
(this._httpServerPort != 80 ? ":" + this._httpServerPort.ToString() : "") +
"\nConnection: close\n\n")); // TODO: Set public IP or domain
}
else
{
connection.Send(Encoding.ASCII.GetBytes(
"HTTP/1.1 503 Service Unavailable\nConnection: close\n\nThis is not a web server"));
}
connection.Disconnect();
break;
case PacketType.RequestID:
RequestIdPacket reqId = firstMessage as RequestIdPacket;
Player newPlayer = new Player(reqId?.Name, connection);
// TODO: Check bans. connection.Send(ResponseIdPacket.RejectPlayer().ToBinary());
this.AddPlayer(newPlayer);
break;
default:
_logger.Warning(
$"Packet not expected on new connection from {connection.Ip}: {Enum.GetName(typeof(PacketType), firstMessage?.Type)}");
break;
}
if (messages.Count > 1)
{
_logger.Warning("Multiple messages on new connection not expected.");
}
}
catch (UnrecognizedPacketException ex)
{
_logger.Warning($"Unrecognized packet from client {connection.Ip}: {ex.Message}");
connection.Disconnect();
}
catch (VersionNotFoundException ex)
{
_logger.Warning($"Protocol version mismatch from client {connection.Ip}: {ex.Message}");
connection.Disconnect();
}
// Remove new connection handler. This isn't new already.
connection.OnMessage -= this._newConnectionEventHandler;
}
private static void ReceiveCallback(IAsyncResult AR)
{
Socket current = (Socket)AR.AsyncState;
int received;
try
{
received = current.EndReceive(AR);
if (received > 0)
{
byte[] recBuf = new byte[received];
Array.Copy(_Buffer, recBuf, received);
PacketHandler.Handle(recBuf, current);
if (current.Connected)
{
current.BeginReceive(_Buffer, 0, _BUFFER_SIZE, SocketFlags.None, ReceiveCallback, current);
}
}
}
catch (SocketException e)
{
Console.WriteLine("Client forcefully disconnected" + e.Message);
current.Close(); // Dont shutdown because the socket may be disposed and its disconnected anyway
_ClientSockets.Remove(current);
return;
}
}
private void ReceiveCallback(IAsyncResult result)
{
ConnectionInfo connection = result.AsyncState as ConnectionInfo;
try
{
Socket clientSocket = connection.socket;
SocketError response;
int buffSize = clientSocket.EndReceive(result, out response);
if (response == SocketError.Success)
{
byte[] packet = new byte[buffSize];
Array.Copy(connection.data, packet, packet.Length);
PacketHandler.Handle(packet, clientSocket);
}
}
catch (Exception e)
{
Console.WriteLine($"Can't receive data from Client, {e.Message}");
}
finally
{
try
{
connection.socket.BeginReceive(connection.data, 0, connection.data.Length, SocketFlags.None, ReceiveCallback, connection);
}
catch (Exception e)
{
Console.WriteLine($"{e.Message}");
connection.socket.Close();
}
}
}
public void ReceiveCallBack(IAsyncResult resultConnection)
{
Socket clientSocket = (Socket)resultConnection.AsyncState;
try
{
Thread threadDataElement = new Thread(new ThreadStart(() => {
int bufferLength = _socket.EndReceive(resultConnection);
byte[] packet = new byte[bufferLength];
Buffer.BlockCopy(_buffer, 0, packet, 0, packet.Length);
ph.Handle(packet,
clientSocket);
}));
threadDataList.Add(threadDataElement);
threadDataElement.Start();
}
catch (SocketException e)
{
Console.WriteLine("[-] Connexion had to be closed because the host ended the connection...");
Environment.Exit(0);
}
_buffer = new byte[1024];
_socket.BeginReceive(
_buffer,
0,
_buffer.Length,
SocketFlags.None,
ReceiveCallBack,
null
);
}
/// <summary>
/// ReceivedCallback when we receive something from Socket
/// </summary>
/// <param name="result"></param>
private void ReceivedCallback(IAsyncResult result)
{
try
{
int buffLength = _socket.EndReceive(result);
byte[] packet = new byte[buffLength];
Array.Copy(_buffer, packet, packet.Length);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(packet);
}
// Handle packet
robotOutputPackage = PacketHandler.Handle(packet, packet.Length);
// Update UI
PublishEventToUI();
// Start receiving next package
StartReceiving();
}
catch (Exception ex)
{
Debug.WriteLine($"Received calback exception message: {ex.Message}");
}
}
private void arrivedData(IAsyncResult iAr)
{
try
{
int DataLength = uSocket.EndReceive(iAr);
if (DataLength > 1)
{
byte[] packetBuffer = new byte[DataLength];
Array.Copy(dataBuffer, 0, packetBuffer, 0, DataLength);
/* Decode Packet */
for (int I = 0; I < packetBuffer.Length; I++)
{
packetBuffer[I] = (byte)(packetBuffer[I] ^ 0x96);
}
PacketHandler pHandler = PacketManager.parsePacket(packetBuffer);
if (pHandler != null)
{
pHandler.Handle(this);
}
}
uSocket.BeginReceive(dataBuffer, 0, dataBuffer.Length, SocketFlags.None, new AsyncCallback(arrivedData), null);
}
catch { disconnect(); }
}
private void arrivedData(IAsyncResult iAr)
{
try
{
int num = this.uSocket.EndReceive(iAr);
if (num <= 1)
{
//this.disconnect();
}
else
{
byte[] numArray = new byte[num];
Array.Copy(this.dataBuffer, 0, numArray, 0, num);
for (int i = 0; i < (int)numArray.Length; i++)
{
numArray[i] = (byte)(numArray[i] ^ 195);
}
PacketHandler packetHandler = PacketManager.parsePacket(numArray);
if (packetHandler != null)
{
packetHandler.Handle(this);
}
this.uSocket.BeginReceive(this.dataBuffer, 0, (int)this.dataBuffer.Length, SocketFlags.None, new AsyncCallback(this.arrivedData), null);
}
}
catch
{
this.disconnect();
}
}
private void ReceivedCallback(IAsyncResult result)
{
int buffLength = _socket.EndReceive(result);
byte[] packet = new byte[buffLength];
Array.Copy(_buffer, packet, packet.Length);
// Read header for getting message size - TODO: proper implementation of this
//int pacSize = BitConverter.ToInt32(new byte[] {packet[3], packet[2], packet[1], packet[0] }, 0);
//byte[] pacBuffer = new byte[pacSize];
//_socket.Receive(pacBuffer, pacSize, SocketFlags.None);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(packet);
}
// Handle packet
double[] rp = PacketHandler.Handle(packet, packet.Length);
Application.Current.Dispatcher.Invoke(() => svm.UpdateUI(rp));
//StartReceiving();
_socket.Shutdown(SocketShutdown.Both);
_socket.Close();
}
void Update()
{
if (packetQeue.Count > 0)
{
handler.Handle(packetQeue[0], socket);
packetQeue.RemoveAt(0);
}
}
private void OnReceiveCallback(IAsyncResult result)
{
_nstream.EndRead(result);
byte[] buff = new byte[_buffer.Length];
_buffer.CopyTo(buff, 0);
_packetHandler.Handle(new Packet(1, buff), this);
Read();
}
private void ReceivedCallback(IAsyncResult result)
{
try
{
// we catch that connection we send and since AsyncState is a object so we set it as Socket to get connection
Socket ListenerSocket = result.AsyncState as Socket;
// Retrieve the state object and the handler socket
// from the asynchronous state object.
//StateObject state = (StateObject)reasult.AsyncState;
//Socket handler = state.workSocket;
//EndReceive is used to count the amount of data received
int mBufferSize = ListenerSocket.EndReceive(result);
//reciveDone.Set();
//if (bufferSize == 58 || bufferSize == 40)
//{
//it is done to store to store the data in buffer to packet
byte[] mPacket = new byte[mBufferSize];
//reciveDone.Set();
// Console.WriteLine("*********************** Listener" + IPAddress.Parse(((IPEndPoint)ListenerSocket.LocalEndPoint).Address.ToString())
// + "*********************** Speaker" + IPAddress.Parse(((IPEndPoint)ListenerSocket.RemoteEndPoint).Address.ToString()));
// it is done to create a shadow clone of buffer before anyone uses it
// this method stores the data in buffer to packet
Array.Copy(mBuffer, mPacket, mPacket.Length);
//Handle the packet
PacketHandler.Handle(mPacket, mListenerSocket);
ReceivedMessage.Set();
FSM_Listener.BGPOpenMsgRecived(Variables.True);
//}
// else
//{
mBuffer = new byte[1024];
ListenerSocket.BeginReceive(mBuffer, 0, mBuffer.Length, SocketFlags.None, ReceivedCallback, ListenerSocket);
// }
}
catch (ObjectDisposedException ex)
{
// Don't care
Console.WriteLine("Listener socket is closed");
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public void OnPacket(object?sender, IByteReader reader)
{
ushort op = reader.Read <ushort>();
PacketHandler <T>?handler = handlers.GetValueOrDefault(op);
if (sender is T session)
{
handler?.Handle(session, reader);
}
}
/// <summary>
/// Called whenever an onReceive event is received by the server, which signifies
/// an incoming packet from an existing connection.
/// </summary>
/// <param name="session">The connection's session</param>
/// <param name="data"></param>
/// <param name="bytesRead"></param>
private bool OnRecieve(ServerSession session, byte[] data, int bytesRead)
{
int packetLength = ((data[0] & 0xFF) + ((data[1] & 0xFF) << 8));
int packetOpcode = ((data[2] & 0xFF) + ((data[3] & 0xFF) << 8));
byte[] packetData = new byte[packetLength - 4];
Array.Copy(data, 4, packetData, 0, packetLength - 4);
PacketHandler handler = _packetManager.GetHandler(packetOpcode);
// Handle the incoming packet
return(handler.Handle(session, packetLength - 4, packetOpcode, packetData));
}
public override bool HijackGetData(ref byte messageType, ref BinaryReader reader, int playerNumber)
{
try
{
if (PacketHandler.CheckBlockPacket(playerNumber, messageType, ref reader))
{
return(true);
}
// 处理原版消息的地方
return(_packetHandler.Handle(messageType, ref reader, playerNumber));
}
catch (Exception ex)
{
CommandBoardcast.ConsoleError(ex);
}
return(false);
}
void ReceivedCallback(IAsyncResult result)
{
try
{
Socket clientSocket = result.AsyncState as Socket;
int bufSize = clientSocket.EndReceive(result);
byte[] buf = new byte[bufSize];
Buffer.BlockCopy(buffer, 0, buf, 0, bufSize);
//handle
PacketHandler.Handle(this, buf);
buffer = new byte[Packet.bufferMaxLength];
clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, ReceivedCallback, clientSocket);
}
catch (Exception e)
{
ConnectionClosed(this, e);
}
}
/// <summary>
/// Handle messages sended from a player
/// </summary>
/// <param name="player"></param>
/// <param name="data"></param>
/// <exception cref="NotImplementedException"></exception>
private void PlayerMessageHandler(Player player, MemoryStream data)
{
try
{
List <Packet> messages = PacketHandler.Handle(data);
messages.ForEach((message) => _logger.Trace($"Player => Server: {message.ToString()}"));
foreach (Packet message in messages)
{
switch (message.Type)
{
case PacketType.RequestJoinZone:
this.HandleJoinZoneRequest(player, (RequestJoinZonePacket)message);
break;
case PacketType.RequestSetAlias:
player.SetAlias((message as RequestSetAliasPacket)?.Alias);
break;
default:
_logger.Warning($"Unrecognized message: {message.ToString()}");
throw new NotImplementedException();
}
}
}
catch (UnrecognizedPacketException ex)
{
_logger.Warning($"Unrecognized packet from client {player.Connection.Ip}: {ex.Message}");
player.Disconnect();
}
catch (PlayerRejectedException rejected)
{
_logger.Debug($"Player {player.Name} rejected: {rejected.Message}");
// TODO: rejected.Player.SendMessage(rejected.Message);
this.RemovePlayer(rejected.Player);
}
}
public async void ReadData(TcpClient tcpClient, ServerThreadPool cn)
{
_nstream = tcpClient.GetStream();
_client = tcpClient;
Connected = true;
try
{
while (true)
{
byte[] buffer = new byte[2];
int bytesRead = await _nstream.ReadAsync(buffer, 0, 2);
if (bytesRead != 2)
{
throw new Exception("Wrong packet");
}
short length = BitConverter.ToInt16(buffer, 0);
buffer = new byte[length];
bytesRead = await _nstream.ReadAsync(buffer, 0, length);
if (bytesRead != length)
{
throw new Exception("Wrong packet");
}
Task.Factory.StartNew(() => _packetHandler.Handle(buffer.ToPacket(), this));
}
}
catch (Exception e)
{
Log.Error($"ServerThread: {e.Message}");
Termination();
}
}
private void OnPacket(ClientSocket client, byte[] buffer) => PacketHandler.Handle((Client)client.StateObject, buffer);
void AcceptNewConnection(IAsyncResult result)
{
if (listener.IsListening)
{
listener.BeginGetContext(AcceptNewConnection, null); //Сразу продолжаем прием новых запросов
}
else
{
return;
}
HttpListenerContext context = listener.EndGetContext(result);
HttpListenerRequest request = context.Request;
HttpListenerResponse response = context.Response;
Out.WriteLine("{0} {1} {2}", DateTime.Now.ToString(), request.RemoteEndPoint, request.HttpMethod);
try
{
PacketSerializer serializer = PacketSerializer.Create(request.ContentType);
if (serializer == null)
{
throw new NotSupportedException(); //вместо исключения должен быть корректный ответ об ошибке
}
//Читаем что нам прислали
Packet <IPacketContent> packet = serializer.Deserialize <IPacketContent>(request.InputStream);
if (packet == null)
{
throw new ArgumentException();
}
//Подберем обработчик
PacketHandler handler = PacketHandler.Create(packet.Version);
handler.Out = Out;
//Получаем результат
Packet <IPacketContent> responsePacket = handler.Handle(packet);
//И отправляем обратно
using (MemoryStream mstream = new MemoryStream())
{
serializer.Serialize(responsePacket, mstream);
response.ContentLength64 = mstream.Length;
response.StatusCode = 200;
mstream.Position = 0;
mstream.CopyTo(response.OutputStream);
}
}
catch (Exception ex)
{
Out.Write("General Exception");
Out.Write(ex.Message);
Out.Write(ex.StackTrace);
response.StatusCode = 500;
}
finally
{
response.OutputStream.Close();
}
}
public void HandlePacket(NetIncomingMessage inc)
{
handler.Handle(inc);
}
private void ProcessNetworkMessages()
{
NetIncomingMessage inc;
while ((inc = client.ReadMessage()) != null)
{
switch (inc.MessageType)
{
//Report changes in connection status
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)inc.ReadByte();
switch (status)
{
case NetConnectionStatus.Connected:
/*var message = new UpdatePlayerStateMessage(inc.SenderConnection.RemoteHailMessage);
* this.playerManager.AddPlayer(message.Id, message.Position, message.Velocity, message.Rotation, true);
* Console.WriteLine("Connected to {0}", inc.SenderEndPoint);*/
ConnectionSuccess("Connected to " + inc.SenderEndpoint);
break;
case NetConnectionStatus.Disconnected:
if (Entry.UserInterace != null && Entry.UserInterace.Chat != null)
{
Entry.UserInterace.Chat.Log("Lost connection to the server !");
}
string reason = "Unknown error !";
try
{
inc.ReadByte();
reason = inc.ReadString();
}
catch
{
}
ConnectionFailed(reason);
break;
case NetConnectionStatus.Disconnecting:
case NetConnectionStatus.InitiatedConnect:
case NetConnectionStatus.RespondedConnect:
Console.WriteLine(status.ToString());
break;
}
break;
case NetIncomingMessageType.ConnectionApproval:
break;
case NetIncomingMessageType.Data:
handler.Handle(inc);
break;
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.ErrorMessage:
Console.WriteLine(inc.ReadString());
break;
}
client.Recycle(inc);
}
}
public void Cycle()
{
if (!this._isStreaming)
{
return;
}
label_2:
int index1;
while (true)
{
if (!this._hasNext)
{
if (!this._stream.EndOfFile)
{
this._next = this._last + this._stream.Compressed.ReadInt32();
this._last = this._next;
this._hasNext = true;
}
else
{
break;
}
}
this._elapsed = Math.Max(this.GetTimeSample(), this._elapsed);
if (this._elapsed >= this._next)
{
this._hasNext = false;
index1 = (int)this._stream.Compressed.ReadByte();
if (index1 >= 0 && index1 < (int)byte.MaxValue)
{
PacketHandler packetHandler = PacketHandlers.m_Handlers[index1];
if (packetHandler != null)
{
int length = packetHandler.Length;
if (length < 0)
{
length = (int)this._stream.Compressed.ReadByte() << 8 | (int)this._stream.Compressed.ReadByte();
}
byte[] numArray1 = new byte[length];
int num1 = 0;
byte[] numArray2 = numArray1;
int index2 = num1;
int num2 = 1;
int index3 = index2 + num2;
int num3 = (int)(byte)index1;
numArray2[index2] = (byte)num3;
if (packetHandler.Length < 0)
{
byte[] numArray3 = numArray1;
int index4 = index3;
int num4 = 1;
int num5 = index4 + num4;
int num6 = (int)(byte)(length >> 8);
numArray3[index4] = (byte)num6;
byte[] numArray4 = numArray1;
int index5 = num5;
int num7 = 1;
index3 = index5 + num7;
int num8 = (int)(byte)length;
numArray4[index5] = (byte)num8;
}
this._stream.Compressed.Read(numArray1, index3, length - index3);
packetHandler.Handle(new PacketReader(numArray1, 0, numArray1.Length, packetHandler.Length >= 0, (byte)index1, packetHandler.Callback.Method.Name));
}
else
{
goto label_14;
}
}
else
{
goto label_22;
}
}
else
{
goto label_1;
}
}
this.Stop();
return;
label_1:
return;
label_14:
PlayUO.Debug.Trace("Bad packet {{ packetID: 0x{0:X2}; }}", (object)index1);
try
{
while (!this._stream.EndOfFile)
{
int num = this._stream.Compressed.ReadInt32();
if (num < 1000)
{
this._hasNext = true;
this._next = this._elapsed + num;
}
else
{
this._stream.Seek(-3L, SeekOrigin.Current);
}
}
goto label_2;
}
catch
{
this.Stop();
return;
}
label_22:
this.Stop();
}
private void OnDataReceived(IAsyncResult iAr)
{
try
{
int bytesReceived = socket.EndReceive(iAr);
if (bytesReceived > 0)
{
byte[] packetBuffer = new byte[bytesReceived];
Buffer.BlockCopy(buffer, 0, packetBuffer, 0, packetBuffer.Length);
// Decrypt the bytes with the xOrKey.
for (int i = 0; i < bytesReceived; i++)
{
packetBuffer[i] ^= Core.Constants.xOrKeyReceive;
}
int oldLength = cacheBuffer.Length;
Array.Resize(ref cacheBuffer, oldLength + bytesReceived);
Array.Copy(packetBuffer, 0, cacheBuffer, oldLength, packetBuffer.Length);
int startIndex = 0; // Determs whre the bytes should split
for (int i = 0; i < cacheBuffer.Length; i++)
{
// loop trough our cached buffer.
if (cacheBuffer[i] == 0x0A)
{
// Found a complete packet
byte[] newPacket = new byte[i - startIndex]; // determ the new packet size.
for (int j = 0; j < (i - startIndex); j++)
{
newPacket[j] = cacheBuffer[startIndex + j]; // copy the buffer to the buffer of the new packet.
}
// Handle the packet instantly.
InPacket inPacket = new InPacket(newPacket);
if (inPacket.Id > 0)
{
PacketHandler <User> pHandler = NetworkTable.Instance.FindExternal(inPacket);
if (pHandler != null)
{
try
{
pHandler.Handle(this, inPacket);
}
catch { /*Disconnect();*/ }
}
else
{
Console.WriteLine("UNKNOWN PACKET :: " + newPacket);
}
}
startIndex = i + 1;
}
}
if (startIndex > 0)
{
byte[] fullCopy = cacheBuffer;
Array.Resize(ref cacheBuffer, (cacheBuffer.Length - startIndex));
for (int i = 0; i < (cacheBuffer.Length - startIndex); i++)
{
cacheBuffer[i] = fullCopy[startIndex + i];
}
fullCopy = null;
}
socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(OnDataReceived), null);
}
else
{
Disconnect();
}
}
catch
{
Disconnect();
}
}
private void OnDataReceived(IAsyncResult iAr)
{
try
{
int bytesReceived = socket.EndReceive(iAr);
if (bytesReceived > 0)
{
byte[] packetBuffer = new byte[bytesReceived];
// Decrypt the bytes with the xOrKey.
for (int i = 0; i < bytesReceived; i++)
{
packetBuffer[i] = (byte)(this.buffer[i] ^ Core.Constants.xOrKeyReceive);
}
int oldLength = cacheBuffer.Length;
Array.Resize(ref cacheBuffer, oldLength + bytesReceived);
Array.Copy(packetBuffer, 0, cacheBuffer, oldLength, packetBuffer.Length);
int startIndex = 0; // Determs where the bytes should split
for (int i = 0; i < cacheBuffer.Length; i++)
{ // loop trough our cached buffer.
if (cacheBuffer[i] == 0x0A)
{ // Found a complete packet
byte[] newPacket = new byte[i - startIndex]; // determ the new packet size.
for (int j = 0; j < (i - startIndex); j++)
{
newPacket[j] = cacheBuffer[startIndex + j]; // copy the buffer to the buffer of the new packet.
}
packetCount++;
// Instant handeling
InPacket inPacket = new InPacket(newPacket);
if (inPacket != null)
{
if (inPacket.Id > 0)
{
PacketHandler <User> pHandler = NetworkTable.Instance.FindExternal(inPacket);
if (pHandler != null)
{
try
{
pHandler.Handle(this, inPacket);
}
catch (Exception e) { Log.Instance.WriteError(e.ToString()); }
}
}
}
// Increase start index.
startIndex = i + 1;
}
}
if (startIndex > 0)
{
byte[] fullCopy = cacheBuffer;
Array.Resize(ref cacheBuffer, (cacheBuffer.Length - startIndex));
for (int i = 0; i < (cacheBuffer.Length - startIndex); i++)
{
cacheBuffer[i] = fullCopy[startIndex + i];
}
fullCopy = null;
}
socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(OnDataReceived), null);
}
else
{
Disconnect();
}
}
catch
{
Disconnect();
}
}
