Valve sockets networking

Nebula.sln

@@ -19,18 +19,22 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NebulaWorld", "NebulaWorld\NebulaWorld.csproj", "{28AEA139-FB22-4672-AF51-28B728CF2978}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "websocket-sharp", "dep\websocket-sharp\websocket-sharp\websocket-sharp.csproj", "{B357BAC7-529E-4D81-A0D2-71041B19C8DE}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NebulaNetwork", "NebulaNetwork\NebulaNetwork.csproj", "{36A3D8AE-2A0A-4A1F-8A65-4FB61B01F779}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NebulaAPI", "NebulaAPI\NebulaAPI.csproj", "{B59DB3BB-DBA2-42AF-B4F1-32A9A6A273D2}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NebulaAPI", "NebulaAPI\NebulaAPI.csproj", "{B59DB3BB-DBA2-42AF-B4F1-32A9A6A273D2}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ValveSockets", "dep\valve.sockets\ValveSockets.csproj", "{D4EEDD8E-0ED6-4426-A3F0-3642A04434D6}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{47B9362C-E91B-4AE4-979B-7D811AB4D1EA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{47B9362C-E91B-4AE4-979B-7D811AB4D1EA}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{47B9362C-E91B-4AE4-979B-7D811AB4D1EA}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{47B9362C-E91B-4AE4-979B-7D811AB4D1EA}.Release|Any CPU.Build.0 = Release|Any CPU
 		{C6237195-F77C-40C0-B06A-4AD51CAD314D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{C6237195-F77C-40C0-B06A-4AD51CAD314D}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C6237195-F77C-40C0-B06A-4AD51CAD314D}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -39,22 +43,18 @@ Global
 		{28AEA139-FB22-4672-AF51-28B728CF2978}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{28AEA139-FB22-4672-AF51-28B728CF2978}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{28AEA139-FB22-4672-AF51-28B728CF2978}.Release|Any CPU.Build.0 = Release|Any CPU
