Refactoring to asynchronous. (partially completed)

MinecraftClient/Protocol/PacketPipeline/SocketWrapper.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+using MinecraftClient.Crypto;
+
+namespace MinecraftClient.Protocol.PacketPipeline
+{
+    /// <summary>
+    /// Wrapper for handling unencrypted & encrypted socket
+    /// </summary>
+    class SocketWrapper
+    {
+        private TcpClient tcpClient;
+
+        private AesStream? AesStream;
+
+        private PacketStream? packetStream = null;
+
+        private Stream ReadStream, WriteStream;
+
+        private bool Encrypted = false;
+
+        public int CompressionThreshold { get; set; } = 0;
+
+
+        private SemaphoreSlim SendSemaphore = new SemaphoreSlim(1, 1);
+
+        private Task LastSendTask = Task.CompletedTask;
+
+        /// <summary>
+        /// Initialize a new SocketWrapper
+        /// </summary>
+        /// <param name="client">TcpClient connected to the server</param>
+        public SocketWrapper(TcpClient client)
+        {
+            tcpClient = client;
+            ReadStream = WriteStream = client.GetStream();
+        }
+
+        /// <summary>
+        /// Check if the socket is still connected
+        /// </summary>
+        /// <returns>TRUE if still connected</returns>
+        /// <remarks>Silently dropped connection can only be detected by attempting to read/write data</remarks>
+        public bool IsConnected()
+        {
+            return tcpClient.Client != null && tcpClient.Connected;
+        }
+
+        /// <summary>
+        /// Check if the socket has data available to read
+        /// </summary>
+        /// <returns>TRUE if data is available to read</returns>
+        public bool HasDataAvailable()
+        {
+            return tcpClient.Client.Available > 0;
+        }
+
+        /// <summary>
+        /// Switch network reading/writing to an encrypted stream
+        /// </summary>
+        /// <param name="secretKey">AES secret key</param>
+        public void SwitchToEncrypted(byte[] secretKey)
+        {
+            if (Encrypted)
+                throw new InvalidOperationException("Stream is already encrypted!?");
+            Encrypted = true;
+            ReadStream = WriteStream = AesStream = new AesStream(tcpClient.Client, secretKey);
+        }
+
+        /// <summary>
+        /// Send raw data to the server.
+        /// </summary>
+        /// <param name="buffer">data to send</param>
+        public async Task SendAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+        {
+            await SendSemaphore.WaitAsync();
+            await LastSendTask;
+            LastSendTask = WriteStream.WriteAsync(buffer, cancellationToken).AsTask();
+            SendSemaphore.Release();
+        }
+
+        public async Task<Tuple<int, PacketStream>> GetNextPacket(bool handleCompress, CancellationToken cancellationToken = default)
+        {
+            // ConsoleIO.WriteLine("GetNextPacket");
+            if (packetStream != null)
+            {
+                await packetStream.DisposeAsync();
+                packetStream = null;
+            }
+
+            int readed = 0;
+            (int packetSize, _) = await ReceiveVarIntRaw(ReadStream, cancellationToken);
+
+            int packetID;
+            if (handleCompress && CompressionThreshold > 0)
+            {
+                (int sizeUncompressed, readed) = await ReceiveVarIntRaw(ReadStream, cancellationToken);
+                if (sizeUncompressed != 0)
+                {
+                    ZlibBaseStream zlibBaseStream = new(AesStream ?? ReadStream, packetSize: packetSize - readed);
+                    ZLibStream zlibStream = new(zlibBaseStream, CompressionMode.Decompress, leaveOpen: false);
+
+                    zlibBaseStream.BufferSize = 16;
+                    (packetID, readed) = await ReceiveVarIntRaw(zlibStream, cancellationToken);
+                    zlibBaseStream.BufferSize = 512;
+
+                    // ConsoleIO.WriteLine("packetID = " + packetID + ", readed = " + zlibBaseStream.packetReaded + ", size = " + packetSize + " -> " + sizeUncompressed);
+
+                    packetStream = new(zlibStream, sizeUncompressed - readed, cancellationToken);
+
+                    return new(packetID, packetStream);
+                }
+            }
+
+            (packetID, int readed2) = await ReceiveVarIntRaw(ReadStream, cancellationToken);
+
+            packetStream = new(AesStream ?? ReadStream, packetSize - readed - readed2, cancellationToken);
+
+            return new(packetID, packetStream);
+        }
+
+        private async Task<Tuple<int, int>> ReceiveVarIntRaw(Stream stream, CancellationToken cancellationToken = default)
+        {
+            int i = 0;
+            int j = 0;
+            byte[] b = new byte[1];
+            while (true)
+            {
+                await stream.ReadAsync(b);
+                i |= (b[0] & 0x7F) << j++ * 7;
+                if (j > 5) throw new OverflowException("VarInt too big");
+                if ((b[0] & 0x80) != 128) break;
+            }
+            return new(i, j);
+        }
+
+        /// <summary>
+        /// Disconnect from the server
+        /// </summary>
+        public void Disconnect()
+        {
+            try
+            {
+                tcpClient.Close();
+            }
+            catch (SocketException) { }
+            catch (IOException) { }
+            catch (NullReferenceException) { }
+            catch (ObjectDisposedException) { }
+        }
+    }
+}