private async Task ReadLoop(CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
while (_client.Available <= 0)
{
await Task.Delay(10);
}
int length;
byte[] data;
await _streamSemaphore.WaitAsync(ct);
try
{
length = Protocol.LengthHeader.Read(_stream);
data = new byte[length];
await _stream.ReadAsync(data, 0, length);
}
finally
{
_streamSemaphore.Release();
}
using (var stream = new MemoryStream(data))
{
var id = Protocol.IdHeader.Read(stream);
var packetDef = Protocol.IdResolver.MapIdToPacket(id);
var obj = packetDef.ReadDelegate(stream);
OnPacketReceived?.Invoke(obj, packetDef.Binding);
}
}
}
private async Task Receive(CancellationToken cancelToken = default)
{
Console.WriteLine($"Start Receiving");
while (_isConnected)
{
await CloseIfCanceled(cancelToken);
byte[] sizeBytes = await ReadBytes(4, cancelToken);
int size;
try
{
size = BitConverter.ToInt32(sizeBytes, 0);
}
catch (Exception e)
{
Console.WriteLine(e);
await CloseAsync();
throw;
}
Console.WriteLine($"New Message incoming: {size} bytes");
byte[] packetBytes = await ReadBytes(size, cancelToken);
Packet packet = MessagePackSerializer.Deserialize <Packet>(packetBytes);
OnPacketReceived?.Invoke(packet);
}
}
private void v_HandlePacket(NetIncomingMessage msg)
{
try
{
IPacket packet = DeserializePacket(msg);
if (packet is null)
{
throw new Exception("Tried to parse a IPacket, but failed");
}
OnPacketReceived?.Invoke(packet);
m_callbackRegistry.HandlePacket(packet);
if (packet is DataPacket dataPacket)
{
OnDataPacketReceived?.Invoke(dataPacket);
}
else if (packet is RequestPacket requestPacket)
{
OnRequestPacketReceived?.Invoke(requestPacket);
}
else if (packet is ResponsePacket responsePacket)
{
OnResponsePacketReceived?.Invoke(responsePacket);
m_requestRegistry.HandlePacket(responsePacket);
}
}
catch (Exception e)
{
msg.SenderConnection.Deny(string.Format("Internal Error: {0}", e.ToString()));
}
}
private void HandleAuthClient()
{
//Inicia Thread KeepAlive
var keepAliveThread = new Thread(new ThreadStart(KeepAlive));
keepAliveThread.Start();
while (Tcp.Connected)
{
try
{
var messageBufferRead = new byte[500000]; //Tamanho do BUFFER á ler
//Lê mensagem do cliente
var bytesRead = Tcp.GetStream().Read(messageBufferRead, 0, 500000);
//variável para armazenar a mensagem recebida
var message = new byte[bytesRead];
//Copia mensagem recebida
Buffer.BlockCopy(messageBufferRead, 0, message, 0, bytesRead);
var json = System.Text.Encoding.Default.GetString(message);
var response = JsonConvert.DeserializeObject <AuthPacket>(json);
//Dispara evento OnPacketReceived
OnPacketReceived?.Invoke(this, response);
}
catch
{
OnDisconnect?.Invoke();
}
}
}
private void RecvThread()
{
while (Active)
{
try
{
var from = new IPEndPoint(0, 0);
var recvBuffer = udpClient.Receive(ref from);
if (recvBuffer == null || recvBuffer.Length == 0)
{
continue;
}
var packet = Packet.FromByteArray(recvBuffer);
try
{
OnPacketReceived?.Invoke(from, packet);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
catch (SocketException)
{
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
// public delegate void OnSceneGraphReceived(byte[] bytes);
public void Create(string ip, int port, OnPacketReceived callbackDelegate)
{
if (running)
{
return;
}
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(ip, port);
if (!socket.Connected)
{
Debug.Log("Connection failed!");
return;
}
running = true;
this.callbackDelegate = callbackDelegate;
// Upon connection, the Hyperverse server will pass us the entire scene-graph under the INIT packet.
// The client update function will run on a separate thread.
thread = new Thread(Run);
thread.Start();
}
/// <summary>
/// Extract the first incoming packet.
/// </summary>
public bool ReceivePacket(out Buffer buffer, out IPEndPoint source)
{
if (Port == 0)
{
Stop();
throw new InvalidOperationException(
"You must specify a non-zero port to UdpProtocol.Start() before you can receive data.");
}
if (inQueue.Count != 0)
{
lock (inQueue)
{
Datagram dg = inQueue.Dequeue();
buffer = dg.buffer;
source = dg.ip;
#if DEBUG
Debug.Log("[UdpProtocol:ReceivePacket(" + buffer.size + ", " + source +
") - Receiving packet ....");
#endif
if (OnPacketReceived != null)
{
OnPacketReceived.Invoke(buffer, source);
}
return(true);
}
}
buffer = null;
source = null;
return(false);
}
/// <summary>
/// Handler for end of the begin receive call.
/// </summary>
/// <param name="ar">Contains the results of the receive.</param>
private void EndReceiveFrom(IAsyncResult ar)
{
try
{
// When socket is closed the object will be disposed of in the middle of a receive.
if (!m_isClosed)
{
EndPoint remoteEP = m_addressFamily == AddressFamily.InterNetwork
? new IPEndPoint(IPAddress.Any, 0)
: new IPEndPoint(IPAddress.IPv6Any, 0);
int bytesRead = m_udpSocket.EndReceiveFrom(ar, ref remoteEP);
if (bytesRead > 0)
{
// During experiments IPPacketInformation wasn't getting set on Linux. Without it the local IP address
// cannot be determined when a listener was bound to IPAddress.Any (or IPv6 equivalent). If the caller
// is relying on getting the local IP address on Linux then something may fail.
//if (packetInfo != null && packetInfo.Address != null)
//{
// localEndPoint = new IPEndPoint(packetInfo.Address, localEndPoint.Port);
//}
byte[] packetBuffer = new byte[bytesRead];
Buffer.BlockCopy(m_recvBuffer, 0, packetBuffer, 0, bytesRead);
OnPacketReceived?.Invoke(this, m_localPort, remoteEP as IPEndPoint, packetBuffer);
}
}
}
catch (SocketException)
{
// Socket errors do not trigger a close. The reason being that there are genuine situations that can cause them during
// normal RTP operation. For example:
// - the RTP connection may start sending before the remote socket starts listening,
// - an on hold, transfer, etc. operation can change the RTP end point which could result in socket errors from the old
// or new socket during the transition.
// It also seems that once a UDP socket pair have exchanged packets and the remote party closes the socket exception will occur
// in the BeginReceive method (very handy). Follow-up, this doesn't seem to be the case, the socket exception can occur in
// BeginReceive before any packets have been exchanged. This means it's not safe to close if BeginReceive gets an ICMP
// error since the remote party may not have initialised their socket yet.
//logger.LogWarning($"SocketException UdpReceiver.EndReceiveMessage. {sockExcp}");
}
catch (ObjectDisposedException) // Thrown when socket is closed. Can be safely ignored.
{
}
catch (Exception excp)
{
Logger.Logger.Error($"Exception UdpReceiver.EndReceiveMessage. ->{excp}");
Close(excp.Message);
}
finally
{
if (!m_isClosed)
{
BeginReceiveFrom();
}
}
}
public virtual void ___recv___(Victem victem, string packet)
{
var handler = OnPacketReceived;
if (handler != null)
{
OnPacketReceived?.Invoke(victem, packet);
}
}
/// <summary>
/// Manuseia Comunicação do Cliente
/// </summary>
private void HandleClient(object obj)
{
try
{
//Recebe cliente a partir do parâmetro
TcpClient tcpClient = (TcpClient)obj;
NetworkStream clientStream = tcpClient.GetStream();
#region READ ON CONNECT INICIAL
AuthPacket packet = ReceivePacket(clientStream);
var client = new AuthClient(tcpClient)
{
Name = packet.Message.ServerName,
Type = packet.Message.ServerType,
Key = packet.Message.Key
};
Clients.Add(client);
ClientConnected(client);
OnPacketReceived?.Invoke(client, packet);
#endregion
//Escuta contínuamente as mensagens dos clientes (Servidores) enquanto estiver conectado
while (tcpClient.Connected)
{
try
{
packet = ReceivePacket(clientStream);
OnPacketReceived?.Invoke(client, packet);
}
catch (Exception erro)
{
Console.WriteLine(DateTime.Now.ToString() + $" Exception error:" + Environment.NewLine);
Console.WriteLine(erro.Message + Environment.NewLine);
//Desconecta client
DisconnectClient(client);
}
}
//Caso o Client não estiver mais conectado
DisconnectClient(client);
}
catch (Exception erro)
{
Console.WriteLine(DateTime.Now.ToString() + $" Exception error:" + Environment.NewLine);
Console.WriteLine(erro.Message + Environment.NewLine);
}
}
private void InvokeDataReceivedEvent(Packet packet)
{
try
{
OnPacketReceived?.Invoke(packet.PacketPayload);
}
catch (Exception exception)
{
logger?.LogError(exception, "OnPacketReceived threw an exception");
}
}
internal void HandlePacket(PosixTimeval timeval, TcpPacket tcp, TcpConnection connection)
{
OnPacketReceived?.Invoke(timeval, tcp, connection, this);
// look for disconnection
if (tcp.Finished == true)
{
IsOpen = false;
OnFlowClosed?.Invoke(timeval, tcp, connection, this);
}
}
private void MonitorStreams()
{
while (IsRunning)
{
foreach (var client in Connections.ToList())
{
if (!client.IsSocketConnected())
{
var e5 = BuildEvent(client, null, String.Empty);
Connections.Remove(client);
OnConnectionRemoved?.Invoke(this, e5);
continue;
}
if (client.Socket.Available != 0)
{
var readObject = ReadObject(client.Socket);
var e1 = BuildEvent(client, null, readObject);
OnPacketReceived?.Invoke(this, e1);
if (readObject is PingPacket ping)
{
client.SendObject(ping).Wait();
continue;
}
if (readObject is PersonalPacket pp)
{
var destination = Connections.FirstOrDefault(c => c.ClientId.ToString() == pp.GuidId);
var e4 = BuildEvent(client, destination, pp);
OnPersonalPacketReceived?.Invoke(this, e4);
if (destination != null)
{
destination.SendObject(pp).Wait();
var e2 = BuildEvent(client, destination, pp);
OnPersonalPacketSent?.Invoke(this, e2);
}
}
else
{
foreach (var c in Connections.ToList())
{
c.SendObject(readObject).Wait();
var e3 = BuildEvent(client, c, readObject);
OnPacketSent?.Invoke(this, e3);
}
}
}
}
}
}
/// <summary>
/// Manuseia Comunicação do Cliente
/// </summary>
private void HandlePlayer(object obj)
{
//Recebe cliente a partir do parâmetro
TcpClient tcpClient = (TcpClient)obj;
var Player = OnConnectPlayer(tcpClient);
var thread = new Thread(new ThreadStart(Player.RefreshData));
thread.Start();
//Chama evento OnClientConnected
this.OnClientConnected?.Invoke(Player);
while (Player.Connected)
{
try
{
byte[] message = ReceivePacket(tcpClient.GetStream());
if (message.Length >= 5)
{
if (Player.Connected)
{
var packet = new Packet(message, Player.GetKey);
if (ShowLog)
{
packet.Log();
}
//Dispara evento OnPacketReceived
OnPacketReceived?.Invoke(Player, packet: packet);
}
}
else
{
if (Player.Connected)
{
DisconnectPlayer(Player);
}
}
}
catch (Exception ex)
{
ServerExpection(Player, ex);
}
}
if (Player.Connected)
{
DisconnectPlayer(Player);
}
}
private async Task Listen()
{
List <string> removeList = new List <string>();
for (int i = clients.Count - 1; i >= 0; i--)
{
Client client = clients[i];
if (client.IsAlive())
{
Packet p = await client.Listen();
if (p != null)
{
PacketType type = p.GetPacketType();
if (type == PacketType.Identify)
{
OnUserConnect.Invoke(this, new UserConnectEventArgs(client));
}
else
{
OnPacketReceived.Invoke(this, new PacketReceivedEventArgs(client, p));
}
}
}
else
{
await client.Stop();
Logger.Info($"Client dropped [{client.GetSessionId()}]");
clients.RemoveAt(i);
string sess = client.GetSessionId();
bool onlyone = true;
for (int j = clients.Count - 1; j >= 0; j--)
{
if (clients[j].GetSessionId() == sess)
{
onlyone = false;
break;
}
}
if (onlyone)
{
OnUserDisconnect.Invoke(this, new UserDosconnectEventArgs(client));
}
}
}
}
private void RawPacketReceived(byte[] data)
{
IDataPacket parsedPacket;
using (var ms = new MemoryStream(data)
{
Position = 2
})
{
parsedPacket = PacketProcessor.ParsePacket(ms);
parsedPacket.DeserializeFrom(ms);
}
OnPacketReceived.Raise(this, new ClientPacketEventArgs(parsedPacket, this, data.Length));
}
private void RecvThread()
{
while (Active)
{
try
{
var packet = Packet.FromStream(reader);
OnPacketReceived?.Invoke(packet);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
/// <summary>
/// Handler for end of the begin receive call.
/// </summary>
/// <param name="ar">Contains the results of the receive.</param>
private void EndReceiveMessageFrom(IAsyncResult ar)
{
try
{
// When socket is closed the object will be disposed of in the middle of a receive.
if (!m_isClosed)
{
SocketFlags flags = SocketFlags.None;
EndPoint remoteEP = (m_udpSocket.LocalEndPoint.AddressFamily == AddressFamily.InterNetwork) ? new IPEndPoint(IPAddress.Any, 0) : new IPEndPoint(IPAddress.IPv6Any, 0);
int bytesRead = m_udpSocket.EndReceiveMessageFrom(ar, ref flags, ref remoteEP, out var packetInfo);
if (bytesRead > 0)
{
IPEndPoint localEndPoint = new IPEndPoint(packetInfo.Address, (m_udpSocket.LocalEndPoint as IPEndPoint).Port);
byte[] packetBuffer = new byte[bytesRead];
Buffer.BlockCopy(m_recvBuffer, 0, packetBuffer, 0, bytesRead);
OnPacketReceived?.Invoke(this, localEndPoint, remoteEP as IPEndPoint, packetBuffer);
}
}
}
catch (SocketException)
{
// Socket errors do not trigger a close. The reason being that there are genuine situations that can cause them during
// normal RTP operation. For example:
// - the RTP connection may start sending before the remote socket starts listening,
// - an on hold, transfer, etc. operation can change the RTP end point which could result in socket errors from the old
// or new socket during the transition.
// It also seems that once a UDP socket pair have exchanged packets and the remote party closes the socket exception will occur
// in the BeginReceive method (very handy). Follow-up, this doesn't seem to be the case, the socket exception can occur in
// BeginReceive before any packets have been exchanged. This means it's not safe to close if BeginReceive gets an ICMP
// error since the remote party may not have initialised their socket yet.
}
catch (ObjectDisposedException) // Thrown when socket is closed. Can be safely ignored.
{ }
catch (Exception excp)
{
logger.LogError($"Exception UdpReceiver.EndReceiveMessageFrom. {excp}");
Close(excp.Message);
}
finally
{
if (!m_isClosed)
{
BeginReceive();
}
}
}
private void RawPacketReceived(object sender, RawServerPacketEventArgs e)
{
IDataPacket parsedPacket;
var rawDat = e.RawData;
rawDat = PacketProcessor.ProcessRawData(rawDat);
using (var ms = new MemoryStream(rawDat)
{
Position = 2
})
{
parsedPacket = PacketProcessor.ParsePacket(ms);
parsedPacket.DeserializeFrom(ms);
}
OnPacketReceived.Raise(this, new ServerPacketEventArgs(parsedPacket, e.Peer, this, e.RawData.Length));
}
public void StartNewRtSession(RtSessionInfo info,
OnPlayerConnectedToGame onPlayerConnectedToGame,
OnPlayerDisconnected onPlayerDisconnected,
OnRTReady onRtReady,
OnPacketReceived onPacketReceived)
{
GameSparksController.Instance().GetGameSparksFactory().StartNewRtSession(
info,
onPlayerConnectedToGame,
onPlayerDisconnected,
onRtReady,
onPacketReceived,
ref _sessionInfo,
ref _gameSparksRtUnity
);
}
private void OnDataReceived(IAsyncResult res)
{
IPEndPoint ip = new IPEndPoint(IPAddress.Any, ReceivePort);
byte[] data = client.EndReceive(res, ref ip);
UdpPacket packet = UdpPacket.ParseData(data);
if (packet != null)
{
OnPacketReceived?.Invoke(packet);
}
else
{
Console.Out.WriteLine("Bad packet received.");
}
client.BeginReceive(new AsyncCallback(OnDataReceived), null);
}
private void ReceiveLoop()
{
while (_alive)
{
int bytesRec = _socket.Receive(_buffer);
if (_currentPacket == null)
{
_currentPacket = new Packet();
}
if (_currentPacket.AddFragment(_buffer, bytesRec))
{
OnPacketReceived?.Invoke((Packet)_currentPacket.Clone());
_currentPacket = null;
}
}
}
/// <summary>
/// Manuseia Comunicação do Cliente
/// </summary>
private void HandlePlayer(object obj)
{
//Recebe cliente a partir do parâmetro
TcpClient tcpClient = (TcpClient)obj;
var Player = OnConnectPlayer(tcpClient);
//Chama evento OnClientConnected
this.OnClientConnected?.Invoke(Player);
while (Player.Connected)
{
try
{
byte[] message = ReceivePacket(tcpClient.GetStream());
if (message.Length >= 5)
{
if (Player.Connected)
{
Player.Server = this;
//Dispara evento OnPacketReceived
OnPacketReceived?.Invoke(Player, packet: new Packet(message, Player.GetKey));
}
}
else
{
if (Player.Connected)
{
DisconnectPlayer(Player);
}
}
}
catch
{
DisconnectPlayer(Player);
}
}
if (Player.Connected)
{
DisconnectPlayer(Player);
}
}
/// <summary>
/// Manuseia Comunicação do Cliente
/// </summary>
private void HandleClient(object obj)
{
//Recebe cliente a partir do parâmetro
TcpClient tcpClient = (TcpClient)obj;
NetworkStream clientStream = tcpClient.GetStream();
#region READ ON CONNECT INICIAL
AuthPacket packet = ReceivePacket(clientStream);
var client = new AuthClient(tcpClient, packet);
Clients.Add(client);
Console.Title = string.Format("Pangya Fresh Up! AuthServer - LOGIN: {0}, GAMES: {1}, MESSENGER: {2}", Clients.Model.Where(c => c.Data.Type == AuthClientTypeEnum.LoginServer).ToList().Count, Clients.Model.Where(c => c.Data.Type == AuthClientTypeEnum.GameServer).ToList().Count, Clients.Model.Where(c => c.Data.Type == AuthClientTypeEnum.MessengerServer).ToList().Count);
ClientConnected(client);
OnPacketReceived?.Invoke(client, packet);
#endregion
//Escuta contínuamente as mensagens dos clientes (Servidores) enquanto estiver conectado
while (tcpClient.Connected)
{
try
{
packet = ReceivePacket(clientStream);
OnPacketReceived?.Invoke(client, packet);
}
catch
{
//Desconecta client
DisconnectClient(client);
}
}
//Caso o Client não estiver mais conectado
if (tcpClient.Connected)
{
DisconnectClient(client);
}
}
protected async Task Init()
{
// Get Info
serverInfo = await rpc.ServerInfoAsync(new ServerInfoRequest());
// TCP relay
tcpRelaySocket.OnPacketReceived += (buf, len) => {
OnPacketReceived?.Invoke(buf, len);
};
tcpRelaySocket.Init();
// Periodically restart listeners & reconnect
PingTimer = new Timer();
PingTimer.Interval = 15000;
PingTimer.Elapsed += PingServer;
PingTimer.Start();
// Sync clients periodically
Task.Run(SyncTask);
}
private void HandlePacket(object obj)
{
//Recebe OnCliente a partir do parâmetro
TcpClient tcpClient = (TcpClient)obj;
var Player = OnConnectBot(tcpClient);
//Chama evento OnClientConnected
this.OnClientConnected?.Invoke(Player);
while (Player.Tcp.Connected)
{
try
{
var messageBufferRead = new byte[500000]; //Tamanho do BUFFER á ler
//Lê mensagem do OnCliente
//size =500000;
int bytesRead = Player.Tcp.GetStream().Read(messageBufferRead, 0, 500000);
//variável para armazenar a mensagem recebida
byte[] message = new byte[bytesRead];
//Copia mensagem recebida
Buffer.BlockCopy(messageBufferRead, 0, message, 0, bytesRead);
if (message.Length >= 5)
{
var packet = new ClientPacket(message);
OnPacketReceived?.Invoke(Player, packet);
}
}
catch (Exception ex)
{
OnException(Player, ex);
}
}
}
public void OnTcpReceived(IDoubleServerClient client, BitBuffer buffer)
{
if (buffer.TotalBitsLeft < 8)
{
return;
}
byte packet = buffer.ReadByte();
if (packet >= TcpHandlers.Length)
{
return;
}
byte[] bytes = buffer.ReadBytes();
NetworkServerClient serverClient = (NetworkServerClient)client.ExtraData;
// ReSharper disable once ConvertToLocalFunction
Action handler = () => {
if (_server != null)
{
OnPacketReceived action = TcpHandlers[packet];
if (action != null)
{
_handlerBuffer.SetContents(bytes);
action((NetworkServerClient)client.ExtraData, _handlerBuffer);
}
}
};
if (!NetworkUtils.SimulateNetworkConditions || NetworkUtils.IsLocal(serverClient.Id))
{
UnityFixedDispatcher.InvokeNoDelay(handler);
}
else
{
UnityFixedDispatcher.InvokeDelayed(NetworkUtils.SimulatedNetDelay, handler);
}
}
public void Connect(IPEndPoint endPoint)
{
_peer.Start();
_listener.NetworkReceiveEvent += (fromPeer, dataReader, deliveryMethod) =>
{
var dataPacket = new DataPacket(dataReader.RawData, dataReader.UserDataOffset, dataReader.UserDataSize,
ConvertDeliveryMethod(deliveryMethod));
OnPacketReceived?.Invoke(endPoint, dataPacket, dataReader.Recycle);
};
_listener.PeerConnectedEvent += peer =>
{
_serverPeer = peer;
OnConnected?.Invoke(peer.EndPoint);
};
_listener.PeerDisconnectedEvent += (peer, info) =>
{
_serverPeer = null;
using (var disconnectInfo = new LiteNetDisconnectInfo(info))
OnDisconnected?.Invoke(endPoint, disconnectInfo);
};
_peer.Connect(endPoint.Address.ToString(), endPoint.Port, "SomeConnectionKey333");
}
IEnumerator StartReading()
{
byte[] meta = new byte[sizeof(Int32)];
while (!cts.IsCancellationRequested)
{
while (!cts.IsCancellationRequested && stream.DataAvailable)
{
var bytesRead = stream.Read(meta, 0, meta.Length);
if (bytesRead > 0)
{
var packetSize = BitConverter.ToInt32(meta, 0);
byte[] data = new byte[packetSize];
var startIndex = 0;
while (startIndex < packetSize && !cts.IsCancellationRequested)
{
bytesRead = stream.Read(data, startIndex, packetSize - startIndex);
startIndex += bytesRead;
}
OnPacketReceived?.Invoke(System.Text.Encoding.ASCII.GetString(data));
}
}
yield return(new WaitForEndOfFrame());
}
}
private void RecvThread()
{
byte[] recvBuf = new byte[4096];
while (connected)
{
// Read the udp pak header ..
int read = 0;
while (read < 2)
{
read += socket.Receive(recvBuf, read, 2, SocketFlags.None);
}
ushort pakSize = (ushort)((recvBuf[0] << 8) | recvBuf[1]); // << content size
pakSize += RECV_HDR_SIZE;
// Read the full packet
while (read < pakSize)
{
read += socket.Receive(recvBuf, read, pakSize - read, SocketFlags.None);
}
// Handle packet
OnPacketReceived?.Invoke(recvBuf, pakSize);
}
}