-		{B357BAC7-529E-4D81-A0D2-71041B19C8DE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{B357BAC7-529E-4D81-A0D2-71041B19C8DE}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{B357BAC7-529E-4D81-A0D2-71041B19C8DE}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{B357BAC7-529E-4D81-A0D2-71041B19C8DE}.Release|Any CPU.Build.0 = Release|Any CPU
 		{36A3D8AE-2A0A-4A1F-8A65-4FB61B01F779}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{36A3D8AE-2A0A-4A1F-8A65-4FB61B01F779}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{36A3D8AE-2A0A-4A1F-8A65-4FB61B01F779}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{36A3D8AE-2A0A-4A1F-8A65-4FB61B01F779}.Release|Any CPU.Build.0 = Release|Any CPU
-		{47B9362C-E91B-4AE4-979B-7D811AB4D1EA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{47B9362C-E91B-4AE4-979B-7D811AB4D1EA}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{47B9362C-E91B-4AE4-979B-7D811AB4D1EA}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{47B9362C-E91B-4AE4-979B-7D811AB4D1EA}.Release|Any CPU.Build.0 = Release|Any CPU
 		{B59DB3BB-DBA2-42AF-B4F1-32A9A6A273D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{B59DB3BB-DBA2-42AF-B4F1-32A9A6A273D2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B59DB3BB-DBA2-42AF-B4F1-32A9A6A273D2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B59DB3BB-DBA2-42AF-B4F1-32A9A6A273D2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D4EEDD8E-0ED6-4426-A3F0-3642A04434D6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D4EEDD8E-0ED6-4426-A3F0-3642A04434D6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D4EEDD8E-0ED6-4426-A3F0-3642A04434D6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D4EEDD8E-0ED6-4426-A3F0-3642A04434D6}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

NebulaModel/NebulaModel.csproj

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
   <ItemGroup>
-    <ProjectReference Include="..\dep\websocket-sharp\websocket-sharp\websocket-sharp.csproj" />
+    <ProjectReference Include="..\dep\valve.sockets\ValveSockets.csproj" />
     <ProjectReference Include="..\NebulaAPI\NebulaAPI.csproj" Private="false" />
   </ItemGroup>
 

NebulaModel/NetworkProvider.cs

@@ -1,6 +1,11 @@
 using NebulaAPI;
+using NebulaModel.Logger;
 using NebulaModel.Networking.Serialization;
 using System;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using Valve.Sockets;
 
 namespace NebulaModel
 {
@@ -10,10 +15,52 @@ public abstract class NetworkProvider : IDisposable, INetworkProvider
 
         public IPlayerManager PlayerManager { get; }
 
+        protected static NetworkingSockets sockets = null;
+        protected static NetworkingUtils utils = null;
+
         protected NetworkProvider(IPlayerManager playerManager)
         {
             PacketProcessor = new NetPacketProcessor();
             PlayerManager = playerManager;
+            if (sockets == null)
+            {
+                InitializeValveSockets();
+            }
+        }
+
+        private void InitializeValveSockets()
+        {
+            Library.Initialize();
+
+            sockets = new NetworkingSockets();
+            utils = new NetworkingUtils();
+
+            sockets.SetManualPollMode(true);
+
+            utils.SetDebugCallback(DebugType.Everything, (DebugType type, string message) =>
+            {
+                Log.Info(message);
+            });
+
+            // Set high speeds
+            Configuration configSendRateMax = new Configuration();
+            configSendRateMax.data.Int32 = 0x10000000;
+            configSendRateMax.dataType = ConfigurationDataType.Int32;
+            configSendRateMax.value = ConfigurationValue.SendRateMax;
+
+            Configuration configSendRateMin = new Configuration();
+            configSendRateMin.data.Int32 = 0x10000000;
+            configSendRateMin.dataType = ConfigurationDataType.Int32;
+            configSendRateMin.value = ConfigurationValue.SendRateMin;
+
+            Configuration configSendBuffer = new Configuration();
+            configSendBuffer.data.Int32 = 0x100000;
+            configSendBuffer.dataType = ConfigurationDataType.Int32;
+            configSendBuffer.value = ConfigurationValue.SendBufferSize;
+
+            utils.SetConfigurationValue(configSendRateMax, ConfigurationScope.Global, new IntPtr());
+            utils.SetConfigurationValue(configSendRateMin, ConfigurationScope.Global, new IntPtr());
+            utils.SetConfigurationValue(configSendBuffer, ConfigurationScope.Global, new IntPtr());
         }
 
         public abstract void Start();

NebulaModel/Networking/NebulaConnection.cs

@@ -2,61 +2,204 @@
 using NebulaModel.Logger;
 using NebulaModel.Networking.Serialization;
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Net;
-using WebSocketSharp;
+using Valve.Sockets;
 
 namespace NebulaModel.Networking
 {
     public class NebulaConnection : INebulaConnection
     {
+        private class Fragment
+        {
+            public int Remaining;
+            public byte[] Data;
+        }
+
+        private readonly NetworkingSockets sockets;
         private readonly EndPoint peerEndpoint;
-        private readonly WebSocket peerSocket;
+        private readonly uint peerSocket;
         private readonly NetPacketProcessor packetProcessor;
+        private readonly Queue<byte[]> sendQueue = new Queue<byte[]>();
+        private Dictionary<uint, Fragment> fragments = new Dictionary<uint, Fragment>();
+        private uint nextFragmentId = 0;
+
+        private const int KMaxPacketSize = Library.maxMessageSize - 1;
+        private const int KMaxFragmentSize = 1 << 16;
 
-        public bool IsAlive => peerSocket?.IsAlive ?? false;
+        public bool IsAlive
+        {
+            get
+            {
+                ConnectionStatus status = new ConnectionStatus();
+                sockets.GetQuickConnectionStatus(peerSocket, ref status);
+
+                return status.state == ConnectionState.Connected;
+            }
+        }
 
-        public NebulaConnection(WebSocket peerSocket, EndPoint peerEndpoint, NetPacketProcessor packetProcessor)
+        public NebulaConnection(NetworkingSockets sockets, uint peerSocket, EndPoint peerEndpoint, NetPacketProcessor packetProcessor)
         {
+            this.sockets = sockets;
             this.peerEndpoint = peerEndpoint;
             this.peerSocket = peerSocket;
             this.packetProcessor = packetProcessor;
         }
 
+        public void Update()
+        {
+            while(sendQueue.Count > 0)
+            {
+                if (SendImmediateRawPacket(sendQueue.Dequeue()) == false)
+                    break;
+            }
+        }
+
         public void SendPacket<T>(T packet) where T : class, new()
         {
-            if (peerSocket.ReadyState == WebSocketState.Open)
+            if (IsAlive)
             {
-                peerSocket.Send(packetProcessor.Write(packet));
+                SendRawPacket(packetProcessor.Write(packet));
             }
             else
             {
                 Log.Warn($"Cannot send packet {packet?.GetType()} to a closed connection {peerEndpoint}");
             }
         }
 
-        public void SendRawPacket(byte[] rawData)
+        public bool SendRawPacket(byte[] rawData)
         {
-            if (peerSocket.ReadyState == WebSocketState.Open)
+            if (IsAlive)
             {
-                peerSocket.Send(rawData);
+                if (rawData.Length >= KMaxPacketSize)
+                {
+                    FragmentPacket(rawData);
+                }
+                else
+                {
+                    byte[] data = new byte[rawData.Length + 1];
+                    data[0] = 0;
+                    Array.Copy(rawData, 0, data, 1, rawData.Length);
+                    var result = sockets.SendMessageToConnection(peerSocket, data);
+                    if (result == Result.LimitExceeded)
+                    {
+                        sendQueue.Enqueue(data);
+                    }
+                    else if (result != Result.OK)
+                    {
+                        Log.Error($"Cannot send raw data because of error {result}");
+                    }
+                    else
+                        return true;
+                }
             }
             else
             {
-                Log.Warn($"Cannot send raw packet to a closed connection {peerSocket?.Url}");
+                Log.Warn($"Cannot send raw packet to a closed connection {peerEndpoint}");
+            }
+
+            return false;
+        }
+
+        private bool SendImmediateRawPacket(byte[] rawData)
+        {
+            var result = sockets.SendMessageToConnection(peerSocket, rawData);
+            if (result == Result.LimitExceeded)
+            {
+                sendQueue.Enqueue(rawData);
+            }
+            else if (result != Result.OK)
+            {
+                Log.Error($"Cannot send raw data because of error {result}");
             }
+            else
+                return true;
+            return false;
+        }
+
+        private void FragmentPacket(byte[] rawData)
+        {
+            NetDataWriter writer = new NetDataWriter();
+            var fragmentId = nextFragmentId++;
+
+            for (var index = 0; index < rawData.Length; index += KMaxFragmentSize)
+            {
+                writer.Reset();
+
+                writer.Put((byte)1);
+                writer.Put(fragmentId);
+                writer.Put((int)rawData.Length);
+                writer.Put((uint)index);
+
+                var dataToSend = rawData.Length - index;
+                var dataChunk = dataToSend > KMaxFragmentSize ? KMaxFragmentSize : dataToSend;
+
+                writer.PutBytesWithLength(rawData, index, dataChunk);
+
+                SendImmediateRawPacket(writer.CopyData());
+            }
+        }
+
+        public byte[] Receive(byte[] rawData)
+        {
+            byte[] payload = rawData.Skip(1).ToArray();
+
+            if (rawData[0] == 0)
+            {
+                return payload;
+            }
+            else
+            {
+                var data = ProcessFragment(payload);
+                if (data != null)
+                {
+                    return data;
+                }
+            }
+
+            return null;
+        }
+
+        private byte[] ProcessFragment(byte[] payload)
+        {
+            NetDataReader reader = new NetDataReader(payload);
+            var fragId = reader.GetUInt();
+            var totalLength = reader.GetInt();
+            var offset = reader.GetUInt();
+            var data = reader.GetBytesWithLength();
+
+            Fragment frag;
+            if(!fragments.TryGetValue(fragId, out frag))
+            {
+                frag = new Fragment();
+                frag.Data = new byte[totalLength];
+                frag.Remaining = totalLength;
+                fragments.Add(fragId, frag);
+            }
+
+            frag.Remaining -= data.Length;
+            Array.Copy(data, 0, frag.Data, offset, data.Length);
+
+            if (frag.Remaining > 0)
+                return null;
+
+            fragments.Remove(fragId);
+
+            return frag.Data;
         }
 
         public void Disconnect(DisconnectionReason reason = DisconnectionReason.Normal, string reasonString = null)
         {
             if (string.IsNullOrEmpty(reasonString))
             {
-                peerSocket.Close((ushort)reason);
+                sockets.CloseConnection(peerSocket, (int)reason, "", true);
             }
             else
             {
-                if (System.Text.Encoding.UTF8.GetBytes(reasonString).Length <= 123)
+                if (System.Text.Encoding.UTF8.GetBytes(reasonString).Length <= Library.maxCloseMessageLength)
                 {
-                    peerSocket.Close((ushort)reason, reasonString);
+                    sockets.CloseConnection(peerSocket, (int)reason, reasonString, true);
                 }
                 else
                 {
@@ -70,6 +213,8 @@ public void Disconnect(DisconnectionReason reason = DisconnectionReason.Normal,
             return Equals(left, right);
         }
 
+
+
         public static bool operator !=(NebulaConnection left, NebulaConnection right)
         {
             return !Equals(left, right);
@@ -96,5 +241,7 @@ public override int GetHashCode()
         {
             return peerEndpoint?.GetHashCode() ?? 0;
         }
+
+
     }
 }