/// <param name="messageType">Type of the message.</param>
/// <returns>Message writer for the current connection.</returns>
IConnectionMessageWriter CreateMessage(MessageType messageType);
-
- /// <summary>
- /// Start listening to the client.
- /// </summary>
- /// <returns>A <see cref="ValueTask"/> representing the asynchronous operation.</returns>
- ValueTask ListenAsync();
}
}
\ No newline at end of file
internal class HazelConnection : IConnection
{
private readonly ILogger<HazelConnection> _logger;
- private readonly ConcurrentStack<DataReceivedEventArgs> _pendingMessages;
public HazelConnection(Connection innerConnection, ILogger<HazelConnection> logger)
{
_logger = logger;
- _pendingMessages = new ConcurrentStack<DataReceivedEventArgs>();
InnerConnection = innerConnection;
- innerConnection.DataReceived += ConnectionOnDataReceived;
- innerConnection.Disconnected += ConnectionOnDisconnected;
+ innerConnection.DataReceived = ConnectionOnDataReceived;
+ innerConnection.Disconnected = ConnectionOnDisconnected;
}
public Connection InnerConnection { get; }
public IClient Client { get; set; }
- private void ConnectionOnDisconnected(object sender, DisconnectedEventArgs e)
+ private async ValueTask ConnectionOnDisconnected(DisconnectedEventArgs e)
{
if (Client != null)
{
- Task.Run(Client.HandleDisconnectAsync);
+ await Client.HandleDisconnectAsync();
}
}
- private void ConnectionOnDataReceived(DataReceivedEventArgs e)
+ private async ValueTask ConnectionOnDataReceived(DataReceivedEventArgs e)
{
- Task.Run(() => HandleData(e));
- }
-
- private async Task HandleData(DataReceivedEventArgs e)
- {
- if (Client == null)
- {
- _pendingMessages.Push(e);
- return;
- }
-
try
{
while (true)
{
_logger.LogError(ex, "Exception caught in client data handler.");
}
- finally
- {
- e.Message.Recycle();
- }
}
public IConnectionMessageWriter CreateMessage(MessageType messageType)
{
return new HazelConnectionMessageWriter(messageType, this);
}
-
- public async ValueTask ListenAsync()
- {
- while (_pendingMessages.TryPop(out var eventArgs))
- {
- await HandleData(eventArgs);
- }
- }
}
}
\ No newline at end of file
using Hazel.Udp;
using Impostor.Server.Games;
using Impostor.Server.Hazel.Messages;
-using Impostor.Server.Net;
using Impostor.Server.Net.Manager;
using Impostor.Server.Net.Messages;
using Microsoft.Extensions.Logging;
_connectionLogger = connectionLogger;
}
- public ValueTask StartAsync(IPEndPoint ipEndPoint)
+ public async ValueTask StartAsync(IPEndPoint ipEndPoint)
{
var mode = ipEndPoint.AddressFamily switch
{
_ => throw new InvalidOperationException()
};
- _connection = new UdpConnectionListener(ipEndPoint, mode, s =>
- {
- _logger.LogWarning("Log from Hazel: {0}", s);
- });
-
- _connection.NewConnection += OnNewConnection;
-
- _connection.Start();
-
- return default;
- }
-
- public ValueTask StopAsync()
- {
- _connection.Dispose();
+ _connection = new UdpConnectionListener(ipEndPoint, mode);
+ _connection.NewConnection = OnNewConnection;
- return default;
+ await _connection.StartAsync();
}
- private void OnNewConnection(NewConnectionEventArgs e)
+ public async ValueTask StopAsync()
{
- Task.Run(() => HandleNewConnection(e));
+ await _connection.DisposeAsync();
}
- private async Task HandleNewConnection(NewConnectionEventArgs e)
+ private async ValueTask OnNewConnection(NewConnectionEventArgs e)
{
try
{
var clientVersion = e.HandshakeData.ReadInt32();
var name = e.HandshakeData.ReadString();
- e.HandshakeData.Recycle();
-
var connection = new HazelConnection(e.Connection, _connectionLogger);
// Register client
throw new ObjectDisposedException(nameof(_reader));
}
- return new BufferMessageReader(_reader.Tag, _reader.Buffer.AsMemory(_reader.Offset, _reader.Length));
+ return new BufferMessageReader(_reader.Tag, _reader.Buffer);
}
private void Dispose(bool disposing)
var client = _clientFactory.Create(connection, name, clientVersion);
Register(client);
-
- await connection.ListenAsync();
}
public void Register(IClient client)
// True if this is our own packet.
using (var stream = udp.Payload.ToMemoryStream())
{
- var reader = MessageReader.Get(stream.ToArray());
- if (reader.Buffer[0] == (byte) SendOption.Reliable)
+ var reader = new MessageReader(stream.ToArray());
+ var option = reader.Buffer.Span[0];
+ if (option == (byte) SendOption.Reliable)
{
- reader.Offset = 3;
- reader.Length = udp.Payload.Length - 3;
- reader.Position = 0;
+ reader = reader.Slice(3);
}
- else if (reader.Buffer[0] == (byte) UdpSendOption.Acknowledgement ||
- reader.Buffer[0] == (byte) UdpSendOption.Ping ||
- reader.Buffer[0] == (byte) UdpSendOption.Hello ||
- reader.Buffer[0] == (byte) UdpSendOption.Disconnect)
+ else if (option == (byte) UdpSendOption.Acknowledgement ||
+ option == (byte) UdpSendOption.Ping ||
+ option == (byte) UdpSendOption.Hello ||
+ option == (byte) UdpSendOption.Disconnect)
{
return;
}
else
{
- reader.Offset = 1;
- reader.Length = udp.Payload.Length - 1;
- reader.Position = 0;
+ reader = reader.Slice(1);
}
var isSent = ipSrc.StartsWith("192.");
break;
case 5:
case 6:
- Console.WriteLine(HexUtils.HexDump(packet.Buffer.Take(packet.Length).ToArray()));
+ Console.WriteLine(HexUtils.HexDump(packet.Buffer.ToArray().Take(packet.Length).ToArray()));
packet.Position = packet.Length;
break;
case 7:
case 5:
case 6:
Console.WriteLine("- GameCode " + packet.ReadInt32());
- Console.WriteLine(HexUtils.HexDump(packet.Buffer.Take(packet.Length).ToArray()));
+ Console.WriteLine(HexUtils.HexDump(packet.Buffer.ToArray().Take(packet.Length).ToArray()));
packet.Position = packet.Length;
break;
}
-Subproject commit ebc3b36068f57ebc1d34106e7778560fc8c09559
+Subproject commit 1c5c51c2bd28482128120003e7f72bee22ff8115
projects / rhonda / impostor.git / commitdiff