[Add] FishNet

Assets/FishNet/Runtime/Transporting/Transports/Multipass.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a3fe0c14d0e92e342a72a5c3c47eded6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Transporting/Transports/Multipass/CHANGELOG.txt

@@ -0,0 +1,2 @@
+1.0.0
+	- Initial release.

Assets/FishNet/Runtime/Transporting/Transports/Multipass/CHANGELOG.txt.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 9b339dd67a0ce7f458236a3ad1d97322
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Multipass/CHANGELOG.txt
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Multipass/Multipass.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 314b449d3505bd24487ba69b61c2fda5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: bf9191e2e07d29749bca3a1ae44e4bc8, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Multipass/Multipass.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Multipass/VERSION.txt

@@ -0,0 +1 @@
+1.0.0

Assets/FishNet/Runtime/Transporting/Transports/Multipass/VERSION.txt.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: e4f9d944e2ca8484587859cf4ec80b6c
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Multipass/VERSION.txt
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4f3b3f854a379684a92d54e1034c3a1a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e13f31983d04611469a690fc65e81b02
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/ClientSocket.cs

@@ -0,0 +1,272 @@
+using FishNet.Managing;
+using FishNet.Managing.Logging;
+using LiteNetLib;
+using LiteNetLib.Layers;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace FishNet.Transporting.Tugboat.Client
+{
+    public class ClientSocket : CommonSocket
+    {
+        ~ClientSocket()
+        {
+            StopConnection();
+        }
+
+        #region Private.
+        #region Configuration.
+        /// <summary>
+        /// Address to bind server to.
+        /// </summary>
+        private string _address = string.Empty;
+        /// <summary>
+        /// Port used by server.
+        /// </summary>
+        private ushort _port;
+        /// <summary>
+        /// MTU sizes for each channel.
+        /// </summary>
+        private int _mtu;
+        #endregion
+
+        #region Queues.
+        /// <summary>
+        /// Inbound messages which need to be handled.
+        /// </summary>
+        private ConcurrentQueue<Packet> _incoming = new();
+        /// <summary>
+        /// Outbound messages which need to be handled.
+        /// </summary>
+        private Queue<Packet> _outgoing = new();
+        #endregion
+
+        /// <summary>
+        /// How long in seconds until client times from server.
+        /// </summary>
+        private int _timeout;
+        /// <summary>
+        /// PacketLayer to use with LiteNetLib.
+        /// </summary>
+        private PacketLayerBase _packetLayer;
+        #endregion
+
+        /// <summary>
+        /// Initializes this for use.
+        /// </summary>
+        internal void Initialize(Transport t, int unreliableMTU, PacketLayerBase packetLayer)
+        {
+            Transport = t;
+            _mtu = unreliableMTU;
+            _packetLayer = packetLayer;
+        }
+
+        /// <summary>
+        /// Updates the Timeout value as seconds.
+        /// </summary>
+        internal void UpdateTimeout(int timeout)
+        {
+            _timeout = timeout;
+            base.UpdateTimeout(NetManager, timeout);
+        }
+
+        /// <summary>
+        /// Polls the socket for new data.
+        /// </summary>
+        internal void PollSocket()
+        {
+            base.PollSocket(NetManager);
+        }
+
+        /// <summary>
+        /// Threaded operation to process client actions.
+        /// </summary>
+        private void ThreadedSocket()
+        {
+            EventBasedNetListener listener = new();
+            listener.NetworkReceiveEvent += Listener_NetworkReceiveEvent;
+            listener.PeerConnectedEvent += Listener_PeerConnectedEvent;
+            listener.PeerDisconnectedEvent += Listener_PeerDisconnectedEvent;
+
+            NetManager = new(listener, _packetLayer, false);
+            NetManager.DontRoute = ((Tugboat)Transport).DontRoute;
+            NetManager.MtuOverride = _mtu + NetConstants.FragmentedHeaderTotalSize;
+
+            UpdateTimeout(_timeout);
+
+            LocalConnectionStates.Enqueue(LocalConnectionState.Starting);
+            NetManager.Start();
+            NetManager.Connect(_address, _port, string.Empty);
+        }
+
+        /// <summary>
+        /// Starts the client connection.
+        /// </summary>
+        internal bool StartConnection(string address, ushort port)
+        {
+            // Force a stop just in case the socket did not clean up.
+            if (GetConnectionState() != LocalConnectionState.Stopped)
+                StopSocket();
+            // Enqueue starting.
+            LocalConnectionStates.Enqueue(LocalConnectionState.Starting);
+            // Iterate to cause state changes to invoke.
+            IterateIncoming();
+
+            // Assign properties.
+            _port = port;
+            _address = address;
+
+            ResetQueues();
+            Task.Run(ThreadedSocket);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Stops the local socket.
+        /// </summary>
+        internal bool StopConnection(DisconnectInfo? info = null)
+        {
+            if (GetConnectionState() == LocalConnectionState.Stopped || GetConnectionState() == LocalConnectionState.Stopping)
+                return false;
+
+            if (info != null)
+                Transport.NetworkManager.Log($"Local client disconnect reason: {info.Value.Reason}.");
+
+            SetConnectionState(LocalConnectionState.Stopping, false);
+            StopSocket();
+            return true;
+        }
+
+        /// <summary>
+        /// Resets queues.
+        /// </summary>
+        private void ResetQueues()
+        {
+            ClearGenericQueue(ref LocalConnectionStates);
+            ClearPacketQueue(ref _incoming);
+            ClearPacketQueue(ref _outgoing);
+        }
+
+        /// <summary>
+        /// Called when disconnected from the server.
+        /// </summary>
+        private void Listener_PeerDisconnectedEvent(NetPeer peer, DisconnectInfo disconnectInfo)
+        {
+            StopConnection(disconnectInfo);
+        }
+
+        /// <summary>
+        /// Called when connected to the server.
+        /// </summary>
+        private void Listener_PeerConnectedEvent(NetPeer peer)
+        {
+            LocalConnectionStates.Enqueue(LocalConnectionState.Started);
+        }
+
+        /// <summary>
+        /// Called when data is received from a peer.
+        /// </summary>
+        private void Listener_NetworkReceiveEvent(NetPeer fromPeer, NetPacketReader reader, byte channel, DeliveryMethod deliveryMethod)
+        {
+            base.Listener_NetworkReceiveEvent(_incoming, fromPeer, reader, deliveryMethod, _mtu);
+        }
+
+        /// <summary>
+        /// Dequeues and processes outgoing.
+        /// </summary>
+        private void DequeueOutgoing()
+        {
+            NetPeer peer = null;
+            if (NetManager != null)
+                peer = NetManager.FirstPeer;
+            // Server connection hasn't been made.
+            if (peer == null)
+            {
+                /* Only dequeue outgoing because other queues might have
+                 * relevant information, such as the local connection queue. */
+                ClearPacketQueue(ref _outgoing);
+            }
+            else
+            {
+                int count = _outgoing.Count;
+                for (int i = 0; i < count; i++)
+                {
+                    Packet outgoing = _outgoing.Dequeue();
+
+                    ArraySegment<byte> segment = outgoing.GetArraySegment();
+                    DeliveryMethod dm = outgoing.Channel == (byte)Channel.Reliable ? DeliveryMethod.ReliableOrdered : DeliveryMethod.Unreliable;
+
+                    // If over the MTU.
+                    if (outgoing.Channel == (byte)Channel.Unreliable && segment.Count > _mtu)
+                    {
+                        Transport.NetworkManager.LogWarning($"Client is sending of {segment.Count} length on the unreliable channel, while the MTU is only {_mtu}. The channel has been changed to reliable for this send.");
+                        dm = DeliveryMethod.ReliableOrdered;
+                    }
+
+                    peer.Send(segment.Array, segment.Offset, segment.Count, dm);
+
+                    outgoing.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Allows for Outgoing queue to be iterated.
+        /// </summary>
+        internal void IterateOutgoing()
+        {
+            DequeueOutgoing();
+        }
+
+        /// <summary>
+        /// Iterates the Incoming queue.
+        /// </summary>
+        internal void IterateIncoming()
+        {
+            /* Run local connection states first so we can begin
+             * to read for data at the start of the frame, as that's
+             * where incoming is read. */
+            while (LocalConnectionStates.TryDequeue(out LocalConnectionState result))
+                SetConnectionState(result, false);
+
+            // Not yet started, cannot continue.
+            LocalConnectionState localState = GetConnectionState();
+            if (localState != LocalConnectionState.Started)
+            {
+                ResetQueues();
+                // If stopped try to kill task.
+                if (localState == LocalConnectionState.Stopped)
+                {
+                    StopSocket();
+                    return;
+                }
+            }
+
+            /* Incoming. */
+            while (_incoming.TryDequeue(out Packet incoming))
+            {
+                ClientReceivedDataArgs dataArgs = new(incoming.GetArraySegment(), (Channel)incoming.Channel, Transport.Index);
+                Transport.HandleClientReceivedDataArgs(dataArgs);
+                // Dispose of packet.
+                incoming.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Sends a packet to the server.
+        /// </summary>
+        internal void SendToServer(byte channelId, ArraySegment<byte> segment)
+        {
+            // Not started, cannot send.
+            if (GetConnectionState() != LocalConnectionState.Started)
+                return;
+
+            Send(ref _outgoing, channelId, segment, -1, _mtu);
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/ClientSocket.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 7944de5e4da77594db036e276174ee60
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/ClientSocket.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/CommonSocket.cs

@@ -0,0 +1,213 @@
+using FishNet.Utility.Performance;
+using LiteNetLib;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace FishNet.Transporting.Tugboat
+{
+    public abstract class CommonSocket
+    {
+        #region Internal.
+        /// <summary>
+        /// Current ConnectionState.
+        /// </summary>
+        private LocalConnectionState _connectionState = LocalConnectionState.Stopped;
+
+        /// <summary>
+        /// Returns the current ConnectionState.
+        /// </summary>
+        /// <returns></returns>
+        internal LocalConnectionState GetConnectionState()
+        {
+            return _connectionState;
+        }
+
+        /// <summary>
+        /// Sets a new connection state.
+        /// </summary>
+        /// <param name = "connectionState"></param>
+        protected void SetConnectionState(LocalConnectionState connectionState, bool asServer)
+        {
+            // If state hasn't changed.
+            if (connectionState == _connectionState)
+                return;
+
+            _connectionState = connectionState;
+            if (asServer)
+                Transport.HandleServerConnectionState(new(connectionState, Transport.Index));
+            else
+                Transport.HandleClientConnectionState(new(connectionState, Transport.Index));
+        }
+        #endregion
+
+        #region Internal.
+        /// <summary>
+        /// NetManager for this socket.
+        /// </summary>
+        internal NetManager NetManager;
+        #endregion
+
+        #region Protected.
+        /// <summary>
+        /// Changes to the sockets local connection state.
+        /// </summary>
+        protected ConcurrentQueue<LocalConnectionState> LocalConnectionStates = new();
+        /// <summary>
+        /// Transport controlling this socket.
+        /// </summary>
+        protected Transport Transport;
+        #endregion
+
+        #region Private.
+        /// <summary>
+        /// Locks the NetManager to stop it.
+        /// </summary>
+        private readonly object _stopLock = new();
+        #endregion
+
+        /// <summary>
+        /// Sends data to connectionId.
+        /// </summary>
+        internal void Send(ref Queue<Packet> queue, byte channelId, ArraySegment<byte> segment, int connectionId, int mtu)
+        {
+            if (GetConnectionState() != LocalConnectionState.Started)
+                return;
+
+            // ConnectionId isn't used from client to server.
+            Packet outgoing = new(connectionId, segment, channelId, mtu);
+            queue.Enqueue(outgoing);
+        }
+
+        /// <summary>
+        /// Updates the timeout for NetManager.
+        /// </summary>
+        protected void UpdateTimeout(NetManager netManager, int timeout)
+        {
+            if (netManager == null)
+                return;
+
+            timeout = timeout == 0 ? int.MaxValue : Math.Min(int.MaxValue, timeout * 1000);
+            netManager.DisconnectTimeout = timeout;
+        }
+
+        /// <summary>
+        /// Clears a ConcurrentQueue of any type.
+        /// </summary>
+        internal void ClearGenericQueue<T>(ref ConcurrentQueue<T> queue)
+        {
+            while (queue.TryDequeue(out _)) { }
+        }
+
+        /// <summary>
+        /// Clears a queue using Packet type.
+        /// </summary>
+        /// <param name = "queue"></param>
+        internal void ClearPacketQueue(ref ConcurrentQueue<Packet> queue)
+        {
+            while (queue.TryDequeue(out Packet p))
+                p.Dispose();
+        }
+
+        /// <summary>
+        /// Clears a queue using Packet type.
+        /// </summary>
+        /// <param name = "queue"></param>
+        internal void ClearPacketQueue(ref Queue<Packet> queue)
+        {
+            int count = queue.Count;
+            for (int i = 0; i < count; i++)
+            {
+                Packet p = queue.Dequeue();
+                p.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Called when data is received.
+        /// </summary>
+        internal virtual void Listener_NetworkReceiveEvent(ConcurrentQueue<Packet> queue, NetPeer fromPeer, NetPacketReader reader, DeliveryMethod deliveryMethod, int mtu)
+        {
+            // Set buffer.
+            int dataLen = reader.AvailableBytes;
+            // Prefer to max out returned array to mtu to reduce chance of resizing.
+            int arraySize = Math.Max(dataLen, mtu);
+            byte[] data = ByteArrayPool.Retrieve(arraySize);
+            reader.GetBytes(data, dataLen);
+            //Id.
+            int id = fromPeer.Id;
+            //Channel.
+            byte channel = deliveryMethod == DeliveryMethod.Unreliable ? (byte)Channel.Unreliable : (byte)Channel.Reliable;
+            //Add to packets.
+            Packet packet = new(id, data, dataLen, channel);
+            queue.Enqueue(packet);
+            //Recycle reader.
+            reader.Recycle();
+        }
+
+        internal void PollSocket(NetManager nm)
+        {
+            nm?.PollEvents();
+        }
+
+        /// <summary>
+        /// Stops the socket and updates local connection state.
+        /// </summary>
+        protected void StopSocket()
+        {
+            if (NetManager == null)
+                return;
+
+            bool threaded;
+            if (Transport is Tugboat tb)
+                threaded = tb.StopSocketsOnThread;
+            else
+                threaded = false;
+
+            //If using a thread.
+            if (threaded)
+            {
+                Task.Run(() =>
+                {
+                    lock (_stopLock)
+                    {
+                        NetManager?.Stop();
+                        NetManager = null;
+                    }
+
+                    //If not stopped yet also enqueue stop.
+                    if (GetConnectionState() != LocalConnectionState.Stopped)
+                        LocalConnectionStates.Enqueue(LocalConnectionState.Stopped);
+                });
+            }
+            //Not using a thread.
+            else
+            {
+                NetManager?.Stop();
+                NetManager = null;
+                //If not stopped yet also enqueue stop.
+                if (GetConnectionState() != LocalConnectionState.Stopped)
+                    LocalConnectionStates.Enqueue(LocalConnectionState.Stopped);
+            }
+        }
+
+        /// <summary>
+        /// Returns the port from the socket if active, otherwise returns null.
+        /// </summary>
+        /// <returns></returns>
+        internal ushort? GetPort()
+        {
+            if (NetManager == null || !NetManager.IsRunning)
+                return null;
+
+            int port = NetManager.LocalPort;
+            if (port < 0)
+                port = 0;
+            else if (port > ushort.MaxValue)
+                port = ushort.MaxValue;
+
+            return (ushort)port;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/CommonSocket.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 329169cdf51866c43a8c42e8aeb291fb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/CommonSocket.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/ServerSocket.cs

@@ -0,0 +1,502 @@
+using FishNet.Connection;
+using FishNet.Managing;
+using FishNet.Managing.Logging;
+using LiteNetLib;
+using LiteNetLib.Layers;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Net;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace FishNet.Transporting.Tugboat.Server
+{
+    public class ServerSocket : CommonSocket
+    {
+        #region Public.
+        /// <summary>
+        /// Gets the current ConnectionState of a remote client on the server.
+        /// </summary>
+        /// <param name = "connectionId">ConnectionId to get ConnectionState for.</param>
+        internal RemoteConnectionState GetConnectionState(int connectionId)
+        {
+            NetPeer peer = GetNetPeer(connectionId, false);
+            if (peer == null || peer.ConnectionState != ConnectionState.Connected)
+                return RemoteConnectionState.Stopped;
+            else
+                return RemoteConnectionState.Started;
+        }
+        #endregion
+
+        #region Private.
+        #region Configuration.
+        /// <summary>
+        /// Port used by server.
+        /// </summary>
+        private ushort _port;
+        /// <summary>
+        /// Maximum number of allowed clients.
+        /// </summary>
+        private int _maximumClients;
+        /// <summary>
+        /// MTU size per packet.
+        /// </summary>
+        private int _mtu;
+        #endregion
+
+        #region Queues.
+        /// <summary>
+        /// Inbound messages which need to be handled.
+        /// </summary>
+        private ConcurrentQueue<Packet> _incoming = new();
+        /// <summary>
+        /// Outbound messages which need to be handled.
+        /// </summary>
+        private Queue<Packet> _outgoing = new();
+        /// <summary>
+        /// ConnectionEvents which need to be handled.
+        /// </summary>
+        private ConcurrentQueue<RemoteConnectionEvent> _remoteConnectionEvents = new();
+        #endregion
+
+        /// <summary>
+        /// How long in seconds until client times from server.
+        /// </summary>
+        private int _timeout;
+        /// <summary>
+        /// IPv4 address to bind server to.
+        /// </summary>
+        private string _ipv4BindAddress;
+        /// <summary>
+        /// IPv6 address to bind server to.
+        /// </summary>
+        private string _ipv6BindAddress;
+        /// <summary>
+        /// PacketLayer to use with LiteNetLib.
+        /// </summary>
+        private PacketLayerBase _packetLayer;
+        /// <summary>
+        /// IPv6 is enabled only on demand, by default LiteNetLib always listens on IPv4 AND IPv6 which causes problems
+        /// if IPv6 is disabled on host. This can be the case in Linux environments
+        /// </summary>
+        private bool _enableIPv6;
+        #endregion
+
+        ~ServerSocket()
+        {
+            StopConnection();
+        }
+
+        /// <summary>
+        /// Initializes this for use.
+        /// </summary>
+        /// <param name = "t"></param>
+        internal void Initialize(Transport t, int unreliableMTU, PacketLayerBase packetLayer, bool enableIPv6)
+        {
+            Transport = t;
+            _mtu = unreliableMTU;
+            _packetLayer = packetLayer;
+            _enableIPv6 = enableIPv6;
+        }
+
+        /// <summary>
+        /// Updates the Timeout value as seconds.
+        /// </summary>
+        internal void UpdateTimeout(int timeout)
+        {
+            _timeout = timeout;
+            base.UpdateTimeout(NetManager, timeout);
+        }
+
+        /// <summary>
+        /// Polls the socket for new data.
+        /// </summary>
+        internal void PollSocket()
+        {
+            base.PollSocket(NetManager);
+        }
+
+        /// <summary>
+        /// Threaded operation to process server actions.
+        /// </summary>
+        private void ThreadedSocket()
+        {
+            EventBasedNetListener listener = new();
+            listener.ConnectionRequestEvent += Listener_ConnectionRequestEvent;
+            listener.PeerConnectedEvent += Listener_PeerConnectedEvent;
+            listener.NetworkReceiveEvent += Listener_NetworkReceiveEvent;
+            listener.PeerDisconnectedEvent += Listener_PeerDisconnectedEvent;
+
+            NetManager = new(listener, _packetLayer, false);
+            NetManager.DontRoute = ((Tugboat)Transport).DontRoute;
+            NetManager.ReuseAddress = ((Tugboat)Transport).ReuseAddress;
+            NetManager.MtuOverride = _mtu + NetConstants.FragmentedHeaderTotalSize;
+
+            UpdateTimeout(_timeout);
+
+            // Set bind addresses.
+            IPAddress ipv4 = null;
+            IPAddress ipv6 = null;
+
+            // Set ipv4
+            if (!string.IsNullOrEmpty(_ipv4BindAddress))
+            {
+                if (!IPAddress.TryParse(_ipv4BindAddress, out ipv4))
+                    ipv4 = null;
+
+                // If unable to parse try to get address another way.
+                if (ipv4 == null)
+                {
+                    IPHostEntry hostEntry = Dns.GetHostEntry(_ipv4BindAddress);
+                    if (hostEntry.AddressList.Length > 0)
+                    {
+                        ipv4 = hostEntry.AddressList[0];
+                        Transport.NetworkManager.Log($"IPv4 could not parse correctly but was resolved to {ipv4.ToString()}");
+                    }
+                }
+            }
+            else
+            {
+                IPAddress.TryParse("0.0.0.0", out ipv4);
+            }
+
+            if (_enableIPv6 && !string.IsNullOrEmpty(_ipv6BindAddress))
+            {
+                // Set ipv6 if protocol is enabled.
+                if (!IPAddress.TryParse(_ipv6BindAddress, out ipv6))
+                    ipv6 = null;
+            }
+            else
+            {
+                IPAddress.TryParse("0:0:0:0:0:0:0:0", out ipv6);
+            }
+
+            string ipv4FailText = ipv4 == null ? $"IPv4 address {_ipv4BindAddress} failed to parse. " : string.Empty;
+            string ipv6FailText = _enableIPv6 && ipv6 == null ? $"IPv6 address {_ipv6BindAddress} failed to parse. " : string.Empty;
+            if (ipv4FailText != string.Empty || ipv6FailText != string.Empty)
+            {
+                Transport.NetworkManager.Log($"{ipv4FailText}{ipv6FailText}Clear the bind address field to use any bind address.");
+                StopConnection();
+                return;
+            }
+
+            NetManager.IPv6Enabled = _enableIPv6;
+            bool startResult = NetManager.Start(ipv4, ipv6, _port);
+            //If started succcessfully.
+            if (startResult)
+            {
+                LocalConnectionStates.Enqueue(LocalConnectionState.Started);
+            }
+            //Failed to start.
+            else
+            {
+                Transport.NetworkManager.LogError($"Server failed to start. This usually occurs when the specified port is unavailable, be it closed or already in use.");
+                StopConnection();
+            }
+        }
+
+        /// <summary>
+        /// Gets the address of a remote connection Id.
+        /// </summary>
+        /// <param name = "connectionId"></param>
+        /// <returns>Returns string.empty if Id is not found.</returns>
+        internal string GetConnectionAddress(int connectionId)
+        {
+            if (GetConnectionState() != LocalConnectionState.Started)
+            {
+                NetworkManager nm = Transport == null ? null : Transport.NetworkManager;
+                string msg = "Server socket is not started.";
+                nm.LogWarning(msg);
+                return string.Empty;
+            }
+
+            NetPeer peer = GetNetPeer(connectionId, false);
+            if (peer == null)
+            {
+                Transport.NetworkManager.LogWarning($"Connection Id {connectionId} returned a null NetPeer.");
+                return string.Empty;
+            }
+
+            return peer.Address.ToString();
+        }
+
+        /// <summary>
+        /// Returns a NetPeer for connectionId.
+        /// </summary>
+        /// <param name = "connectionId"></param>
+        /// <returns></returns>
+        private NetPeer GetNetPeer(int connectionId, bool connectedOnly)
+        {
+            if (NetManager != null)
+            {
+                NetPeer peer = NetManager.GetPeerById(connectionId);
+                if (connectedOnly && peer != null && peer.ConnectionState != ConnectionState.Connected)
+                    peer = null;
+
+                return peer;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Starts the server.
+        /// </summary>
+        internal bool StartConnection(ushort port, int maximumClients, string ipv4BindAddress, string ipv6BindAddress)
+        {
+            //Force a stop just in case the socket did not clean up.
+            if (base.GetConnectionState() != LocalConnectionState.Stopped)
+                StopSocket();
+            //Enqueue starting.
+            LocalConnectionStates.Enqueue(LocalConnectionState.Starting);
+            //Iterate to cause state changes to invoke.
+            IterateIncoming();
+
+            //Assign properties.
+            _port = port;
+            _maximumClients = maximumClients;
+            _ipv4BindAddress = ipv4BindAddress;
+            _ipv6BindAddress = ipv6BindAddress;
+            ResetQueues();
+
+            Task.Run(ThreadedSocket);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Stops the local socket.
+        /// </summary>
+        internal bool StopConnection()
+        {
+            if (NetManager == null || base.GetConnectionState() == LocalConnectionState.Stopped || base.GetConnectionState() == LocalConnectionState.Stopping)
+                return false;
+
+            LocalConnectionStates.Enqueue(LocalConnectionState.Stopping);
+            StopSocket();
+            return true;
+        }
+
+        /// <summary>
+        /// Stops a remote client disconnecting the client from the server.
+        /// </summary>
+        /// <param name = "connectionId">ConnectionId of the client to disconnect.</param>
+        internal bool StopConnection(int connectionId)
+        {
+            //Server isn't running.
+            if (NetManager == null || base.GetConnectionState() != LocalConnectionState.Started)
+                return false;
+
+            NetPeer peer = GetNetPeer(connectionId, false);
+            if (peer == null)
+                return false;
+
+            try
+            {
+                peer.Disconnect();
+                //Let LiteNetLib get the disconnect event which will enqueue a remote connection state.
+                //base.Transport.HandleRemoteConnectionState(new RemoteConnectionStateArgs(RemoteConnectionState.Stopped, connectionId, base.Transport.Index));
+            }
+            catch
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Resets queues.
+        /// </summary>
+        private void ResetQueues()
+        {
+            ClearGenericQueue(ref LocalConnectionStates);
+            ClearPacketQueue(ref _incoming);
+            ClearPacketQueue(ref _outgoing);
+            ClearGenericQueue(ref _remoteConnectionEvents);
+        }
+
+        /// <summary>
+        /// Called when a peer disconnects or times out.
+        /// </summary>
+        private void Listener_PeerDisconnectedEvent(NetPeer peer, DisconnectInfo disconnectInfo)
+        {
+            _remoteConnectionEvents.Enqueue(new(false, peer.Id));
+        }
+
+        /// <summary>
+        /// Called when a peer completes connection.
+        /// </summary>
+        private void Listener_PeerConnectedEvent(NetPeer peer)
+        {
+            _remoteConnectionEvents.Enqueue(new(true, peer.Id));
+        }
+
+        /// <summary>
+        /// Called when data is received from a peer.
+        /// </summary>
+        private void Listener_NetworkReceiveEvent(NetPeer fromPeer, NetPacketReader reader, byte channel, DeliveryMethod deliveryMethod)
+        {
+            //If over the MTU.
+            if (reader.AvailableBytes > _mtu)
+            {
+                _remoteConnectionEvents.Enqueue(new(false, fromPeer.Id));
+                fromPeer.Disconnect();
+            }
+            else
+            {
+                base.Listener_NetworkReceiveEvent(_incoming, fromPeer, reader, deliveryMethod, _mtu);
+            }
+        }
+
+        /// <summary>
+        /// Called when a remote connection request is made.
+        /// </summary>
+        private void Listener_ConnectionRequestEvent(ConnectionRequest request)
+        {
+            if (NetManager == null)
+                return;
+
+            //At maximum peers.
+            if (NetManager.ConnectedPeersCount >= _maximumClients)
+            {
+                request.Reject();
+                return;
+            }
+
+            request.AcceptIfKey(key: string.Empty);
+        }
+
+        /// <summary>
+        /// Dequeues and processes outgoing.
+        /// </summary>
+        private void DequeueOutgoing()
+        {
+            if (base.GetConnectionState() != LocalConnectionState.Started || NetManager == null)
+            {
+                //Not started, clear outgoing.
+                ClearPacketQueue(ref _outgoing);
+            }
+            else
+            {
+                int count = _outgoing.Count;
+                for (int i = 0; i < count; i++)
+                {
+                    Packet outgoing = _outgoing.Dequeue();
+                    int connectionId = outgoing.ConnectionId;
+
+                    ArraySegment<byte> segment = outgoing.GetArraySegment();
+                    DeliveryMethod dm = outgoing.Channel == (byte)Channel.Reliable ? DeliveryMethod.ReliableOrdered : DeliveryMethod.Unreliable;
+
+                    //If over the MTU.
+                    if (outgoing.Channel == (byte)Channel.Unreliable && segment.Count > _mtu)
+                    {
+                        Transport.NetworkManager.LogWarning($"Server is sending of {segment.Count} length on the unreliable channel, while the MTU is only {_mtu}. The channel has been changed to reliable for this send.");
+                        dm = DeliveryMethod.ReliableOrdered;
+                    }
+
+                    //Send to all clients.
+                    if (connectionId == NetworkConnection.UNSET_CLIENTID_VALUE)
+                    {
+                        NetManager.SendToAll(segment.Array, segment.Offset, segment.Count, dm);
+                    }
+                    //Send to one client.
+                    else
+                    {
+                        NetPeer peer = GetNetPeer(connectionId, true);
+                        //If peer is found.
+                        if (peer != null)
+                            peer.Send(segment.Array, segment.Offset, segment.Count, dm);
+                    }
+
+                    outgoing.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Allows for Outgoing queue to be iterated.
+        /// </summary>
+        internal void IterateOutgoing()
+        {
+            DequeueOutgoing();
+        }
+
+        /// <summary>
+        /// Iterates the Incoming queue.
+        /// </summary>
+        internal void IterateIncoming()
+        {
+            /* Run local connection states first so we can begin
+             * to read for data at the start of the frame, as that's
+             * where incoming is read. */
+            while (LocalConnectionStates.TryDequeue(out LocalConnectionState result))
+                SetConnectionState(result, true);
+
+            //Not yet started.
+            LocalConnectionState localState = base.GetConnectionState();
+            if (localState != LocalConnectionState.Started)
+            {
+                ResetQueues();
+                //If stopped try to kill task.
+                if (localState == LocalConnectionState.Stopped)
+                {
+                    StopSocket();
+                    return;
+                }
+            }
+
+            //Handle connection and disconnection events.
+            while (_remoteConnectionEvents.TryDequeue(out RemoteConnectionEvent connectionEvent))
+            {
+                RemoteConnectionState state = connectionEvent.Connected ? RemoteConnectionState.Started : RemoteConnectionState.Stopped;
+                Transport.HandleRemoteConnectionState(new(state, connectionEvent.ConnectionId, Transport.Index));
+            }
+
+            //Handle packets.
+            while (_incoming.TryDequeue(out Packet incoming))
+            {
+                //Make sure peer is still connected.
+                NetPeer peer = GetNetPeer(incoming.ConnectionId, true);
+                if (peer != null)
+                {
+                    ServerReceivedDataArgs dataArgs = new(incoming.GetArraySegment(), (Channel)incoming.Channel, incoming.ConnectionId, Transport.Index);
+
+                    Transport.HandleServerReceivedDataArgs(dataArgs);
+                }
+
+                incoming.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Sends a packet to a single, or all clients.
+        /// </summary>
+        internal void SendToClient(byte channelId, ArraySegment<byte> segment, int connectionId)
+        {
+            Send(ref _outgoing, channelId, segment, connectionId, _mtu);
+        }
+
+        /// <summary>
+        /// Returns the maximum number of clients allowed to connect to the server. If the transport does not support this method the value -1 is returned.
+        /// </summary>
+        /// <returns></returns>
+        internal int GetMaximumClients()
+        {
+            return Math.Min(_maximumClients, NetworkConnection.MAXIMUM_CLIENTID_WITHOUT_SIMULATED_VALUE);
+        }
+
+        /// <summary>
+        /// Sets the MaximumClients value.
+        /// </summary>
+        /// <param name = "value"></param>
+        internal void SetMaximumClients(int value)
+        {
+            _maximumClients = value;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/ServerSocket.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 5c6703e8024041e45ae92566123865ad
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/ServerSocket.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/Supporting.cs

@@ -0,0 +1,57 @@
+using FishNet.Utility.Performance;
+using System;
+
+namespace FishNet.Transporting.Tugboat
+{
+    internal struct Packet
+    {
+        public readonly int ConnectionId;
+        public readonly byte[] Data;
+        public readonly int Length;
+        public readonly byte Channel;
+
+        public Packet(int connectionId, byte[] data, int length, byte channel)
+        {
+            ConnectionId = connectionId;
+            Data = data;
+            Length = length;
+            Channel = channel;
+        }
+
+        public Packet(int sender, ArraySegment<byte> segment, byte channel, int mtu)
+        {
+            // Prefer to max out returned array to mtu to reduce chance of resizing.
+            int arraySize = Math.Max(segment.Count, mtu);
+            Data = ByteArrayPool.Retrieve(arraySize);
+            Buffer.BlockCopy(segment.Array, segment.Offset, Data, 0, segment.Count);
+            ConnectionId = sender;
+            Length = segment.Count;
+            Channel = channel;
+        }
+
+        public ArraySegment<byte> GetArraySegment()
+        {
+            return new(Data, 0, Length);
+        }
+
+        public void Dispose()
+        {
+            ByteArrayPool.Store(Data);
+        }
+    }
+}
+
+namespace FishNet.Transporting.Tugboat.Server
+{
+    internal struct RemoteConnectionEvent
+    {
+        public readonly bool Connected;
+        public readonly int ConnectionId;
+
+        public RemoteConnectionEvent(bool connected, int connectionId)
+        {
+            Connected = connected;
+            ConnectionId = connectionId;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/Supporting.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 80c810a1a6a8f3345bb48abfb75c804a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Core/Supporting.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a537e10eb38767b4085a7bec020f9675
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Editor/TugboatEditor.cs

@@ -0,0 +1,85 @@
+#if UNITY_EDITOR
+using FishNet.Object;
+using UnityEditor;
+using UnityEngine;
+
+namespace FishNet.Transporting.Tugboat.Editing
+{
+    [CustomEditor(typeof(Tugboat), true)]
+    [CanEditMultipleObjects]
+    public class TugboatEditor : Editor
+    {
+        private SerializedProperty _stopSocketsOnThread;
+        private SerializedProperty _dontRoute;
+        private SerializedProperty _reuseAddress;
+        private SerializedProperty _unreliableMtu;
+        private SerializedProperty _ipv4BindAddress;
+        private SerializedProperty _enableIpv6;
+        private SerializedProperty _ipv6BindAddress;
+        private SerializedProperty _port;
+        private SerializedProperty _maximumClients;
+        private SerializedProperty _clientAddress;
+
+        protected virtual void OnEnable()
+        {
+            _stopSocketsOnThread = serializedObject.FindProperty(nameof(_stopSocketsOnThread));
+            _dontRoute = serializedObject.FindProperty(nameof(_dontRoute));
+            _reuseAddress = serializedObject.FindProperty(nameof(_reuseAddress));
+            _unreliableMtu = serializedObject.FindProperty(nameof(_unreliableMtu));
+            _ipv4BindAddress = serializedObject.FindProperty(nameof(_ipv4BindAddress));
+            _enableIpv6 = serializedObject.FindProperty(nameof(_enableIpv6));
+            _ipv6BindAddress = serializedObject.FindProperty(nameof(_ipv6BindAddress));
+            _port = serializedObject.FindProperty(nameof(_port));
+            _maximumClients = serializedObject.FindProperty(nameof(_maximumClients));
+            _clientAddress = serializedObject.FindProperty(nameof(_clientAddress));
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            Tugboat tb = (Tugboat)target;
+
+            GUI.enabled = false;
+            EditorGUILayout.ObjectField("Script:", MonoScript.FromMonoBehaviour(tb), typeof(Tugboat), false);
+            GUI.enabled = true;
+
+            EditorGUILayout.LabelField("Settings", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(_stopSocketsOnThread);
+            EditorGUILayout.PropertyField(_dontRoute);
+            EditorGUI.indentLevel--;
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Channels", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(_unreliableMtu);
+            EditorGUI.indentLevel--;
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Server", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(_reuseAddress);
+            EditorGUILayout.PropertyField(_ipv4BindAddress);
+            EditorGUILayout.PropertyField(_enableIpv6);
+            if (_enableIpv6.boolValue == true)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(_ipv6BindAddress);
+                EditorGUI.indentLevel--;
+            }
+            EditorGUILayout.PropertyField(_port);
+            EditorGUILayout.PropertyField(_maximumClients);
+            EditorGUI.indentLevel--;
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("Client", EditorStyles.boldLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(_clientAddress);
+            EditorGUI.indentLevel--;
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
+
+#endif

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Editor/TugboatEditor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 578d8bb2922ac0648a90b969512b9779
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Editor/TugboatEditor.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 12f412d6d520d5c45bb49d177690e507
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/BaseChannel.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using System.Threading;
+
+namespace LiteNetLib
+{
+    internal abstract class BaseChannel
+    {
+        protected readonly NetPeer Peer;
+        protected readonly Queue<NetPacket> OutgoingQueue = new(NetConstants.DefaultWindowSize);
+        private int _isAddedToPeerChannelSendQueue;
+        public int PacketsInQueue => OutgoingQueue.Count;
+
+        protected BaseChannel(NetPeer peer)
+        {
+            Peer = peer;
+        }
+
+        public void AddToQueue(NetPacket packet)
+        {
+            lock (OutgoingQueue)
+            {
+                OutgoingQueue.Enqueue(packet);
+            }
+            AddToPeerChannelSendQueue();
+        }
+
+        protected void AddToPeerChannelSendQueue()
+        {
+            if (Interlocked.CompareExchange(ref _isAddedToPeerChannelSendQueue, 1, 0) == 0)
+            {
+                Peer.AddToReliableChannelSendQueue(this);
+            }
+        }
+
+        public bool SendAndCheckQueue()
+        {
+            bool hasPacketsToSend = SendNextPackets();
+            if (!hasPacketsToSend)
+                Interlocked.Exchange(ref _isAddedToPeerChannelSendQueue, 0);
+
+            return hasPacketsToSend;
+        }
+
+        protected abstract bool SendNextPackets();
+        public abstract bool ProcessPacket(NetPacket packet);
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/BaseChannel.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 70b7c357a9f57f5479c5d94550d26280
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/BaseChannel.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/ConnectionRequest.cs

@@ -0,0 +1,129 @@
+using System.Net;
+using System.Threading;
+using LiteNetLib.Utils;
+
+namespace LiteNetLib
+{
+    internal enum ConnectionRequestResult
+    {
+        None,
+        Accept,
+        Reject,
+        RejectForce
+    }
+
+    public class ConnectionRequest
+    {
+        private readonly NetManager _listener;
+        private int _used;
+        public NetDataReader Data => InternalPacket.Data;
+        internal ConnectionRequestResult Result { get; private set; }
+        internal NetConnectRequestPacket InternalPacket;
+        public readonly IPEndPoint RemoteEndPoint;
+
+        internal void UpdateRequest(NetConnectRequestPacket connectRequest)
+        {
+            // old request
+            if (connectRequest.ConnectionTime < InternalPacket.ConnectionTime)
+                return;
+
+            if (connectRequest.ConnectionTime == InternalPacket.ConnectionTime && connectRequest.ConnectionNumber == InternalPacket.ConnectionNumber)
+                return;
+
+            InternalPacket = connectRequest;
+        }
+
+        private bool TryActivate()
+        {
+            return Interlocked.CompareExchange(ref _used, 1, 0) == 0;
+        }
+
+        internal ConnectionRequest(IPEndPoint remoteEndPoint, NetConnectRequestPacket requestPacket, NetManager listener)
+        {
+            InternalPacket = requestPacket;
+            RemoteEndPoint = remoteEndPoint;
+            _listener = listener;
+        }
+
+        public NetPeer AcceptIfKey(string key)
+        {
+            if (!TryActivate())
+                return null;
+            try
+            {
+                if (Data.GetString() == key)
+                    Result = ConnectionRequestResult.Accept;
+            }
+            catch
+            {
+                NetDebug.WriteError("[AC] Invalid incoming data");
+            }
+            if (Result == ConnectionRequestResult.Accept)
+                return _listener.OnConnectionSolved(this, null, 0, 0);
+
+            Result = ConnectionRequestResult.Reject;
+            _listener.OnConnectionSolved(this, null, 0, 0);
+            return null;
+        }
+
+        /// <summary>
+        /// Accept connection and get new NetPeer as result
+        /// </summary>
+        /// <returns>Connected NetPeer</returns>
+        public NetPeer Accept()
+        {
+            if (!TryActivate())
+                return null;
+            Result = ConnectionRequestResult.Accept;
+            return _listener.OnConnectionSolved(this, null, 0, 0);
+        }
+
+        public void Reject(byte[] rejectData, int start, int length, bool force)
+        {
+            if (!TryActivate())
+                return;
+            Result = force ? ConnectionRequestResult.RejectForce : ConnectionRequestResult.Reject;
+            _listener.OnConnectionSolved(this, rejectData, start, length);
+        }
+
+        public void Reject(byte[] rejectData, int start, int length)
+        {
+            Reject(rejectData, start, length, false);
+        }
+
+        public void RejectForce(byte[] rejectData, int start, int length)
+        {
+            Reject(rejectData, start, length, true);
+        }
+
+        public void RejectForce()
+        {
+            Reject(null, 0, 0, true);
+        }
+
+        public void RejectForce(byte[] rejectData)
+        {
+            Reject(rejectData, 0, rejectData.Length, true);
+        }
+
+        public void RejectForce(NetDataWriter rejectData)
+        {
+            Reject(rejectData.Data, 0, rejectData.Length, true);
+        }
+
+        public void Reject()
+        {
+            Reject(null, 0, 0, false);
+        }
+
+        public void Reject(byte[] rejectData)
+        {
+            Reject(rejectData, 0, rejectData.Length, false);
+        }
+
+        public void Reject(NetDataWriter rejectData)
+        {
+            Reject(rejectData.Data, 0, rejectData.Length, false);
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/ConnectionRequest.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 5e609855f95e9034889c882b51aaec68
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/ConnectionRequest.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/INetEventListener.cs

@@ -0,0 +1,279 @@
+using System.Net;
+using System.Net.Sockets;
+using LiteNetLib.Utils;
+
+namespace LiteNetLib
+{
+    /// <summary>
+    /// Type of message that you receive in OnNetworkReceiveUnconnected event
+    /// </summary>
+    public enum UnconnectedMessageType
+    {
+        BasicMessage,
+        Broadcast
+    }
+
+    /// <summary>
+    /// Disconnect reason that you receive in OnPeerDisconnected event
+    /// </summary>
+    public enum DisconnectReason
+    {
+        ConnectionFailed,
+        Timeout,
+        HostUnreachable,
+        NetworkUnreachable,
+        RemoteConnectionClose,
+        DisconnectPeerCalled,
+        ConnectionRejected,
+        InvalidProtocol,
+        UnknownHost,
+        Reconnect,
+        PeerToPeerConnection,
+        PeerNotFound
+    }
+
+    /// <summary>
+    /// Additional information about disconnection
+    /// </summary>
+    public struct DisconnectInfo
+    {
+        /// <summary>
+        /// Additional info why peer disconnected
+        /// </summary>
+        public DisconnectReason Reason;
+        /// <summary>
+        /// Error code (if reason is SocketSendError or SocketReceiveError)
+        /// </summary>
+        public SocketError SocketErrorCode;
+        /// <summary>
+        /// Additional data that can be accessed (only if reason is RemoteConnectionClose)
+        /// </summary>
+        public NetPacketReader AdditionalData;
+    }
+
+    public interface INetEventListener
+    {
+        /// <summary>
+        /// New remote peer connected to host, or client connected to remote host
+        /// </summary>
+        /// <param name = "peer">Connected peer object</param>
+        void OnPeerConnected(NetPeer peer);
+
+        /// <summary>
+        /// Peer disconnected
+        /// </summary>
+        /// <param name = "peer">disconnected peer</param>
+        /// <param name = "disconnectInfo">additional info about reason, errorCode or data received with disconnect message</param>
+        void OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo);
+
+        /// <summary>
+        /// Network error (on send or receive)
+        /// </summary>
+        /// <param name = "endPoint">From endPoint (can be null)</param>
+        /// <param name = "socketError">Socket error</param>
+        void OnNetworkError(IPEndPoint endPoint, SocketError socketError);
+
+        /// <summary>
+        /// Received some data
+        /// </summary>
+        /// <param name = "peer">From peer</param>
+        /// <param name = "reader">DataReader containing all received data</param>
+        /// <param name = "channelNumber">Number of channel at which packet arrived</param>
+        /// <param name = "deliveryMethod">Type of received packet</param>
+        void OnNetworkReceive(NetPeer peer, NetPacketReader reader, byte channelNumber, DeliveryMethod deliveryMethod);
+
+        /// <summary>
+        /// Received unconnected message
+        /// </summary>
+        /// <param name = "remoteEndPoint">From address (IP and Port)</param>
+        /// <param name = "reader">Message data</param>
+        /// <param name = "messageType">Message type (simple, discovery request or response)</param>
+        void OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType);
+
+        /// <summary>
+        /// Latency information updated
+        /// </summary>
+        /// <param name = "peer">Peer with updated latency</param>
+        /// <param name = "latency">latency value in milliseconds</param>
+        void OnNetworkLatencyUpdate(NetPeer peer, int latency);
+
+        /// <summary>
+        /// On peer connection requested
+        /// </summary>
+        /// <param name = "request">Request information (EndPoint, internal id, additional data)</param>
+        void OnConnectionRequest(ConnectionRequest request);
+    }
+
+    public interface IDeliveryEventListener
+    {
+        /// <summary>
+        /// On reliable message delivered
+        /// </summary>
+        /// <param name = "peer"></param>
+        /// <param name = "userData"></param>
+        void OnMessageDelivered(NetPeer peer, object userData);
+    }
+
+    public interface INtpEventListener
+    {
+        /// <summary>
+        /// Ntp response
+        /// </summary>
+        /// <param name = "packet"></param>
+        void OnNtpResponse(NtpPacket packet);
+    }
+
+    public interface IPeerAddressChangedListener
+    {
+        /// <summary>
+        /// Called when peer address changed (when AllowPeerAddressChange is enabled)
+        /// </summary>
+        /// <param name = "peer">Peer that changed address (with new address)</param>
+        /// <param name = "previousAddress">previous IP</param>
+        void OnPeerAddressChanged(NetPeer peer, IPEndPoint previousAddress);
+    }
+
+    public class EventBasedNetListener : INetEventListener, IDeliveryEventListener, INtpEventListener, IPeerAddressChangedListener
+    {
+        public delegate void OnPeerConnected(NetPeer peer);
+
+        public delegate void OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo);
+
+        public delegate void OnNetworkError(IPEndPoint endPoint, SocketError socketError);
+
+        public delegate void OnNetworkReceive(NetPeer peer, NetPacketReader reader, byte channel, DeliveryMethod deliveryMethod);
+
+        public delegate void OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType);
+
+        public delegate void OnNetworkLatencyUpdate(NetPeer peer, int latency);
+
+        public delegate void OnConnectionRequest(ConnectionRequest request);
+
+        public delegate void OnDeliveryEvent(NetPeer peer, object userData);
+
+        public delegate void OnNtpResponseEvent(NtpPacket packet);
+
+        public delegate void OnPeerAddressChangedEvent(NetPeer peer, IPEndPoint previousAddress);
+
+        public event OnPeerConnected PeerConnectedEvent;
+        public event OnPeerDisconnected PeerDisconnectedEvent;
+        public event OnNetworkError NetworkErrorEvent;
+        public event OnNetworkReceive NetworkReceiveEvent;
+        public event OnNetworkReceiveUnconnected NetworkReceiveUnconnectedEvent;
+        public event OnNetworkLatencyUpdate NetworkLatencyUpdateEvent;
+        public event OnConnectionRequest ConnectionRequestEvent;
+        public event OnDeliveryEvent DeliveryEvent;
+        public event OnNtpResponseEvent NtpResponseEvent;
+        public event OnPeerAddressChangedEvent PeerAddressChangedEvent;
+
+        public void ClearPeerConnectedEvent()
+        {
+            PeerConnectedEvent = null;
+        }
+
+        public void ClearPeerDisconnectedEvent()
+        {
+            PeerDisconnectedEvent = null;
+        }
+
+        public void ClearNetworkErrorEvent()
+        {
+            NetworkErrorEvent = null;
+        }
+
+        public void ClearNetworkReceiveEvent()
+        {
+            NetworkReceiveEvent = null;
+        }
+
+        public void ClearNetworkReceiveUnconnectedEvent()
+        {
+            NetworkReceiveUnconnectedEvent = null;
+        }
+
+        public void ClearNetworkLatencyUpdateEvent()
+        {
+            NetworkLatencyUpdateEvent = null;
+        }
+
+        public void ClearConnectionRequestEvent()
+        {
+            ConnectionRequestEvent = null;
+        }
+
+        public void ClearDeliveryEvent()
+        {
+            DeliveryEvent = null;
+        }
+
+        public void ClearNtpResponseEvent()
+        {
+            NtpResponseEvent = null;
+        }
+
+        public void ClearPeerAddressChangedEvent()
+        {
+            PeerAddressChangedEvent = null;
+        }
+
+        void INetEventListener.OnPeerConnected(NetPeer peer)
+        {
+            if (PeerConnectedEvent != null)
+                PeerConnectedEvent(peer);
+        }
+
+        void INetEventListener.OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo)
+        {
+            if (PeerDisconnectedEvent != null)
+                PeerDisconnectedEvent(peer, disconnectInfo);
+        }
+
+        void INetEventListener.OnNetworkError(IPEndPoint endPoint, SocketError socketErrorCode)
+        {
+            if (NetworkErrorEvent != null)
+                NetworkErrorEvent(endPoint, socketErrorCode);
+        }
+
+        void INetEventListener.OnNetworkReceive(NetPeer peer, NetPacketReader reader, byte channelNumber, DeliveryMethod deliveryMethod)
+        {
+            if (NetworkReceiveEvent != null)
+                NetworkReceiveEvent(peer, reader, channelNumber, deliveryMethod);
+        }
+
+        void INetEventListener.OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
+        {
+            if (NetworkReceiveUnconnectedEvent != null)
+                NetworkReceiveUnconnectedEvent(remoteEndPoint, reader, messageType);
+        }
+
+        void INetEventListener.OnNetworkLatencyUpdate(NetPeer peer, int latency)
+        {
+            if (NetworkLatencyUpdateEvent != null)
+                NetworkLatencyUpdateEvent(peer, latency);
+        }
+
+        void INetEventListener.OnConnectionRequest(ConnectionRequest request)
+        {
+            if (ConnectionRequestEvent != null)
+                ConnectionRequestEvent(request);
+        }
+
+        void IDeliveryEventListener.OnMessageDelivered(NetPeer peer, object userData)
+        {
+            if (DeliveryEvent != null)
+                DeliveryEvent(peer, userData);
+        }
+
+        void INtpEventListener.OnNtpResponse(NtpPacket packet)
+        {
+            if (NtpResponseEvent != null)
+                NtpResponseEvent(packet);
+        }
+
+        void IPeerAddressChangedListener.OnPeerAddressChanged(NetPeer peer, IPEndPoint previousAddress)
+        {
+            if (PeerAddressChangedEvent != null)
+                PeerAddressChangedEvent(peer, previousAddress);
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/INetEventListener.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 79436ed5864cf48418ac341ea3c70a6b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/INetEventListener.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/InternalPackets.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Net;
+using LiteNetLib.Utils;
+
+namespace LiteNetLib
+{
+    internal sealed class NetConnectRequestPacket
+    {
+        public const int HeaderSize = 18;
+        public readonly long ConnectionTime;
+        public byte ConnectionNumber;
+        public readonly byte[] TargetAddress;
+        public readonly NetDataReader Data;
+        public readonly int PeerId;
+
+        private NetConnectRequestPacket(long connectionTime, byte connectionNumber, int localId, byte[] targetAddress, NetDataReader data)
+        {
+            ConnectionTime = connectionTime;
+            ConnectionNumber = connectionNumber;
+            TargetAddress = targetAddress;
+            Data = data;
+            PeerId = localId;
+        }
+
+        public static int GetProtocolId(NetPacket packet)
+        {
+            return BitConverter.ToInt32(packet.RawData, 1);
+        }
+
+        public static NetConnectRequestPacket FromData(NetPacket packet)
+        {
+            if (packet.ConnectionNumber >= NetConstants.MaxConnectionNumber)
+                return null;
+
+            // Getting connection time for peer
+            long connectionTime = BitConverter.ToInt64(packet.RawData, 5);
+
+            // Get peer id
+            int peerId = BitConverter.ToInt32(packet.RawData, 13);
+
+            // Get target address
+            int addrSize = packet.RawData[HeaderSize - 1];
+            if (addrSize != 16 && addrSize != 28)
+                return null;
+            byte[] addressBytes = new byte[addrSize];
+            Buffer.BlockCopy(packet.RawData, HeaderSize, addressBytes, 0, addrSize);
+
+            // Read data and create request
+            NetDataReader reader = new(null, 0, 0);
+            if (packet.Size > HeaderSize + addrSize)
+                reader.SetSource(packet.RawData, HeaderSize + addrSize, packet.Size);
+
+            return new(connectionTime, packet.ConnectionNumber, peerId, addressBytes, reader);
+        }
+
+        public static NetPacket Make(NetDataWriter connectData, SocketAddress addressBytes, long connectTime, int localId)
+        {
+            // Make initial packet
+            NetPacket packet = new(PacketProperty.ConnectRequest, connectData.Length + addressBytes.Size);
+
+            // Add data
+            FastBitConverter.GetBytes(packet.RawData, 1, NetConstants.ProtocolId);
+            FastBitConverter.GetBytes(packet.RawData, 5, connectTime);
+            FastBitConverter.GetBytes(packet.RawData, 13, localId);
+            packet.RawData[HeaderSize - 1] = (byte)addressBytes.Size;
+            for (int i = 0; i < addressBytes.Size; i++)
+                packet.RawData[HeaderSize + i] = addressBytes[i];
+            Buffer.BlockCopy(connectData.Data, 0, packet.RawData, HeaderSize + addressBytes.Size, connectData.Length);
+            return packet;
+        }
+    }
+
+    internal sealed class NetConnectAcceptPacket
+    {
+        public const int Size = 15;
+        public readonly long ConnectionTime;
+        public readonly byte ConnectionNumber;
+        public readonly int PeerId;
+        public readonly bool PeerNetworkChanged;
+
+        private NetConnectAcceptPacket(long connectionTime, byte connectionNumber, int peerId, bool peerNetworkChanged)
+        {
+            ConnectionTime = connectionTime;
+            ConnectionNumber = connectionNumber;
+            PeerId = peerId;
+            PeerNetworkChanged = peerNetworkChanged;
+        }
+
+        public static NetConnectAcceptPacket FromData(NetPacket packet)
+        {
+            if (packet.Size != Size)
+                return null;
+
+            long connectionId = BitConverter.ToInt64(packet.RawData, 1);
+
+            // check connect num
+            byte connectionNumber = packet.RawData[9];
+            if (connectionNumber >= NetConstants.MaxConnectionNumber)
+                return null;
+
+            // check reused flag
+            byte isReused = packet.RawData[10];
+            if (isReused > 1)
+                return null;
+
+            // get remote peer id
+            int peerId = BitConverter.ToInt32(packet.RawData, 11);
+            if (peerId < 0)
+                return null;
+
+            return new(connectionId, connectionNumber, peerId, isReused == 1);
+        }
+
+        public static NetPacket Make(long connectTime, byte connectNum, int localPeerId)
+        {
+            NetPacket packet = new(PacketProperty.ConnectAccept, 0);
+            FastBitConverter.GetBytes(packet.RawData, 1, connectTime);
+            packet.RawData[9] = connectNum;
+            FastBitConverter.GetBytes(packet.RawData, 11, localPeerId);
+            return packet;
+        }
+
+        public static NetPacket MakeNetworkChanged(NetPeer peer)
+        {
+            NetPacket packet = new(PacketProperty.PeerNotFound, Size - 1);
+            FastBitConverter.GetBytes(packet.RawData, 1, peer.ConnectTime);
+            packet.RawData[9] = peer.ConnectionNum;
+            packet.RawData[10] = 1;
+            FastBitConverter.GetBytes(packet.RawData, 11, peer.RemoteId);
+            return packet;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/InternalPackets.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: b8582459906515843a2f2adb010c3fd7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/InternalPackets.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Layers.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5fa8ca1b7ce0a0041a2ddfebeef8c8fe
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Layers/Crc32cLayer.cs

@@ -0,0 +1,38 @@
+using LiteNetLib.Utils;
+using System;
+using System.Net;
+
+namespace LiteNetLib.Layers
+{
+    public sealed class Crc32cLayer : PacketLayerBase
+    {
+        public Crc32cLayer() : base(CRC32C.ChecksumSize) { }
+
+        public override void ProcessInboundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int length)
+        {
+            if (length < NetConstants.HeaderSize + CRC32C.ChecksumSize)
+            {
+                NetDebug.WriteError("[NM] DataReceived size: bad!");
+                // Set length to 0 to have netManager drop the packet.
+                length = 0;
+                return;
+            }
+
+            int checksumPoint = length - CRC32C.ChecksumSize;
+            if (CRC32C.Compute(data, 0, checksumPoint) != BitConverter.ToUInt32(data, checksumPoint))
+            {
+                NetDebug.Write("[NM] DataReceived checksum: bad!");
+                // Set length to 0 to have netManager drop the packet.
+                length = 0;
+                return;
+            }
+            length -= CRC32C.ChecksumSize;
+        }
+
+        public override void ProcessOutBoundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int offset, ref int length)
+        {
+            FastBitConverter.GetBytes(data, length, CRC32C.Compute(data, offset, length));
+            length += CRC32C.ChecksumSize;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Layers/Crc32cLayer.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 7d52aafc1486ec842a8d133ef41dfd39
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Layers/Crc32cLayer.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Layers/PacketLayerBase.cs

@@ -0,0 +1,17 @@
+using System.Net;
+
+namespace LiteNetLib.Layers
+{
+    public abstract class PacketLayerBase
+    {
+        public readonly int ExtraPacketSizeForLayer;
+
+        protected PacketLayerBase(int extraPacketSizeForLayer)
+        {
+            ExtraPacketSizeForLayer = extraPacketSizeForLayer;
+        }
+
+        public abstract void ProcessInboundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int length);
+        public abstract void ProcessOutBoundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int offset, ref int length);
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Layers/PacketLayerBase.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: bddd0b5590cce7e42918c72429b84bde
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Layers/PacketLayerBase.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Layers/XorEncryptLayer.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Net;
+using System.Text;
+
+namespace LiteNetLib.Layers
+{
+    public class XorEncryptLayer : PacketLayerBase
+    {
+        private byte[] _byteKey;
+        public XorEncryptLayer() : base(0) { }
+
+        public XorEncryptLayer(byte[] key) : this()
+        {
+            SetKey(key);
+        }
+
+        public XorEncryptLayer(string key) : this()
+        {
+            SetKey(key);
+        }
+
+        public void SetKey(string key)
+        {
+            _byteKey = Encoding.UTF8.GetBytes(key);
+        }
+
+        public void SetKey(byte[] key)
+        {
+            if (_byteKey == null || _byteKey.Length != key.Length)
+                _byteKey = new byte[key.Length];
+            Buffer.BlockCopy(key, 0, _byteKey, 0, key.Length);
+        }
+
+        public override void ProcessInboundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int length)
+        {
+            if (_byteKey == null)
+                return;
+            for (int i = 0; i < length; i++)
+            {
+                data[i] = (byte)(data[i] ^ _byteKey[i % _byteKey.Length]);
+            }
+        }
+
+        public override void ProcessOutBoundPacket(ref IPEndPoint endPoint, ref byte[] data, ref int offset, ref int length)
+        {
+            if (_byteKey == null)
+                return;
+            int cur = offset;
+            for (int i = 0; i < length; i++, cur++)
+            {
+                data[cur] = (byte)(data[cur] ^ _byteKey[i % _byteKey.Length]);
+            }
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Layers/XorEncryptLayer.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: fb37499ecdd1ce145b0bcaf4b4f0279e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Layers/XorEncryptLayer.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/LiteNetLib.csproj

@@ -0,0 +1,66 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <AssemblyName>LiteNetLib</AssemblyName>
+    <RootNamespace>LiteNetLib</RootNamespace>
+    <TargetFrameworks Condition="'$(OS)' != 'Windows_NT'">net6.0;net5.0;netcoreapp3.1;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks Condition="'$(OS)' == 'Windows_NT'">net471;net6.0;net5.0;netstandard2.0;netstandard2.1;netcoreapp3.1</TargetFrameworks>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <OutputType>Library</OutputType>
+    <LangVersion>7.3</LangVersion>
+
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <NoWarn>1701;1702;1705;1591</NoWarn>
+    <PackageVersion>1.2.0</PackageVersion>
+    <Title>Lite reliable UDP library for Mono and .NET </Title>
+    <IsTrimmable>true</IsTrimmable>
+    <EnableTrimAnalyzer>true</EnableTrimAnalyzer>
+    <AssemblyVersion>1.2.0</AssemblyVersion>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+    <DefineConstants>TRACE</DefineConstants>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DefineConstants>$(DefineConstants);LITENETLIB_UNSAFE</DefineConstants>
+    <PackageTags>udp reliable-udp network</PackageTags>
+    <PackageReleaseNotes>https://github.com/RevenantX/LiteNetLib/releases/tag/v1.2.0</PackageReleaseNotes>
+    <RepositoryType>git</RepositoryType>
+    <RepositoryUrl>https://github.com/RevenantX/LiteNetLib</RepositoryUrl>
+    <PackageProjectUrl>https://github.com/RevenantX/LiteNetLib</PackageProjectUrl>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+    <Version>1.1.0</Version>
+    <Authors>Ruslan Pyrch</Authors>
+    <Copyright>Copyright 2023 Ruslan Pyrch</Copyright>
+    <Description>Lite reliable UDP library for .NET, Mono, and .NET Core</Description>
+    <PackageIcon>LNL.png</PackageIcon>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <TargetFrameworks>net5.0;net6.0;net7.0;net8.0;netstandard2.0;netstandard2.1;net471</TargetFrameworks>
+  </PropertyGroup>
+
+  <Target Name="UpdateUnityDLLS" AfterTargets="CopyFilesToOutputDirectory" Condition=" '$(TargetFramework)' == 'net471' and '$(Configuration)' == 'Release' ">
+    <ItemGroup>
+      <LibraryRelease Include="$(TargetDir)LiteNetLib.dll;$(TargetDir)LiteNetLib.pdb;$(TargetDir)LiteNetLib.xml" />
+    </ItemGroup>
+    <Copy SourceFiles="@(LibraryRelease)" DestinationFolder="..\LiteNetLibSampleUnity\Assets" />
+  </Target>
+
+  <ItemGroup>
+    <None Include="..\LNL.png">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+    <None Include="..\README.md">
+      <Pack>True</Pack>
+      <PackagePath>\</PackagePath>
+    </None>
+  </ItemGroup>
+
+</Project>

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/LiteNetLib.csproj.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 1ec83424c5410b04aab06dddca60e7f6
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/LiteNetLib.csproj
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NatPunchModule.cs

@@ -0,0 +1,289 @@
+using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
+using System.Net;
+using System.Net.Sockets;
+using LiteNetLib.Utils;
+
+namespace LiteNetLib
+{
+    public enum NatAddressType
+    {
+        Internal,
+        External
+    }
+
+    public interface INatPunchListener
+    {
+        void OnNatIntroductionRequest(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint, string token);
+        void OnNatIntroductionSuccess(IPEndPoint targetEndPoint, NatAddressType type, string token);
+    }
+
+    public class EventBasedNatPunchListener : INatPunchListener
+    {
+        public delegate void OnNatIntroductionRequest(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint, string token);
+
+        public delegate void OnNatIntroductionSuccess(IPEndPoint targetEndPoint, NatAddressType type, string token);
+
+        public event OnNatIntroductionRequest NatIntroductionRequest;
+        public event OnNatIntroductionSuccess NatIntroductionSuccess;
+
+        void INatPunchListener.OnNatIntroductionRequest(IPEndPoint localEndPoint, IPEndPoint remoteEndPoint, string token)
+        {
+            if (NatIntroductionRequest != null)
+                NatIntroductionRequest(localEndPoint, remoteEndPoint, token);
+        }
+
+        void INatPunchListener.OnNatIntroductionSuccess(IPEndPoint targetEndPoint, NatAddressType type, string token)
+        {
+            if (NatIntroductionSuccess != null)
+                NatIntroductionSuccess(targetEndPoint, type, token);
+        }
+    }
+
+    /// <summary>
+    /// Module for UDP NAT Hole punching operations. Can be accessed from NetManager
+    /// </summary>
+    public sealed class NatPunchModule
+    {
+        private struct RequestEventData
+        {
+            public IPEndPoint LocalEndPoint;
+            public IPEndPoint RemoteEndPoint;
+            public string Token;
+        }
+
+        private struct SuccessEventData
+        {
+            public IPEndPoint TargetEndPoint;
+            public NatAddressType Type;
+            public string Token;
+        }
+
+        private class NatIntroduceRequestPacket
+        {
+            public IPEndPoint Internal
+            {
+                [Preserve]
+                get;
+                [Preserve]
+                set;
+            }
+            public string Token
+            {
+                [Preserve]
+                get;
+                [Preserve]
+                set;
+            }
+        }
+
+        private class NatIntroduceResponsePacket
+        {
+            public IPEndPoint Internal
+            {
+                [Preserve]
+                get;
+                [Preserve]
+                set;
+            }
+            public IPEndPoint External
+            {
+                [Preserve]
+                get;
+                [Preserve]
+                set;
+            }
+            public string Token
+            {
+                [Preserve]
+                get;
+                [Preserve]
+                set;
+            }
+        }
+
+        private class NatPunchPacket
+        {
+            public string Token
+            {
+                [Preserve]
+                get;
+                [Preserve]
+                set;
+            }
+            public bool IsExternal
+            {
+                [Preserve]
+                get;
+                [Preserve]
+                set;
+            }
+        }
+
+        private readonly NetManager _socket;
+        private readonly ConcurrentQueue<RequestEventData> _requestEvents = new();
+        private readonly ConcurrentQueue<SuccessEventData> _successEvents = new();
+        private readonly NetDataReader _cacheReader = new();
+        private readonly NetDataWriter _cacheWriter = new();
+        private readonly NetPacketProcessor _netPacketProcessor = new(MaxTokenLength);
+        private INatPunchListener _natPunchListener;
+        public const int MaxTokenLength = 256;
+        /// <summary>
+        /// Events automatically will be called without PollEvents method from another thread
+        /// </summary>
+        public bool UnsyncedEvents = false;
+
+        internal NatPunchModule(NetManager socket)
+        {
+            _socket = socket;
+            _netPacketProcessor.SubscribeReusable<NatIntroduceResponsePacket>(OnNatIntroductionResponse);
+            _netPacketProcessor.SubscribeReusable<NatIntroduceRequestPacket, IPEndPoint>(OnNatIntroductionRequest);
+            _netPacketProcessor.SubscribeReusable<NatPunchPacket, IPEndPoint>(OnNatPunch);
+        }
+
+        internal void ProcessMessage(IPEndPoint senderEndPoint, NetPacket packet)
+        {
+            lock (_cacheReader)
+            {
+                _cacheReader.SetSource(packet.RawData, NetConstants.HeaderSize, packet.Size);
+                _netPacketProcessor.ReadAllPackets(_cacheReader, senderEndPoint);
+            }
+        }
+
+        public void Init(INatPunchListener listener)
+        {
+            _natPunchListener = listener;
+        }
+
+        private void Send<
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(Trimming.SerializerMemberTypes)]
+#endif
+            T>(T packet, IPEndPoint target) where T : class, new()
+        {
+            _cacheWriter.Reset();
+            _cacheWriter.Put((byte)PacketProperty.NatMessage);
+            _netPacketProcessor.Write(_cacheWriter, packet);
+            _socket.SendRaw(_cacheWriter.Data, 0, _cacheWriter.Length, target);
+        }
+
+        public void NatIntroduce(IPEndPoint hostInternal, IPEndPoint hostExternal, IPEndPoint clientInternal, IPEndPoint clientExternal, string additionalInfo)
+        {
+            NatIntroduceResponsePacket req = new()
+            {
+                Token = additionalInfo
+            };
+
+            // First packet (server) send to client
+            req.Internal = hostInternal;
+            req.External = hostExternal;
+            Send(req, clientExternal);
+
+            // Second packet (client) send to server
+            req.Internal = clientInternal;
+            req.External = clientExternal;
+            Send(req, hostExternal);
+        }
+
+        public void PollEvents()
+        {
+            if (UnsyncedEvents)
+                return;
+
+            if (_natPunchListener == null || (_successEvents.IsEmpty && _requestEvents.IsEmpty))
+                return;
+
+            while (_successEvents.TryDequeue(out SuccessEventData evt))
+            {
+                _natPunchListener.OnNatIntroductionSuccess(evt.TargetEndPoint, evt.Type, evt.Token);
+            }
+
+            while (_requestEvents.TryDequeue(out RequestEventData evt))
+            {
+                _natPunchListener.OnNatIntroductionRequest(evt.LocalEndPoint, evt.RemoteEndPoint, evt.Token);
+            }
+        }
+
+        public void SendNatIntroduceRequest(string host, int port, string additionalInfo)
+        {
+            SendNatIntroduceRequest(NetUtils.MakeEndPoint(host, port), additionalInfo);
+        }
+
+        public void SendNatIntroduceRequest(IPEndPoint masterServerEndPoint, string additionalInfo)
+        {
+            // prepare outgoing data
+            string networkIp = NetUtils.GetLocalIp(LocalAddrType.IPv4);
+            if (string.IsNullOrEmpty(networkIp) || masterServerEndPoint.AddressFamily == AddressFamily.InterNetworkV6)
+            {
+                networkIp = NetUtils.GetLocalIp(LocalAddrType.IPv6);
+            }
+
+            Send(new NatIntroduceRequestPacket
+            {
+                Internal = NetUtils.MakeEndPoint(networkIp, _socket.LocalPort),
+                Token = additionalInfo
+            }, masterServerEndPoint);
+        }
+
+        // We got request and must introduce
+        private void OnNatIntroductionRequest(NatIntroduceRequestPacket req, IPEndPoint senderEndPoint)
+        {
+            if (UnsyncedEvents)
+            {
+                _natPunchListener.OnNatIntroductionRequest(req.Internal, senderEndPoint, req.Token);
+            }
+            else
+            {
+                _requestEvents.Enqueue(new()
+                {
+                    LocalEndPoint = req.Internal,
+                    RemoteEndPoint = senderEndPoint,
+                    Token = req.Token
+                });
+            }
+        }
+
+        // We got introduce and must punch
+        private void OnNatIntroductionResponse(NatIntroduceResponsePacket req)
+        {
+            NetDebug.Write(NetLogLevel.Trace, "[NAT] introduction received");
+
+            // send internal punch
+            NatPunchPacket punchPacket = new() { Token = req.Token };
+            Send(punchPacket, req.Internal);
+            NetDebug.Write(NetLogLevel.Trace, $"[NAT] internal punch sent to {req.Internal}");
+
+            // hack for some routers
+            _socket.Ttl = 2;
+            _socket.SendRaw(new[] { (byte)PacketProperty.Empty }, 0, 1, req.External);
+
+            // send external punch
+            _socket.Ttl = NetConstants.SocketTTL;
+            punchPacket.IsExternal = true;
+            Send(punchPacket, req.External);
+            NetDebug.Write(NetLogLevel.Trace, $"[NAT] external punch sent to {req.External}");
+        }
+
+        // We got punch and can connect
+        private void OnNatPunch(NatPunchPacket req, IPEndPoint senderEndPoint)
+        {
+            // Read info
+            NetDebug.Write(NetLogLevel.Trace, $"[NAT] punch received from {senderEndPoint} - additional info: {req.Token}");
+
+            // Release punch success to client; enabling him to Connect() to Sender if token is ok
+            if (UnsyncedEvents)
+            {
+                _natPunchListener.OnNatIntroductionSuccess(senderEndPoint, req.IsExternal ? NatAddressType.External : NatAddressType.Internal, req.Token);
+            }
+            else
+            {
+                _successEvents.Enqueue(new()
+                {
+                    TargetEndPoint = senderEndPoint,
+                    Type = req.IsExternal ? NatAddressType.External : NatAddressType.Internal,
+                    Token = req.Token
+                });
+            }
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NatPunchModule.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: e608aa88ab820244a90b83eca0f716c5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NatPunchModule.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NativeSocket.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace LiteNetLib
+{
+    internal static class NativeSocket
+    {
+        private static unsafe class WinSock
+        {
+            private const string LibName = "ws2_32.dll";
+
+            [DllImport(LibName, SetLastError = true)]
+            public static extern int recvfrom(IntPtr socketHandle, [In] [Out] byte[] pinnedBuffer, [In] int len, [In] SocketFlags socketFlags, [Out] byte[] socketAddress, [In] [Out] ref int socketAddressSize);
+
+            [DllImport(LibName, SetLastError = true)]
+            internal static extern int sendto(IntPtr socketHandle, byte* pinnedBuffer, [In] int len, [In] SocketFlags socketFlags, [In] byte[] socketAddress, [In] int socketAddressSize);
+        }
+
+        private static unsafe class UnixSock
+        {
+            private const string LibName = "libc";
+
+            [DllImport(LibName, SetLastError = true)]
+            public static extern int recvfrom(IntPtr socketHandle, [In] [Out] byte[] pinnedBuffer, [In] int len, [In] SocketFlags socketFlags, [Out] byte[] socketAddress, [In] [Out] ref int socketAddressSize);
+
+            [DllImport(LibName, SetLastError = true)]
+            internal static extern int sendto(IntPtr socketHandle, byte* pinnedBuffer, [In] int len, [In] SocketFlags socketFlags, [In] byte[] socketAddress, [In] int socketAddressSize);
+        }
+
+        public static readonly bool IsSupported = false;
+        public static readonly bool UnixMode = false;
+        public const int IPv4AddrSize = 16;
+        public const int IPv6AddrSize = 28;
+        public const int AF_INET = 2;
+        public const int AF_INET6 = 10;
+        private static readonly Dictionary<int, SocketError> NativeErrorToSocketError = new()
+        {
+            { 13, SocketError.AccessDenied }, // EACCES
+            { 98, SocketError.AddressAlreadyInUse }, // EADDRINUSE
+            { 99, SocketError.AddressNotAvailable }, // EADDRNOTAVAIL
+            { 97, SocketError.AddressFamilyNotSupported }, // EAFNOSUPPORT
+            { 11, SocketError.WouldBlock }, // EAGAIN
+            { 114, SocketError.AlreadyInProgress }, // EALREADY
+            { 9, SocketError.OperationAborted }, // EBADF
+            { 125, SocketError.OperationAborted }, // ECANCELED
+            { 103, SocketError.ConnectionAborted }, // ECONNABORTED
+            { 111, SocketError.ConnectionRefused }, // ECONNREFUSED
+            { 104, SocketError.ConnectionReset }, // ECONNRESET
+            { 89, SocketError.DestinationAddressRequired }, // EDESTADDRREQ
+            { 14, SocketError.Fault }, // EFAULT
+            { 112, SocketError.HostDown }, // EHOSTDOWN
+            { 6, SocketError.HostNotFound }, // ENXIO
+            { 113, SocketError.HostUnreachable }, // EHOSTUNREACH
+            { 115, SocketError.InProgress }, // EINPROGRESS
+            { 4, SocketError.Interrupted }, // EINTR
+            { 22, SocketError.InvalidArgument }, // EINVAL
+            { 106, SocketError.IsConnected }, // EISCONN
+            { 24, SocketError.TooManyOpenSockets }, // EMFILE
+            { 90, SocketError.MessageSize }, // EMSGSIZE
+            { 100, SocketError.NetworkDown }, // ENETDOWN
+            { 102, SocketError.NetworkReset }, // ENETRESET
+            { 101, SocketError.NetworkUnreachable }, // ENETUNREACH
+            { 23, SocketError.TooManyOpenSockets }, // ENFILE
+            { 105, SocketError.NoBufferSpaceAvailable }, // ENOBUFS
+            { 61, SocketError.NoData }, // ENODATA
+            { 2, SocketError.AddressNotAvailable }, // ENOENT
+            { 92, SocketError.ProtocolOption }, // ENOPROTOOPT
+            { 107, SocketError.NotConnected }, // ENOTCONN
+            { 88, SocketError.NotSocket }, // ENOTSOCK
+            { 3440, SocketError.OperationNotSupported }, // ENOTSUP
+            { 1, SocketError.AccessDenied }, // EPERM
+            { 32, SocketError.Shutdown }, // EPIPE
+            { 96, SocketError.ProtocolFamilyNotSupported }, // EPFNOSUPPORT
+            { 93, SocketError.ProtocolNotSupported }, // EPROTONOSUPPORT
+            { 91, SocketError.ProtocolType }, // EPROTOTYPE
+            { 94, SocketError.SocketNotSupported }, // ESOCKTNOSUPPORT
+            { 108, SocketError.Disconnecting }, // ESHUTDOWN
+            { 110, SocketError.TimedOut }, // ETIMEDOUT
+            { 0, SocketError.Success }
+        };
+
+        static NativeSocket()
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            {
+                IsSupported = true;
+                UnixMode = true;
+            }
+            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                IsSupported = true;
+            }
+        }
+
+        public static int RecvFrom(IntPtr socketHandle, byte[] pinnedBuffer, int len, byte[] socketAddress, ref int socketAddressSize)
+        {
+            return UnixMode ? UnixSock.recvfrom(socketHandle, pinnedBuffer, len, 0, socketAddress, ref socketAddressSize) : WinSock.recvfrom(socketHandle, pinnedBuffer, len, 0, socketAddress, ref socketAddressSize);
+        }
+
+        public static unsafe int SendTo(IntPtr socketHandle, byte* pinnedBuffer, int len, byte[] socketAddress, int socketAddressSize)
+        {
+            return UnixMode ? UnixSock.sendto(socketHandle, pinnedBuffer, len, 0, socketAddress, socketAddressSize) : WinSock.sendto(socketHandle, pinnedBuffer, len, 0, socketAddress, socketAddressSize);
+        }
+
+        public static SocketError GetSocketError()
+        {
+            int error = Marshal.GetLastWin32Error();
+            if (UnixMode)
+                return NativeErrorToSocketError.TryGetValue(error, out SocketError err) ? err : SocketError.SocketError;
+            return (SocketError)error;
+        }
+
+        public static SocketException GetSocketException()
+        {
+            int error = Marshal.GetLastWin32Error();
+            if (UnixMode)
+                return NativeErrorToSocketError.TryGetValue(error, out SocketError err) ? new((int)err) : new SocketException((int)SocketError.SocketError);
+            return new(error);
+        }
+
+        public static short GetNativeAddressFamily(IPEndPoint remoteEndPoint)
+        {
+            return UnixMode ? (short)(remoteEndPoint.AddressFamily == AddressFamily.InterNetwork ? AF_INET : AF_INET6) : (short)remoteEndPoint.AddressFamily;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NativeSocket.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 12cfcf4490f2b8f4db979ee833ecf5af
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NativeSocket.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetConstants.cs

@@ -0,0 +1,69 @@
+namespace LiteNetLib
+{
+    /// <summary>
+    /// Sending method type
+    /// </summary>
+    public enum DeliveryMethod : byte
+    {
+        /// <summary>
+        /// Unreliable. Packets can be dropped, can be duplicated, can arrive without order.
+        /// </summary>
+        Unreliable = 4,
+        /// <summary>
+        /// Reliable. Packets won't be dropped, won't be duplicated, can arrive without order.
+        /// </summary>
+        ReliableUnordered = 0,
+        /// <summary>
+        /// Unreliable. Packets can be dropped, won't be duplicated, will arrive in order.
+        /// </summary>
+        Sequenced = 1,
+        /// <summary>
+        /// Reliable and ordered. Packets won't be dropped, won't be duplicated, will arrive in order.
+        /// </summary>
+        ReliableOrdered = 2,
+        /// <summary>
+        /// Reliable only last packet. Packets can be dropped (except the last one), won't be duplicated, will arrive in order.
+        /// Cannot be fragmented
+        /// </summary>
+        ReliableSequenced = 3
+    }
+
+    /// <summary>
+    /// Network constants. Can be tuned from sources for your purposes.
+    /// </summary>
+    public static class NetConstants
+    {
+        // can be tuned
+        public const int DefaultWindowSize = 64;
+        public const int SocketBufferSize = 1024 * 1024; // 1mb
+        public const int SocketTTL = 255;
+        public const int HeaderSize = 1;
+        public const int ChanneledHeaderSize = 4;
+        public const int FragmentHeaderSize = 6;
+        public const int FragmentedHeaderTotalSize = ChanneledHeaderSize + FragmentHeaderSize;
+        public const ushort MaxSequence = 32768;
+        public const ushort HalfMaxSequence = MaxSequence / 2;
+
+        // protocol
+        internal const int ProtocolId = 13;
+        internal const int MaxUdpHeaderSize = 68;
+        internal const int ChannelTypeCount = 4;
+        internal static readonly int[] PossibleMtu =
+        {
+            576 - MaxUdpHeaderSize, // minimal (RFC 1191)
+            1024, // most games standard
+            1232 - MaxUdpHeaderSize,
+            1460 - MaxUdpHeaderSize, // google cloud
+            1472 - MaxUdpHeaderSize, // VPN
+            1492 - MaxUdpHeaderSize, // Ethernet with LLC and SNAP, PPPoE (RFC 1042)
+            1500 - MaxUdpHeaderSize // Ethernet II (RFC 1191)
+        };
+
+        // Max possible single packet size
+        public static readonly int MaxPacketSize = PossibleMtu[PossibleMtu.Length - 1];
+        public static readonly int MaxUnreliableDataSize = MaxPacketSize - HeaderSize;
+
+        // peer specific
+        public const byte MaxConnectionNumber = 4;
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetConstants.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: b42ee5a523e67ff4c9149f91f7fe4245
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetConstants.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetDebug.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Diagnostics;
+
+namespace LiteNetLib
+{
+    public class InvalidPacketException : ArgumentException
+    {
+        public InvalidPacketException(string message) : base(message) { }
+    }
+
+    public class TooBigPacketException : InvalidPacketException
+    {
+        public TooBigPacketException(string message) : base(message) { }
+    }
+
+    public enum NetLogLevel
+    {
+        Warning,
+        Error,
+        Trace,
+        Info
+    }
+
+    /// <summary>
+    /// Interface to implement for your own logger
+    /// </summary>
+    public interface INetLogger
+    {
+        void WriteNet(NetLogLevel level, string str, params object[] args);
+    }
+
+    /// <summary>
+    /// Static class for defining your own LiteNetLib logger instead of Console.WriteLine
+    /// or Debug.Log if compiled with UNITY flag
+    /// </summary>
+    public static class NetDebug
+    {
+        public static INetLogger Logger = null;
+        private static readonly object DebugLogLock = new();
+
+        private static void WriteLogic(NetLogLevel logLevel, string str, params object[] args)
+        {
+            lock (DebugLogLock)
+            {
+                if (Logger == null)
+                {
+#if UNITY_5_3_OR_NEWER
+                    UnityEngine.Debug.Log(string.Format(str, args));
+#else
+                    Console.WriteLine(str, args);
+#endif
+                }
+                else
+                {
+                    Logger.WriteNet(logLevel, str, args);
+                }
+            }
+        }
+
+        [Conditional("DEBUG_MESSAGES")]
+        internal static void Write(string str)
+        {
+            WriteLogic(NetLogLevel.Trace, str);
+        }
+
+        [Conditional("DEBUG_MESSAGES")]
+        internal static void Write(NetLogLevel level, string str)
+        {
+            WriteLogic(level, str);
+        }
+
+        [Conditional("DEBUG_MESSAGES")]
+        [Conditional("DEBUG")]
+        internal static void WriteForce(string str)
+        {
+            WriteLogic(NetLogLevel.Trace, str);
+        }
+
+        [Conditional("DEBUG_MESSAGES")]
+        [Conditional("DEBUG")]
+        internal static void WriteForce(NetLogLevel level, string str)
+        {
+            WriteLogic(level, str);
+        }
+
+        internal static void WriteError(string str)
+        {
+            WriteLogic(NetLogLevel.Error, str);
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetDebug.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 9f50ae51c124bf1439e339eee1fcd6f5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetDebug.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetManager.HashSet.cs

@@ -0,0 +1,309 @@
+using System;
+using System.Net;
+using System.Threading;
+
+namespace LiteNetLib
+{
+    // minimal hashset class from dotnet with some optimizations
+    public partial class NetManager
+    {
+        private const int MaxPrimeArrayLength = 0x7FFFFFC3;
+        private const int HashPrime = 101;
+        private const int Lower31BitMask = 0x7FFFFFFF;
+        private static readonly int[] Primes =
+        {
+            3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
+            1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,
+            17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 156437,
+            187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403, 968897, 1162687, 1395263,
+            1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 4999559, 5999471, 7199369
+        };
+
+        private static int HashSetGetPrime(int min)
+        {
+            foreach (int prime in Primes)
+            {
+                if (prime >= min)
+                    return prime;
+            }
+
+            // Outside of our predefined table. Compute the hard way.
+            for (int i = min | 1; i < int.MaxValue; i += 2)
+            {
+                if (IsPrime(i) && (i - 1) % HashPrime != 0)
+                    return i;
+            }
+            return min;
+
+            bool IsPrime(int candidate)
+            {
+                if ((candidate & 1) != 0)
+                {
+                    int limit = (int)Math.Sqrt(candidate);
+                    for (int divisor = 3; divisor <= limit; divisor += 2)
+                    {
+                        if (candidate % divisor == 0)
+                            return false;
+                    }
+                    return true;
+                }
+                return candidate == 2;
+            }
+        }
+
+        private struct Slot
+        {
+            internal int HashCode;
+            internal int Next;
+            internal NetPeer Value;
+        }
+
+        private int[] _buckets;
+        private Slot[] _slots;
+        private int _count;
+        private int _lastIndex;
+        private int _freeList = -1;
+        private NetPeer[] _peersArray = new NetPeer[32];
+        private readonly ReaderWriterLockSlim _peersLock = new(LockRecursionPolicy.NoRecursion);
+        private volatile NetPeer _headPeer;
+
+        private void ClearPeerSet()
+        {
+            _peersLock.EnterWriteLock();
+            _headPeer = null;
+            if (_lastIndex > 0)
+            {
+                Array.Clear(_slots, 0, _lastIndex);
+                Array.Clear(_buckets, 0, _buckets.Length);
+                _lastIndex = 0;
+                _count = 0;
+                _freeList = -1;
+            }
+            _peersArray = new NetPeer[32];
+            _peersLock.ExitWriteLock();
+        }
+
+        private bool ContainsPeer(NetPeer item)
+        {
+            if (_buckets != null)
+            {
+                int hashCode = item.GetHashCode() & Lower31BitMask;
+                for (int i = _buckets[hashCode % _buckets.Length] - 1; i >= 0; i = _slots[i].Next)
+                {
+                    if (_slots[i].HashCode == hashCode && _slots[i].Value.Equals(item))
+                        return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Gets peer by peer id
+        /// </summary>
+        /// <param name = "id">id of peer</param>
+        /// <returns>Peer if peer with id exist, otherwise null</returns>
+        public NetPeer GetPeerById(int id)
+        {
+            return id >= 0 && id < _peersArray.Length ? _peersArray[id] : null;
+        }
+
+        /// <summary>
+        /// Gets peer by peer id
+        /// </summary>
+        /// <param name = "id">id of peer</param>
+        /// <param name = "peer">resulting peer</param>
+        /// <returns>True if peer with id exist, otherwise false</returns>
+        public bool TryGetPeerById(int id, out NetPeer peer)
+        {
+            peer = GetPeerById(id);
+            return peer != null;
+        }
+
+        private void AddPeer(NetPeer peer)
+        {
+            _peersLock.EnterWriteLock();
+            if (_headPeer != null)
+            {
+                peer.NextPeer = _headPeer;
+                _headPeer.PrevPeer = peer;
+            }
+            _headPeer = peer;
+            AddPeerToSet(peer);
+            if (peer.Id >= _peersArray.Length)
+            {
+                int newSize = _peersArray.Length * 2;
+                while (peer.Id >= newSize)
+                    newSize *= 2;
+                Array.Resize(ref _peersArray, newSize);
+            }
+            _peersArray[peer.Id] = peer;
+            _peersLock.ExitWriteLock();
+        }
+
+        private void RemovePeer(NetPeer peer)
+        {
+            _peersLock.EnterWriteLock();
+            RemovePeerInternal(peer);
+            _peersLock.ExitWriteLock();
+        }
+
+        private void RemovePeerInternal(NetPeer peer)
+        {
+            if (!RemovePeerFromSet(peer))
+                return;
+            if (peer == _headPeer)
+                _headPeer = peer.NextPeer;
+
+            if (peer.PrevPeer != null)
+                peer.PrevPeer.NextPeer = peer.NextPeer;
+            if (peer.NextPeer != null)
+                peer.NextPeer.PrevPeer = peer.PrevPeer;
+            peer.PrevPeer = null;
+
+            _peersArray[peer.Id] = null;
+            _peerIds.Enqueue(peer.Id);
+        }
+
+        private bool RemovePeerFromSet(NetPeer peer)
+        {
+            if (_buckets == null)
+                return false;
+            if (peer == null)
+                return false;
+            int hashCode = peer.GetHashCode() & Lower31BitMask;
+            int bucket = hashCode % _buckets.Length;
+            int last = -1;
+            for (int i = _buckets[bucket] - 1; i >= 0; last = i, i = _slots[i].Next)
+            {
+                if (_slots[i].HashCode == hashCode && _slots[i].Value.Equals(peer))
+                {
+                    if (last < 0)
+                        _buckets[bucket] = _slots[i].Next + 1;
+                    else
+                        _slots[last].Next = _slots[i].Next;
+                    _slots[i].HashCode = -1;
+                    _slots[i].Value = null;
+                    _slots[i].Next = _freeList;
+
+                    _count--;
+                    if (_count == 0)
+                    {
+                        _lastIndex = 0;
+                        _freeList = -1;
+                    }
+                    else
+                    {
+                        _freeList = i;
+                    }
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private bool TryGetPeer(IPEndPoint endPoint, out NetPeer actualValue)
+        {
+            if (_buckets != null)
+            {
+#if NET8_0_OR_GREATER
+                // can be NetPeer or IPEndPoint
+                int hashCode = (UseNativeSockets ? endPoint.GetHashCode() : endPoint.Serialize().GetHashCode()) & Lower31BitMask;
+#else
+                int hashCode = endPoint.GetHashCode() & Lower31BitMask;
+#endif
+                _peersLock.EnterReadLock();
+                for (int i = _buckets[hashCode % _buckets.Length] - 1; i >= 0; i = _slots[i].Next)
+                {
+                    if (_slots[i].HashCode == hashCode && _slots[i].Value.Equals(endPoint))
+                    {
+                        actualValue = _slots[i].Value;
+                        _peersLock.ExitReadLock();
+                        return true;
+                    }
+                }
+                _peersLock.ExitReadLock();
+            }
+            actualValue = null;
+            return false;
+        }
+
+        // only used for NET8
+        private bool TryGetPeer(SocketAddress saddr, out NetPeer actualValue)
+        {
+            if (_buckets != null)
+            {
+                int hashCode = saddr.GetHashCode() & Lower31BitMask;
+                _peersLock.EnterReadLock();
+                for (int i = _buckets[hashCode % _buckets.Length] - 1; i >= 0; i = _slots[i].Next)
+                {
+                    if (_slots[i].HashCode == hashCode && _slots[i].Value.Serialize().Equals(saddr))
+                    {
+                        actualValue = _slots[i].Value;
+                        _peersLock.ExitReadLock();
+                        return true;
+                    }
+                }
+                _peersLock.ExitReadLock();
+            }
+            actualValue = null;
+            return false;
+        }
+
+        private bool AddPeerToSet(NetPeer value)
+        {
+            if (_buckets == null)
+            {
+                int size = HashSetGetPrime(0);
+                _buckets = new int[size];
+                _slots = new Slot[size];
+            }
+
+            int hashCode = value.GetHashCode() & Lower31BitMask;
+            int bucket = hashCode % _buckets.Length;
+            for (int i = _buckets[hashCode % _buckets.Length] - 1; i >= 0; i = _slots[i].Next)
+            {
+                if (_slots[i].HashCode == hashCode && _slots[i].Value.Equals(value))
+                    return false;
+            }
+
+            int index;
+            if (_freeList >= 0)
+            {
+                index = _freeList;
+                _freeList = _slots[index].Next;
+            }
+            else
+            {
+                if (_lastIndex == _slots.Length)
+                {
+                    // increase capacity
+                    int newSize = 2 * _count;
+                    newSize = (uint)newSize > MaxPrimeArrayLength && MaxPrimeArrayLength > _count ? MaxPrimeArrayLength : HashSetGetPrime(newSize);
+
+                    // Able to increase capacity; copy elements to larger array and rehash
+                    Slot[] newSlots = new Slot[newSize];
+                    Array.Copy(_slots, 0, newSlots, 0, _lastIndex);
+                    _buckets = new int[newSize];
+                    for (int i = 0; i < _lastIndex; i++)
+                    {
+                        int b = newSlots[i].HashCode % newSize;
+                        newSlots[i].Next = _buckets[b] - 1;
+                        _buckets[b] = i + 1;
+                    }
+                    _slots = newSlots;
+                    // this will change during resize
+                    bucket = hashCode % _buckets.Length;
+                }
+                index = _lastIndex;
+                _lastIndex++;
+            }
+            _slots[index].HashCode = hashCode;
+            _slots[index].Value = value;
+            _slots[index].Next = _buckets[bucket] - 1;
+            _buckets[bucket] = index + 1;
+            _count++;
+
+            return true;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetManager.HashSet.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: a3dad2c47fd51d14fbb281bf3cb231e4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetManager.HashSet.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetManager.PacketPool.cs

@@ -0,0 +1,79 @@
+using System;
+
+namespace LiteNetLib
+{
+    public partial class NetManager
+    {
+        private NetPacket _poolHead;
+        private readonly object _poolLock = new();
+        /// <summary>
+        /// Maximum packet pool size (increase if you have tons of packets sending)
+        /// </summary>
+        public int PacketPoolSize = 1000;
+        public int PoolCount { get; private set; }
+
+        private NetPacket PoolGetWithData(PacketProperty property, byte[] data, int start, int length)
+        {
+            int headerSize = NetPacket.GetHeaderSize(property);
+            NetPacket packet = PoolGetPacket(length + headerSize);
+            packet.Property = property;
+            Buffer.BlockCopy(data, start, packet.RawData, headerSize, length);
+            return packet;
+        }
+
+        // Get packet with size
+        private NetPacket PoolGetWithProperty(PacketProperty property, int size)
+        {
+            NetPacket packet = PoolGetPacket(size + NetPacket.GetHeaderSize(property));
+            packet.Property = property;
+            return packet;
+        }
+
+        private NetPacket PoolGetWithProperty(PacketProperty property)
+        {
+            NetPacket packet = PoolGetPacket(NetPacket.GetHeaderSize(property));
+            packet.Property = property;
+            return packet;
+        }
+
+        internal NetPacket PoolGetPacket(int size)
+        {
+            if (size > NetConstants.MaxPacketSize)
+                return new(size);
+
+            NetPacket packet;
+            lock (_poolLock)
+            {
+                packet = _poolHead;
+                if (packet == null)
+                    return new(size);
+
+                _poolHead = _poolHead.Next;
+                PoolCount--;
+            }
+
+            packet.Size = size;
+            if (packet.RawData.Length < size)
+                packet.RawData = new byte[size];
+            return packet;
+        }
+
+        internal void PoolRecycle(NetPacket packet)
+        {
+            if (packet.RawData.Length > NetConstants.MaxPacketSize || PoolCount >= PacketPoolSize)
+            {
+                // Don't pool big packets. Save memory
+                return;
+            }
+
+            // Clean fragmented flag
+            packet.RawData[0] = 0;
+            lock (_poolLock)
+            {
+                packet.Next = _poolHead;
+                _poolHead = packet;
+                PoolCount++;
+            }
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetManager.PacketPool.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: d384bada29340e542945f001cad348ac
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetManager.PacketPool.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetManager.Socket.cs

@@ -0,0 +1,682 @@
+#if UNITY_2018_3_OR_NEWER
+#define UNITY_SOCKET_FIX
+#endif
+using System.Runtime.InteropServices;
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using LiteNetLib.Utils;
+
+namespace LiteNetLib
+{
+    public partial class NetManager
+    {
+        private const int ReceivePollingTime = 500000; // 0.5 second
+        private Socket _udpSocketv4;
+        private Socket _udpSocketv6;
+        private Thread _receiveThread;
+        private IPEndPoint _bufferEndPointv4;
+        private IPEndPoint _bufferEndPointv6;
+        #if UNITY_SOCKET_FIX
+        private PausedSocketFix _pausedSocketFix;
+        private bool _useSocketFix;
+        #endif
+        #if NET8_0_OR_GREATER
+        private readonly SocketAddress _sockAddrCacheV4 = new SocketAddress(AddressFamily.InterNetwork);
+        private readonly SocketAddress _sockAddrCacheV6 = new SocketAddress(AddressFamily.InterNetworkV6);
+        #endif
+        private const int SioUdpConnreset = -1744830452; // SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12
+        private static readonly IPAddress MulticastAddressV6 = IPAddress.Parse("ff02::1");
+        public static readonly bool IPv6Support;
+
+        // special case in iOS (and possibly android that should be resolved in unity)
+        internal bool NotConnected;
+        public short Ttl
+        {
+            get
+            {
+                #if UNITY_SWITCH
+                return 0;
+                #else
+                return _udpSocketv4.Ttl;
+                #endif
+            }
+            internal set
+            {
+                #if !UNITY_SWITCH
+                _udpSocketv4.Ttl = value;
+                #endif
+            }
+        }
+
+        static NetManager()
+        {
+            #if DISABLE_IPV6
+            IPv6Support = false;
+            #elif !UNITY_2019_1_OR_NEWER && !UNITY_2018_4_OR_NEWER && (!UNITY_EDITOR && ENABLE_IL2CPP)
+            string version = UnityEngine.Application.unityVersion;
+            IPv6Support = Socket.OSSupportsIPv6 && int.Parse(version.Remove(version.IndexOf('f')).Split('.')[2]) >= 6;
+            #else
+            IPv6Support = Socket.OSSupportsIPv6;
+            #endif
+        }
+
+        private bool ProcessError(SocketException ex)
+        {
+            switch (ex.SocketErrorCode)
+            {
+                case SocketError.NotConnected:
+                    NotConnected = true;
+                    return true;
+                case SocketError.Interrupted:
+                case SocketError.NotSocket:
+                case SocketError.OperationAborted:
+                    return true;
+                case SocketError.ConnectionReset:
+                case SocketError.MessageSize:
+                case SocketError.TimedOut:
+                case SocketError.NetworkReset:
+                case SocketError.WouldBlock:
+                    // NetDebug.Write($"[R]Ignored error: {(int)ex.SocketErrorCode} - {ex}");
+                    break;
+                default:
+                    NetDebug.WriteError($"[R]Error code: {(int)ex.SocketErrorCode} - {ex}");
+                    CreateEvent(NetEvent.EType.Error, errorCode: ex.SocketErrorCode);
+                    break;
+            }
+            return false;
+        }
+
+        private void ManualReceive(Socket socket, EndPoint bufferEndPoint, int maxReceive)
+        {
+            // Reading data
+            try
+            {
+                int packetsReceived = 0;
+                while (socket.Available > 0)
+                {
+                    ReceiveFrom(socket, ref bufferEndPoint);
+                    packetsReceived++;
+                    if (packetsReceived == maxReceive)
+                        break;
+                }
+            }
+            catch (SocketException ex)
+            {
+                ProcessError(ex);
+            }
+            catch (ObjectDisposedException) { }
+            catch (Exception e)
+            {
+                // protects socket receive thread
+                NetDebug.WriteError("[NM] SocketReceiveThread error: " + e);
+            }
+        }
+
+        private void NativeReceiveLogic()
+        {
+            IntPtr socketHandle4 = _udpSocketv4.Handle;
+            IntPtr socketHandle6 = _udpSocketv6?.Handle ?? IntPtr.Zero;
+            byte[] addrBuffer4 = new byte[NativeSocket.IPv4AddrSize];
+            byte[] addrBuffer6 = new byte[NativeSocket.IPv6AddrSize];
+            IPEndPoint tempEndPoint = new(IPAddress.Any, 0);
+            List<Socket> selectReadList = new(2);
+            Socket socketv4 = _udpSocketv4;
+            Socket socketV6 = _udpSocketv6;
+            NetPacket packet = PoolGetPacket(NetConstants.MaxPacketSize);
+
+            while (IsRunning)
+            {
+                try
+                {
+                    if (socketV6 == null)
+                    {
+                        if (NativeReceiveFrom(socketHandle4, addrBuffer4) == false)
+                            return;
+                        continue;
+                    }
+                    bool messageReceived = false;
+                    if (socketv4.Available != 0 || selectReadList.Contains(socketv4))
+                    {
+                        if (NativeReceiveFrom(socketHandle4, addrBuffer4) == false)
+                            return;
+                        messageReceived = true;
+                    }
+                    if (socketV6.Available != 0 || selectReadList.Contains(socketV6))
+                    {
+                        if (NativeReceiveFrom(socketHandle6, addrBuffer6) == false)
+                            return;
+                        messageReceived = true;
+                    }
+
+                    selectReadList.Clear();
+
+                    if (messageReceived)
+                        continue;
+
+                    selectReadList.Add(socketv4);
+                    selectReadList.Add(socketV6);
+
+                    Socket.Select(selectReadList, null, null, ReceivePollingTime);
+                }
+                catch (SocketException ex)
+                {
+                    if (ProcessError(ex))
+                        return;
+                }
+                catch (ObjectDisposedException)
+                {
+                    // socket closed
+                    return;
+                }
+                catch (ThreadAbortException)
+                {
+                    // thread closed
+                    return;
+                }
+                catch (Exception e)
+                {
+                    // protects socket receive thread
+                    NetDebug.WriteError("[NM] SocketReceiveThread error: " + e);
+                }
+            }
+
+            bool NativeReceiveFrom(IntPtr s, byte[] address)
+            {
+                int addrSize = address.Length;
+                packet.Size = NativeSocket.RecvFrom(s, packet.RawData, NetConstants.MaxPacketSize, address, ref addrSize);
+                if (packet.Size == 0)
+                    return true; // socket closed or empty packet
+
+                if (packet.Size == -1)
+                {
+                    // Linux timeout EAGAIN
+                    return ProcessError(new((int)NativeSocket.GetSocketError())) == false;
+                }
+
+                // NetDebug.WriteForce($"[R]Received data from {endPoint}, result: {packet.Size}");
+                // refresh temp Addr/Port
+                short family = (short)((address[1] << 8) | address[0]);
+                tempEndPoint.Port = (ushort)((address[2] << 8) | address[3]);
+                if ((NativeSocket.UnixMode && family == NativeSocket.AF_INET6) || (!NativeSocket.UnixMode && (AddressFamily)family == AddressFamily.InterNetworkV6))
+                {
+                    uint scope = unchecked((uint)((address[27] << 24) + (address[26] << 16) + (address[25] << 8) + address[24]));
+                    #if NETCOREAPP || NETSTANDARD2_1 || NETSTANDARD2_1_OR_GREATER
+                    tempEndPoint.Address = new(new ReadOnlySpan<byte>(address, 8, 16), scope);
+                    #else
+                    byte[] addrBuffer = new byte[16];
+                    Buffer.BlockCopy(address, 8, addrBuffer, 0, 16);
+                    tempEndPoint.Address = new(addrBuffer, scope);
+                    #endif
+                }
+                else // IPv4
+                {
+                    long ipv4Addr = unchecked((uint)((address[4] & 0x000000FF) | ((address[5] << 8) & 0x0000FF00) | ((address[6] << 16) & 0x00FF0000) | (address[7] << 24)));
+                    tempEndPoint.Address = new(ipv4Addr);
+                }
+
+                if (TryGetPeer(tempEndPoint, out NetPeer peer))
+                {
+                    // use cached native ep
+                    OnMessageReceived(packet, peer);
+                }
+                else
+                {
+                    OnMessageReceived(packet, tempEndPoint);
+                    tempEndPoint = new(IPAddress.Any, 0);
+                }
+                packet = PoolGetPacket(NetConstants.MaxPacketSize);
+                return true;
+            }
+        }
+
+        private void ReceiveFrom(Socket s, ref EndPoint bufferEndPoint)
+        {
+            NetPacket packet = PoolGetPacket(NetConstants.MaxPacketSize);
+            #if NET8_0_OR_GREATER
+            var sockAddr = s.AddressFamily == AddressFamily.InterNetwork ? _sockAddrCacheV4 : _sockAddrCacheV6;
+            packet.Size = s.ReceiveFrom(packet, SocketFlags.None, sockAddr);
+            OnMessageReceived(packet, TryGetPeer(sockAddr, out var peer) ? peer : (IPEndPoint)bufferEndPoint.Create(sockAddr));
+            #else
+            packet.Size = s.ReceiveFrom(packet.RawData, 0, NetConstants.MaxPacketSize, SocketFlags.None, ref bufferEndPoint);
+            OnMessageReceived(packet, (IPEndPoint)bufferEndPoint);
+            #endif
+        }
+
+        private void ReceiveLogic()
+        {
+            EndPoint bufferEndPoint4 = new IPEndPoint(IPAddress.Any, 0);
+            EndPoint bufferEndPoint6 = new IPEndPoint(IPAddress.IPv6Any, 0);
+            List<Socket> selectReadList = new(2);
+            Socket socketv4 = _udpSocketv4;
+            Socket socketV6 = _udpSocketv6;
+
+            while (IsRunning)
+            {
+                // Reading data
+                try
+                {
+                    if (socketV6 == null)
+                    {
+                        if (socketv4.Available == 0 && !socketv4.Poll(ReceivePollingTime, SelectMode.SelectRead))
+                            continue;
+                        ReceiveFrom(socketv4, ref bufferEndPoint4);
+                    }
+                    else
+                    {
+                        bool messageReceived = false;
+                        if (socketv4.Available != 0 || selectReadList.Contains(socketv4))
+                        {
+                            ReceiveFrom(socketv4, ref bufferEndPoint4);
+                            messageReceived = true;
+                        }
+                        if (socketV6.Available != 0 || selectReadList.Contains(socketV6))
+                        {
+                            ReceiveFrom(socketV6, ref bufferEndPoint6);
+                            messageReceived = true;
+                        }
+
+                        selectReadList.Clear();
+
+                        if (messageReceived)
+                            continue;
+
+                        selectReadList.Add(socketv4);
+                        selectReadList.Add(socketV6);
+                        Socket.Select(selectReadList, null, null, ReceivePollingTime);
+                    }
+                    // NetDebug.Write(NetLogLevel.Trace, $"[R]Received data from {bufferEndPoint}, result: {packet.Size}");
+                }
+                catch (SocketException ex)
+                {
+                    if (ProcessError(ex))
+                        return;
+                }
+                catch (ObjectDisposedException)
+                {
+                    // socket closed
+                    return;
+                }
+                catch (ThreadAbortException)
+                {
+                    // thread closed
+                    return;
+                }
+                catch (Exception e)
+                {
+                    // protects socket receive thread
+                    NetDebug.WriteError("[NM] SocketReceiveThread error: " + e);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Start logic thread and listening on selected port
+        /// </summary>
+        /// <param name = "addressIPv4">bind to specific ipv4 address</param>
+        /// <param name = "addressIPv6">bind to specific ipv6 address</param>
+        /// <param name = "port">port to listen</param>
+        /// <param name = "manualMode">mode of library</param>
+        public bool Start(IPAddress addressIPv4, IPAddress addressIPv6, int port, bool manualMode)
+        {
+            if (IsRunning && NotConnected == false)
+                return false;
+
+            NotConnected = false;
+            _manualMode = manualMode;
+            UseNativeSockets = UseNativeSockets && NativeSocket.IsSupported;
+            _udpSocketv4 = new(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+            if (!BindSocket(_udpSocketv4, new(addressIPv4, port)))
+                return false;
+
+            LocalPort = ((IPEndPoint)_udpSocketv4.LocalEndPoint).Port;
+
+            #if UNITY_SOCKET_FIX
+            if (_useSocketFix && _pausedSocketFix == null)
+                _pausedSocketFix = new(this, addressIPv4, addressIPv6, port, manualMode);
+            #endif
+
+            IsRunning = true;
+            if (_manualMode)
+            {
+                _bufferEndPointv4 = new(IPAddress.Any, 0);
+            }
+
+            // Check IPv6 support
+            if (IPv6Support && IPv6Enabled)
+            {
+                _udpSocketv6 = new(AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp);
+                // Use one port for two sockets
+                if (BindSocket(_udpSocketv6, new(addressIPv6, LocalPort)))
+                {
+                    if (_manualMode)
+                        _bufferEndPointv6 = new(IPAddress.IPv6Any, 0);
+                }
+                else
+                {
+                    _udpSocketv6 = null;
+                }
+            }
+
+            if (!manualMode)
+            {
+                ThreadStart ts = ReceiveLogic;
+                if (UseNativeSockets)
+                    ts = NativeReceiveLogic;
+                _receiveThread = new(ts)
+                {
+                    Name = $"ReceiveThread({LocalPort})",
+                    IsBackground = true
+                };
+                _receiveThread.Start();
+                if (_logicThread == null)
+                {
+                    _logicThread = new(UpdateLogic) { Name = "LogicThread", IsBackground = true };
+                    _logicThread.Start();
+                }
+            }
+
+            return true;
+        }
+
+        private bool BindSocket(Socket socket, IPEndPoint ep)
+        {
+            // Setup socket
+            socket.ReceiveTimeout = 500;
+            socket.SendTimeout = 500;
+            socket.ReceiveBufferSize = NetConstants.SocketBufferSize;
+            socket.SendBufferSize = NetConstants.SocketBufferSize;
+            socket.Blocking = true;
+
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                try
+                {
+                    socket.IOControl(SioUdpConnreset, new byte[] { 0 }, null);
+                }
+                catch
+                {
+                    // ignored
+                }
+            }
+
+            try
+            {
+                socket.ExclusiveAddressUse = !ReuseAddress;
+                socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, ReuseAddress);
+                socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontRoute, DontRoute);
+            }
+            catch
+            {
+                // Unity with IL2CPP throws an exception here, it doesn't matter in most cases so just ignore it
+            }
+            if (ep.AddressFamily == AddressFamily.InterNetwork)
+            {
+                Ttl = NetConstants.SocketTTL;
+
+                try
+                {
+                    socket.EnableBroadcast = true;
+                }
+                catch (SocketException e)
+                {
+                    NetDebug.WriteError($"[B]Broadcast error: {e.SocketErrorCode}");
+                }
+
+                if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+                {
+                    try
+                    {
+                        socket.DontFragment = true;
+                    }
+                    catch (SocketException e)
+                    {
+                        NetDebug.WriteError($"[B]DontFragment error: {e.SocketErrorCode}");
+                    }
+                }
+            }
+            // Bind
+            try
+            {
+                socket.Bind(ep);
+                NetDebug.Write(NetLogLevel.Trace, $"[B]Successfully binded to port: {((IPEndPoint)socket.LocalEndPoint).Port}, AF: {socket.AddressFamily}");
+
+                // join multicast
+                if (ep.AddressFamily == AddressFamily.InterNetworkV6)
+                {
+                    try
+                    {
+                        #if !UNITY_SOCKET_FIX
+                        socket.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.AddMembership, new IPv6MulticastOption(MulticastAddressV6));
+                        #endif
+                    }
+                    catch (Exception)
+                    {
+                        // Unity3d throws exception - ignored
+                    }
+                }
+            }
+            catch (SocketException bindException)
+            {
+                switch (bindException.SocketErrorCode)
+                {
+                    // IPv6 bind fix
+                    case SocketError.AddressAlreadyInUse:
+                        if (socket.AddressFamily == AddressFamily.InterNetworkV6)
+                        {
+                            try
+                            {
+                                // Set IPv6Only
+                                socket.DualMode = false;
+                                socket.Bind(ep);
+                            }
+                            catch (SocketException ex)
+                            {
+                                // because its fixed in 2018_3
+                                NetDebug.WriteError($"[B]Bind exception: {ex}, errorCode: {ex.SocketErrorCode}");
+                                return false;
+                            }
+                            return true;
+                        }
+                        break;
+                    // hack for iOS (Unity3D)
+                    case SocketError.AddressFamilyNotSupported:
+                        return true;
+                }
+                NetDebug.WriteError($"[B]Bind exception: {bindException}, errorCode: {bindException.SocketErrorCode}");
+                return false;
+            }
+            return true;
+        }
+
+        internal int SendRawAndRecycle(NetPacket packet, IPEndPoint remoteEndPoint)
+        {
+            int result = SendRaw(packet.RawData, 0, packet.Size, remoteEndPoint);
+            PoolRecycle(packet);
+            return result;
+        }
+
+        internal int SendRaw(NetPacket packet, IPEndPoint remoteEndPoint)
+        {
+            return SendRaw(packet.RawData, 0, packet.Size, remoteEndPoint);
+        }
+
+        internal int SendRaw(byte[] message, int start, int length, IPEndPoint remoteEndPoint)
+        {
+            if (!IsRunning)
+                return 0;
+
+            NetPacket expandedPacket = null;
+            if (_extraPacketLayer != null)
+            {
+                expandedPacket = PoolGetPacket(length + _extraPacketLayer.ExtraPacketSizeForLayer);
+                Buffer.BlockCopy(message, start, expandedPacket.RawData, 0, length);
+                start = 0;
+                _extraPacketLayer.ProcessOutBoundPacket(ref remoteEndPoint, ref expandedPacket.RawData, ref start, ref length);
+                message = expandedPacket.RawData;
+            }
+
+            Socket socket = _udpSocketv4;
+            if (remoteEndPoint.AddressFamily == AddressFamily.InterNetworkV6 && IPv6Support)
+            {
+                socket = _udpSocketv6;
+                if (socket == null)
+                    return 0;
+            }
+
+            int result;
+            try
+            {
+                if (UseNativeSockets && remoteEndPoint is NetPeer peer)
+                {
+                    unsafe
+                    {
+                        fixed (byte* dataWithOffset = &message[start])
+                        {
+                            result = NativeSocket.SendTo(socket.Handle, dataWithOffset, length, peer.NativeAddress, peer.NativeAddress.Length);
+                        }
+                    }
+                    if (result == -1)
+                        throw NativeSocket.GetSocketException();
+                }
+                else
+                {
+                    #if NET8_0_OR_GREATER
+                    result = socket.SendTo(new ReadOnlySpan<byte>(message, start, length), SocketFlags.None, remoteEndPoint.Serialize());
+                    #else
+                    result = socket.SendTo(message, start, length, SocketFlags.None, remoteEndPoint);
+                    #endif
+                }
+                // NetDebug.WriteForce("[S]Send packet to {0}, result: {1}", remoteEndPoint, result);
+            }
+            catch (SocketException ex)
+            {
+                switch (ex.SocketErrorCode)
+                {
+                    case SocketError.NoBufferSpaceAvailable:
+                    case SocketError.Interrupted:
+                        return 0;
+                    case SocketError.MessageSize:
+                        NetDebug.Write(NetLogLevel.Trace, $"[SRD] 10040, datalen: {length}");
+                        return 0;
+
+                    case SocketError.HostUnreachable:
+                    case SocketError.NetworkUnreachable:
+                        if (DisconnectOnUnreachable && remoteEndPoint is NetPeer peer)
+                        {
+                            DisconnectPeerForce(peer, ex.SocketErrorCode == SocketError.HostUnreachable ? DisconnectReason.HostUnreachable : DisconnectReason.NetworkUnreachable, ex.SocketErrorCode, null);
+                        }
+
+                        CreateEvent(NetEvent.EType.Error, remoteEndPoint: remoteEndPoint, errorCode: ex.SocketErrorCode);
+                        return -1;
+
+                    case SocketError.Shutdown:
+                        CreateEvent(NetEvent.EType.Error, remoteEndPoint: remoteEndPoint, errorCode: ex.SocketErrorCode);
+                        return -1;
+
+                    default:
+                        NetDebug.WriteError($"[S] {ex}");
+                        return -1;
+                }
+            }
+            catch (Exception ex)
+            {
+                NetDebug.WriteError($"[S] {ex}");
+                return 0;
+            }
+            finally
+            {
+                if (expandedPacket != null)
+                    PoolRecycle(expandedPacket);
+            }
+
+            if (result <= 0)
+                return 0;
+
+            if (EnableStatistics)
+            {
+                Statistics.IncrementPacketsSent();
+                Statistics.AddBytesSent(length);
+            }
+
+            return result;
+        }
+
+        public bool SendBroadcast(NetDataWriter writer, int port)
+        {
+            return SendBroadcast(writer.Data, 0, writer.Length, port);
+        }
+
+        public bool SendBroadcast(byte[] data, int port)
+        {
+            return SendBroadcast(data, 0, data.Length, port);
+        }
+
+        public bool SendBroadcast(byte[] data, int start, int length, int port)
+        {
+            if (!IsRunning)
+                return false;
+
+            NetPacket packet;
+            if (_extraPacketLayer != null)
+            {
+                int headerSize = NetPacket.GetHeaderSize(PacketProperty.Broadcast);
+                packet = PoolGetPacket(headerSize + length + _extraPacketLayer.ExtraPacketSizeForLayer);
+                packet.Property = PacketProperty.Broadcast;
+                Buffer.BlockCopy(data, start, packet.RawData, headerSize, length);
+                int checksumComputeStart = 0;
+                int preCrcLength = length + headerSize;
+                IPEndPoint emptyEp = null;
+                _extraPacketLayer.ProcessOutBoundPacket(ref emptyEp, ref packet.RawData, ref checksumComputeStart, ref preCrcLength);
+            }
+            else
+            {
+                packet = PoolGetWithData(PacketProperty.Broadcast, data, start, length);
+            }
+
+            bool broadcastSuccess = false;
+            bool multicastSuccess = false;
+            try
+            {
+                broadcastSuccess = _udpSocketv4.SendTo(packet.RawData, 0, packet.Size, SocketFlags.None, new IPEndPoint(IPAddress.Broadcast, port)) > 0;
+
+                if (_udpSocketv6 != null)
+                {
+                    multicastSuccess = _udpSocketv6.SendTo(packet.RawData, 0, packet.Size, SocketFlags.None, new IPEndPoint(MulticastAddressV6, port)) > 0;
+                }
+            }
+            catch (SocketException ex)
+            {
+                if (ex.SocketErrorCode == SocketError.HostUnreachable)
+                    return broadcastSuccess;
+                NetDebug.WriteError($"[S][MCAST] {ex}");
+                return broadcastSuccess;
+            }
+            catch (Exception ex)
+            {
+                NetDebug.WriteError($"[S][MCAST] {ex}");
+                return broadcastSuccess;
+            }
+            finally
+            {
+                PoolRecycle(packet);
+            }
+
+            return broadcastSuccess || multicastSuccess;
+        }
+
+        private void CloseSocket()
+        {
+            IsRunning = false;
+            _udpSocketv4?.Close();
+            _udpSocketv6?.Close();
+            _udpSocketv4 = null;
+            _udpSocketv6 = null;
+            if (_receiveThread != null && _receiveThread != Thread.CurrentThread)
+                _receiveThread.Join();
+            _receiveThread = null;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetManager.Socket.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 9cc0423407df3e74a8e5a15dbbad2598
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetManager.Socket.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetManager.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 37d95580df7122c44b9333cd3ab77732
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetManager.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetPacket.cs

@@ -0,0 +1,158 @@
+using System;
+using LiteNetLib.Utils;
+
+namespace LiteNetLib
+{
+    internal enum PacketProperty : byte
+    {
+        Unreliable,
+        Channeled,
+        Ack,
+        Ping,
+        Pong,
+        ConnectRequest,
+        ConnectAccept,
+        Disconnect,
+        UnconnectedMessage,
+        MtuCheck,
+        MtuOk,
+        Broadcast,
+        Merged,
+        ShutdownOk,
+        PeerNotFound,
+        InvalidProtocol,
+        NatMessage,
+        Empty
+    }
+
+    internal sealed class NetPacket
+    {
+        private static readonly int PropertiesCount = Enum.GetValues(typeof(PacketProperty)).Length;
+        private static readonly int[] HeaderSizes;
+
+        static NetPacket()
+        {
+            HeaderSizes = NetUtils.AllocatePinnedUninitializedArray<int>(PropertiesCount);
+            for (int i = 0; i < HeaderSizes.Length; i++)
+            {
+                switch ((PacketProperty)i)
+                {
+                    case PacketProperty.Channeled:
+                    case PacketProperty.Ack:
+                        HeaderSizes[i] = NetConstants.ChanneledHeaderSize;
+                        break;
+                    case PacketProperty.Ping:
+                        HeaderSizes[i] = NetConstants.HeaderSize + 2;
+                        break;
+                    case PacketProperty.ConnectRequest:
+                        HeaderSizes[i] = NetConnectRequestPacket.HeaderSize;
+                        break;
+                    case PacketProperty.ConnectAccept:
+                        HeaderSizes[i] = NetConnectAcceptPacket.Size;
+                        break;
+                    case PacketProperty.Disconnect:
+                        HeaderSizes[i] = NetConstants.HeaderSize + 8;
+                        break;
+                    case PacketProperty.Pong:
+                        HeaderSizes[i] = NetConstants.HeaderSize + 10;
+                        break;
+                    default:
+                        HeaderSizes[i] = NetConstants.HeaderSize;
+                        break;
+                }
+            }
+        }
+
+        // Header
+        public PacketProperty Property
+        {
+            get => (PacketProperty)(RawData[0] & 0x1F);
+            set => RawData[0] = (byte)((RawData[0] & 0xE0) | (byte)value);
+        }
+        public byte ConnectionNumber
+        {
+            get => (byte)((RawData[0] & 0x60) >> 5);
+            set => RawData[0] = (byte)((RawData[0] & 0x9F) | (value << 5));
+        }
+        public ushort Sequence
+        {
+            get => BitConverter.ToUInt16(RawData, 1);
+            set => FastBitConverter.GetBytes(RawData, 1, value);
+        }
+        public bool IsFragmented => (RawData[0] & 0x80) != 0;
+
+        public void MarkFragmented()
+        {
+            RawData[0] |= 0x80; // set first bit
+        }
+
+        public byte ChannelId
+        {
+            get => RawData[3];
+            set => RawData[3] = value;
+        }
+        public ushort FragmentId
+        {
+            get => BitConverter.ToUInt16(RawData, 4);
+            set => FastBitConverter.GetBytes(RawData, 4, value);
+        }
+        public ushort FragmentPart
+        {
+            get => BitConverter.ToUInt16(RawData, 6);
+            set => FastBitConverter.GetBytes(RawData, 6, value);
+        }
+        public ushort FragmentsTotal
+        {
+            get => BitConverter.ToUInt16(RawData, 8);
+            set => FastBitConverter.GetBytes(RawData, 8, value);
+        }
+
+        // Data
+        public byte[] RawData;
+        public int Size;
+
+        // Delivery
+        public object UserData;
+
+        // Pool node
+        public NetPacket Next;
+
+        public NetPacket(int size)
+        {
+            RawData = new byte[size];
+            Size = size;
+        }
+
+        public NetPacket(PacketProperty property, int size)
+        {
+            size += GetHeaderSize(property);
+            RawData = new byte[size];
+            Property = property;
+            Size = size;
+        }
+
+        public static int GetHeaderSize(PacketProperty property)
+        {
+            return HeaderSizes[(int)property];
+        }
+
+        public int GetHeaderSize()
+        {
+            return HeaderSizes[RawData[0] & 0x1F];
+        }
+
+        public bool Verify()
+        {
+            byte property = (byte)(RawData[0] & 0x1F);
+            if (property >= PropertiesCount)
+                return false;
+            int headerSize = HeaderSizes[property];
+            bool fragmented = (RawData[0] & 0x80) != 0;
+            return Size >= headerSize && (!fragmented || Size >= headerSize + NetConstants.FragmentHeaderSize);
+        }
+
+#if LITENETLIB_SPANS || NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1 || NETCOREAPP3_1 || NET5_0 || NETSTANDARD2_1
+        public static implicit operator Span<byte>(NetPacket p) => new(p.RawData, 0, p.Size);
+#endif
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetPacket.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: e7ddd322169be074f870f73db1a55255
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetPacket.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetPeer.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 3e1a9277334c51545b92369c8e4c6d74
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetPeer.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetStatistics.cs

@@ -0,0 +1,71 @@
+using System.Threading;
+
+namespace LiteNetLib
+{
+    public sealed class NetStatistics
+    {
+        private long _packetsSent;
+        private long _packetsReceived;
+        private long _bytesSent;
+        private long _bytesReceived;
+        private long _packetLoss;
+        public long PacketsSent => Interlocked.Read(ref _packetsSent);
+        public long PacketsReceived => Interlocked.Read(ref _packetsReceived);
+        public long BytesSent => Interlocked.Read(ref _bytesSent);
+        public long BytesReceived => Interlocked.Read(ref _bytesReceived);
+        public long PacketLoss => Interlocked.Read(ref _packetLoss);
+        public long PacketLossPercent
+        {
+            get
+            {
+                long sent = PacketsSent, loss = PacketLoss;
+
+                return sent == 0 ? 0 : loss * 100 / sent;
+            }
+        }
+
+        public void Reset()
+        {
+            Interlocked.Exchange(ref _packetsSent, 0);
+            Interlocked.Exchange(ref _packetsReceived, 0);
+            Interlocked.Exchange(ref _bytesSent, 0);
+            Interlocked.Exchange(ref _bytesReceived, 0);
+            Interlocked.Exchange(ref _packetLoss, 0);
+        }
+
+        public void IncrementPacketsSent()
+        {
+            Interlocked.Increment(ref _packetsSent);
+        }
+
+        public void IncrementPacketsReceived()
+        {
+            Interlocked.Increment(ref _packetsReceived);
+        }
+
+        public void AddBytesSent(long bytesSent)
+        {
+            Interlocked.Add(ref _bytesSent, bytesSent);
+        }
+
+        public void AddBytesReceived(long bytesReceived)
+        {
+            Interlocked.Add(ref _bytesReceived, bytesReceived);
+        }
+
+        public void IncrementPacketLoss()
+        {
+            Interlocked.Increment(ref _packetLoss);
+        }
+
+        public void AddPacketLoss(long packetLoss)
+        {
+            Interlocked.Add(ref _packetLoss, packetLoss);
+        }
+
+        public override string ToString()
+        {
+            return string.Format("BytesReceived: {0}\nPacketsReceived: {1}\nBytesSent: {2}\nPacketsSent: {3}\nPacketLoss: {4}\nPacketLossPercent: {5}\n", BytesReceived, PacketsReceived, BytesSent, PacketsSent, PacketLoss, PacketLossPercent);
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetStatistics.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 15d4b62077bda58428b77d57fa4a9288
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetStatistics.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetUtils.cs

@@ -0,0 +1,221 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Net;
+using System.Net.Sockets;
+using System.Net.NetworkInformation;
+
+namespace LiteNetLib
+{
+    /// <summary>
+    /// Address type that you want to receive from NetUtils.GetLocalIp method
+    /// </summary>
+    [Flags]
+    public enum LocalAddrType
+    {
+        IPv4 = 1,
+        IPv6 = 2,
+        All = IPv4 | IPv6
+    }
+
+    /// <summary>
+    /// Some specific network utilities
+    /// </summary>
+    public static class NetUtils
+    {
+        private static readonly NetworkSorter NetworkSorter = new();
+
+        public static IPEndPoint MakeEndPoint(string hostStr, int port)
+        {
+            return new(ResolveAddress(hostStr), port);
+        }
+
+        public static IPAddress ResolveAddress(string hostStr)
+        {
+            if (hostStr == "localhost")
+                return IPAddress.Loopback;
+
+            if (!IPAddress.TryParse(hostStr, out IPAddress ipAddress))
+            {
+                if (NetManager.IPv6Support)
+                    ipAddress = ResolveAddress(hostStr, AddressFamily.InterNetworkV6);
+                if (ipAddress == null)
+                    ipAddress = ResolveAddress(hostStr, AddressFamily.InterNetwork);
+            }
+            if (ipAddress == null)
+                throw new ArgumentException("Invalid address: " + hostStr);
+
+            return ipAddress;
+        }
+
+        public static IPAddress ResolveAddress(string hostStr, AddressFamily addressFamily)
+        {
+            IPAddress[] addresses = Dns.GetHostEntry(hostStr).AddressList;
+            foreach (IPAddress ip in addresses)
+            {
+                if (ip.AddressFamily == addressFamily)
+                {
+                    return ip;
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Get all local ip addresses
+        /// </summary>
+        /// <param name = "addrType">type of address (IPv4, IPv6 or both)</param>
+        /// <returns>List with all local ip addresses</returns>
+        public static List<string> GetLocalIpList(LocalAddrType addrType)
+        {
+            List<string> targetList = new();
+            GetLocalIpList(targetList, addrType);
+            return targetList;
+        }
+
+        /// <summary>
+        /// Get all local ip addresses (non alloc version)
+        /// </summary>
+        /// <param name = "targetList">result list</param>
+        /// <param name = "addrType">type of address (IPv4, IPv6 or both)</param>
+        public static void GetLocalIpList(IList<string> targetList, LocalAddrType addrType)
+        {
+            bool ipv4 = (addrType & LocalAddrType.IPv4) == LocalAddrType.IPv4;
+            bool ipv6 = (addrType & LocalAddrType.IPv6) == LocalAddrType.IPv6;
+            try
+            {
+                // Sort networks interfaces so it prefer Wifi over Cellular networks
+                // Most cellulars networks seems to be incompatible with NAT Punch
+                NetworkInterface[] networks = NetworkInterface.GetAllNetworkInterfaces();
+                Array.Sort(networks, NetworkSorter);
+
+                foreach (NetworkInterface ni in networks)
+                {
+                    // Skip loopback and disabled network interfaces
+                    if (ni.NetworkInterfaceType == NetworkInterfaceType.Loopback || ni.OperationalStatus != OperationalStatus.Up)
+                        continue;
+
+                    IPInterfaceProperties ipProps = ni.GetIPProperties();
+
+                    // Skip address without gateway
+                    if (ipProps.GatewayAddresses.Count == 0)
+                        continue;
+
+                    foreach (UnicastIPAddressInformation ip in ipProps.UnicastAddresses)
+                    {
+                        IPAddress address = ip.Address;
+                        if ((ipv4 && address.AddressFamily == AddressFamily.InterNetwork) || (ipv6 && address.AddressFamily == AddressFamily.InterNetworkV6))
+                            targetList.Add(address.ToString());
+                    }
+                }
+
+                // Fallback mode (unity android)
+                if (targetList.Count == 0)
+                {
+                    IPAddress[] addresses = Dns.GetHostEntry(Dns.GetHostName()).AddressList;
+                    foreach (IPAddress ip in addresses)
+                    {
+                        if ((ipv4 && ip.AddressFamily == AddressFamily.InterNetwork) || (ipv6 && ip.AddressFamily == AddressFamily.InterNetworkV6))
+                            targetList.Add(ip.ToString());
+                    }
+                }
+            }
+            catch
+            {
+                // ignored
+            }
+
+            if (targetList.Count == 0)
+            {
+                if (ipv4)
+                    targetList.Add("127.0.0.1");
+                if (ipv6)
+                    targetList.Add("::1");
+            }
+        }
+
+        private static readonly List<string> IpList = new();
+
+        /// <summary>
+        /// Get first detected local ip address
+        /// </summary>
+        /// <param name = "addrType">type of address (IPv4, IPv6 or both)</param>
+        /// <returns>IP address if available. Else - string.Empty</returns>
+        public static string GetLocalIp(LocalAddrType addrType)
+        {
+            lock (IpList)
+            {
+                IpList.Clear();
+                GetLocalIpList(IpList, addrType);
+                return IpList.Count == 0 ? string.Empty : IpList[0];
+            }
+        }
+
+        // ===========================================
+        // Internal and debug log related stuff
+        // ===========================================
+        internal static void PrintInterfaceInfos()
+        {
+            NetDebug.WriteForce(NetLogLevel.Info, $"IPv6Support: {NetManager.IPv6Support}");
+            try
+            {
+                foreach (NetworkInterface ni in NetworkInterface.GetAllNetworkInterfaces())
+                {
+                    foreach (UnicastIPAddressInformation ip in ni.GetIPProperties().UnicastAddresses)
+                    {
+                        if (ip.Address.AddressFamily == AddressFamily.InterNetwork || ip.Address.AddressFamily == AddressFamily.InterNetworkV6)
+                        {
+                            NetDebug.WriteForce(NetLogLevel.Info, $"Interface: {ni.Name}, Type: {ni.NetworkInterfaceType}, Ip: {ip.Address}, OpStatus: {ni.OperationalStatus}");
+                        }
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                NetDebug.WriteForce(NetLogLevel.Info, $"Error while getting interface infos: {e}");
+            }
+        }
+
+        internal static int RelativeSequenceNumber(int number, int expected)
+        {
+            return (number - expected + NetConstants.MaxSequence + NetConstants.HalfMaxSequence) % NetConstants.MaxSequence - NetConstants.HalfMaxSequence;
+        }
+
+        internal static T[] AllocatePinnedUninitializedArray<T>(int count) where T : unmanaged
+        {
+#if NET5_0_OR_GREATER || NET5_0
+            return GC.AllocateUninitializedArray<T>(count, true);
+#else
+            return new T[count];
+#endif
+        }
+    }
+
+    // Pick the most obvious choice for the local IP
+    // Ethernet > Wifi > Others > Cellular
+    internal class NetworkSorter : IComparer<NetworkInterface>
+    {
+        [SuppressMessage("ReSharper", "PossibleNullReferenceException")]
+        public int Compare(NetworkInterface a, NetworkInterface b)
+        {
+            bool isCellularA = a.NetworkInterfaceType == NetworkInterfaceType.Wman || a.NetworkInterfaceType == NetworkInterfaceType.Wwanpp || a.NetworkInterfaceType == NetworkInterfaceType.Wwanpp2;
+
+            bool isCellularB = b.NetworkInterfaceType == NetworkInterfaceType.Wman || b.NetworkInterfaceType == NetworkInterfaceType.Wwanpp || b.NetworkInterfaceType == NetworkInterfaceType.Wwanpp2;
+
+            bool isWifiA = a.NetworkInterfaceType == NetworkInterfaceType.Wireless80211;
+            bool isWifiB = b.NetworkInterfaceType == NetworkInterfaceType.Wireless80211;
+
+            bool isEthernetA = a.NetworkInterfaceType == NetworkInterfaceType.Ethernet || a.NetworkInterfaceType == NetworkInterfaceType.Ethernet3Megabit || a.NetworkInterfaceType == NetworkInterfaceType.GigabitEthernet || a.NetworkInterfaceType == NetworkInterfaceType.FastEthernetFx || a.NetworkInterfaceType == NetworkInterfaceType.FastEthernetT;
+
+            bool isEthernetB = b.NetworkInterfaceType == NetworkInterfaceType.Ethernet || b.NetworkInterfaceType == NetworkInterfaceType.Ethernet3Megabit || b.NetworkInterfaceType == NetworkInterfaceType.GigabitEthernet || b.NetworkInterfaceType == NetworkInterfaceType.FastEthernetFx || b.NetworkInterfaceType == NetworkInterfaceType.FastEthernetT;
+
+            bool isOtherA = !isCellularA && !isWifiA && !isEthernetA;
+            bool isOtherB = !isCellularB && !isWifiB && !isEthernetB;
+
+            int priorityA = isEthernetA ? 3 : isWifiA ? 2 : isOtherA ? 1 : 0;
+            int priorityB = isEthernetB ? 3 : isWifiB ? 2 : isOtherB ? 1 : 0;
+
+            return priorityA > priorityB ? -1 : priorityA < priorityB ? 1 : 0;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetUtils.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: ab6438405a73f8c46ac22cd2f259a0e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/NetUtils.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/PausedSocketFix.cs

@@ -0,0 +1,57 @@
+#if UNITY_2018_3_OR_NEWER
+using System.Net;
+
+namespace LiteNetLib
+{
+    public class PausedSocketFix
+    {
+        private readonly NetManager _netManager;
+        private readonly IPAddress _ipv4;
+        private readonly IPAddress _ipv6;
+        private readonly int _port;
+        private readonly bool _manualMode;
+        private bool _initialized;
+
+        public PausedSocketFix(NetManager netManager, IPAddress ipv4, IPAddress ipv6, int port, bool manualMode)
+        {
+            _netManager = netManager;
+            _ipv4 = ipv4;
+            _ipv6 = ipv6;
+            _port = port;
+            _manualMode = manualMode;
+            UnityEngine.Application.focusChanged += Application_focusChanged;
+            _initialized = true;
+        }
+
+        public void Deinitialize()
+        {
+            if (_initialized)
+                UnityEngine.Application.focusChanged -= Application_focusChanged;
+            _initialized = false;
+        }
+
+        private void Application_focusChanged(bool focused)
+        {
+            // If coming back into focus see if a reconnect is needed.
+            if (focused)
+            {
+                // try reconnect
+                if (!_initialized)
+                    return;
+                // Was intentionally disconnected at some point.
+                if (!_netManager.IsRunning)
+                    return;
+                // Socket is in working state.
+                if (_netManager.NotConnected == false)
+                    return;
+
+                // Socket isn't running but should be. Try to start again.
+                if (!_netManager.Start(_ipv4, _ipv6, _port, _manualMode))
+                {
+                    NetDebug.WriteError($"[S] Cannot restore connection. Ipv4 {_ipv4}, Ipv6 {_ipv6}, Port {_port}, ManualMode {_manualMode}");
+                }
+            }
+        }
+    }
+}
+#endif

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/PausedSocketFix.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 85ea50adb87db074c9a1c587f35aebb2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/PausedSocketFix.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/PooledPacket.cs

@@ -0,0 +1,29 @@
+namespace LiteNetLib
+{
+    public readonly ref struct PooledPacket
+    {
+        internal readonly NetPacket _packet;
+        internal readonly byte _channelNumber;
+        /// <summary>
+        /// Maximum data size that you can put into such packet
+        /// </summary>
+        public readonly int MaxUserDataSize;
+        /// <summary>
+        /// Offset for user data when writing to Data array
+        /// </summary>
+        public readonly int UserDataOffset;
+        /// <summary>
+        /// Raw packet data. Do not modify header! Use UserDataOffset as start point for your data
+        /// </summary>
+        public byte[] Data => _packet.RawData;
+
+        internal PooledPacket(NetPacket packet, int maxDataSize, byte channelNumber)
+        {
+            _packet = packet;
+            UserDataOffset = _packet.GetHeaderSize();
+            _packet.Size = UserDataOffset;
+            MaxUserDataSize = maxDataSize - UserDataOffset;
+            _channelNumber = channelNumber;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/PooledPacket.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 76e47a542bb12e043b874c7180d98319
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/PooledPacket.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/ReliableChannel.cs

@@ -0,0 +1,334 @@
+using System;
+
+namespace LiteNetLib
+{
+    internal sealed class ReliableChannel : BaseChannel
+    {
+        private struct PendingPacket
+        {
+            private NetPacket _packet;
+            private long _timeStamp;
+            private bool _isSent;
+
+            public override string ToString()
+            {
+                return _packet == null ? "Empty" : _packet.Sequence.ToString();
+            }
+
+            public void Init(NetPacket packet)
+            {
+                _packet = packet;
+                _isSent = false;
+            }
+
+            // Returns true if there is a pending packet inside
+            public bool TrySend(long currentTime, NetPeer peer)
+            {
+                if (_packet == null)
+                    return false;
+
+                if (_isSent) // check send time
+                {
+                    double resendDelay = peer.ResendDelay * TimeSpan.TicksPerMillisecond;
+                    double packetHoldTime = currentTime - _timeStamp;
+                    if (packetHoldTime < resendDelay)
+                        return true;
+                    NetDebug.Write($"[RC]Resend: {packetHoldTime} > {resendDelay}");
+                }
+                _timeStamp = currentTime;
+                _isSent = true;
+                peer.SendUserData(_packet);
+                return true;
+            }
+
+            public bool Clear(NetPeer peer)
+            {
+                if (_packet != null)
+                {
+                    peer.RecycleAndDeliver(_packet);
+                    _packet = null;
+                    return true;
+                }
+                return false;
+            }
+        }
+
+        private readonly NetPacket _outgoingAcks; // for send acks
+        private readonly PendingPacket[] _pendingPackets; //for unacked packets and duplicates
+        private readonly NetPacket[] _receivedPackets; //for order
+        private readonly bool[] _earlyReceived; //for unordered
+        private int _localSeqence;
+        private int _remoteSequence;
+        private int _localWindowStart;
+        private int _remoteWindowStart;
+        private bool _mustSendAcks;
+        private readonly DeliveryMethod _deliveryMethod;
+        private readonly bool _ordered;
+        private readonly int _windowSize;
+        private const int BitsInByte = 8;
+        private readonly byte _id;
+
+        public ReliableChannel(NetPeer peer, bool ordered, byte id) : base(peer)
+        {
+            _id = id;
+            _windowSize = NetConstants.DefaultWindowSize;
+            _ordered = ordered;
+            _pendingPackets = new PendingPacket[_windowSize];
+            for (int i = 0; i < _pendingPackets.Length; i++)
+                _pendingPackets[i] = new();
+
+            if (_ordered)
+            {
+                _deliveryMethod = DeliveryMethod.ReliableOrdered;
+                _receivedPackets = new NetPacket[_windowSize];
+            }
+            else
+            {
+                _deliveryMethod = DeliveryMethod.ReliableUnordered;
+                _earlyReceived = new bool[_windowSize];
+            }
+
+            _localWindowStart = 0;
+            _localSeqence = 0;
+            _remoteSequence = 0;
+            _remoteWindowStart = 0;
+            _outgoingAcks = new(PacketProperty.Ack, (_windowSize - 1) / BitsInByte + 2) { ChannelId = id };
+        }
+
+        //ProcessAck in packet
+        private void ProcessAck(NetPacket packet)
+        {
+            if (packet.Size != _outgoingAcks.Size)
+            {
+                NetDebug.Write("[PA]Invalid acks packet size");
+                return;
+            }
+
+            ushort ackWindowStart = packet.Sequence;
+            int windowRel = NetUtils.RelativeSequenceNumber(_localWindowStart, ackWindowStart);
+            if (ackWindowStart >= NetConstants.MaxSequence || windowRel < 0)
+            {
+                NetDebug.Write("[PA]Bad window start");
+                return;
+            }
+
+            //check relevance
+            if (windowRel >= _windowSize)
+            {
+                NetDebug.Write("[PA]Old acks");
+                return;
+            }
+
+            byte[] acksData = packet.RawData;
+            lock (_pendingPackets)
+            {
+                for (int pendingSeq = _localWindowStart; pendingSeq != _localSeqence; pendingSeq = (pendingSeq + 1) % NetConstants.MaxSequence)
+                {
+                    int rel = NetUtils.RelativeSequenceNumber(pendingSeq, ackWindowStart);
+                    if (rel >= _windowSize)
+                    {
+                        NetDebug.Write("[PA]REL: " + rel);
+                        break;
+                    }
+
+                    int pendingIdx = pendingSeq % _windowSize;
+                    int currentByte = NetConstants.ChanneledHeaderSize + pendingIdx / BitsInByte;
+                    int currentBit = pendingIdx % BitsInByte;
+                    if ((acksData[currentByte] & (1 << currentBit)) == 0)
+                    {
+                        if (Peer.NetManager.EnableStatistics)
+                        {
+                            Peer.Statistics.IncrementPacketLoss();
+                            Peer.NetManager.Statistics.IncrementPacketLoss();
+                        }
+
+                        //Skip false ack
+                        NetDebug.Write($"[PA]False ack: {pendingSeq}");
+                        continue;
+                    }
+
+                    if (pendingSeq == _localWindowStart)
+                    {
+                        //Move window
+                        _localWindowStart = (_localWindowStart + 1) % NetConstants.MaxSequence;
+                    }
+
+                    //clear packet
+                    if (_pendingPackets[pendingIdx].Clear(Peer))
+                        NetDebug.Write($"[PA]Removing reliableInOrder ack: {pendingSeq} - true");
+                }
+            }
+        }
+
+        protected override bool SendNextPackets()
+        {
+            if (_mustSendAcks)
+            {
+                _mustSendAcks = false;
+                NetDebug.Write("[RR]SendAcks");
+                lock (_outgoingAcks)
+                {
+                    Peer.SendUserData(_outgoingAcks);
+                }
+            }
+
+            long currentTime = DateTime.UtcNow.Ticks;
+            bool hasPendingPackets = false;
+
+            lock (_pendingPackets)
+            {
+                //get packets from queue
+                lock (OutgoingQueue)
+                {
+                    while (OutgoingQueue.Count > 0)
+                    {
+                        int relate = NetUtils.RelativeSequenceNumber(_localSeqence, _localWindowStart);
+                        if (relate >= _windowSize)
+                            break;
+
+                        NetPacket netPacket = OutgoingQueue.Dequeue();
+                        netPacket.Sequence = (ushort)_localSeqence;
+                        netPacket.ChannelId = _id;
+                        _pendingPackets[_localSeqence % _windowSize].Init(netPacket);
+                        _localSeqence = (_localSeqence + 1) % NetConstants.MaxSequence;
+                    }
+                }
+
+                //send
+                for (int pendingSeq = _localWindowStart; pendingSeq != _localSeqence; pendingSeq = (pendingSeq + 1) % NetConstants.MaxSequence)
+                {
+                    // Please note: TrySend is invoked on a mutable struct, it's important to not extract it into a variable here
+                    if (_pendingPackets[pendingSeq % _windowSize].TrySend(currentTime, Peer))
+                        hasPendingPackets = true;
+                }
+            }
+
+            return hasPendingPackets || _mustSendAcks || OutgoingQueue.Count > 0;
+        }
+
+        //Process incoming packet
+        public override bool ProcessPacket(NetPacket packet)
+        {
+            if (packet.Property == PacketProperty.Ack)
+            {
+                ProcessAck(packet);
+                return false;
+            }
+            int seq = packet.Sequence;
+            if (seq >= NetConstants.MaxSequence)
+            {
+                NetDebug.Write("[RR]Bad sequence");
+                return false;
+            }
+
+            int relate = NetUtils.RelativeSequenceNumber(seq, _remoteWindowStart);
+            int relateSeq = NetUtils.RelativeSequenceNumber(seq, _remoteSequence);
+
+            if (relateSeq > _windowSize)
+            {
+                NetDebug.Write("[RR]Bad sequence");
+                return false;
+            }
+
+            //Drop bad packets
+            if (relate < 0)
+            {
+                //Too old packet doesn't ack
+                NetDebug.Write("[RR]ReliableInOrder too old");
+                return false;
+            }
+            if (relate >= _windowSize * 2)
+            {
+                //Some very new packet
+                NetDebug.Write("[RR]ReliableInOrder too new");
+                return false;
+            }
+
+            //If very new - move window
+            int ackIdx;
+            int ackByte;
+            int ackBit;
+            lock (_outgoingAcks)
+            {
+                if (relate >= _windowSize)
+                {
+                    //New window position
+                    int newWindowStart = (_remoteWindowStart + relate - _windowSize + 1) % NetConstants.MaxSequence;
+                    _outgoingAcks.Sequence = (ushort)newWindowStart;
+
+                    //Clean old data
+                    while (_remoteWindowStart != newWindowStart)
+                    {
+                        ackIdx = _remoteWindowStart % _windowSize;
+                        ackByte = NetConstants.ChanneledHeaderSize + ackIdx / BitsInByte;
+                        ackBit = ackIdx % BitsInByte;
+                        _outgoingAcks.RawData[ackByte] &= (byte)~(1 << ackBit);
+                        _remoteWindowStart = (_remoteWindowStart + 1) % NetConstants.MaxSequence;
+                    }
+                }
+
+                //Final stage - process valid packet
+                //trigger acks send
+                _mustSendAcks = true;
+
+                ackIdx = seq % _windowSize;
+                ackByte = NetConstants.ChanneledHeaderSize + ackIdx / BitsInByte;
+                ackBit = ackIdx % BitsInByte;
+                if ((_outgoingAcks.RawData[ackByte] & (1 << ackBit)) != 0)
+                {
+                    NetDebug.Write("[RR]ReliableInOrder duplicate");
+                    //because _mustSendAcks == true
+                    AddToPeerChannelSendQueue();
+                    return false;
+                }
+
+                //save ack
+                _outgoingAcks.RawData[ackByte] |= (byte)(1 << ackBit);
+            }
+
+            AddToPeerChannelSendQueue();
+
+            //detailed check
+            if (seq == _remoteSequence)
+            {
+                NetDebug.Write("[RR]ReliableInOrder packet succes");
+                Peer.AddReliablePacket(_deliveryMethod, packet);
+                _remoteSequence = (_remoteSequence + 1) % NetConstants.MaxSequence;
+
+                if (_ordered)
+                {
+                    NetPacket p;
+                    while ((p = _receivedPackets[_remoteSequence % _windowSize]) != null)
+                    {
+                        //process holden packet
+                        _receivedPackets[_remoteSequence % _windowSize] = null;
+                        Peer.AddReliablePacket(_deliveryMethod, p);
+                        _remoteSequence = (_remoteSequence + 1) % NetConstants.MaxSequence;
+                    }
+                }
+                else
+                {
+                    while (_earlyReceived[_remoteSequence % _windowSize])
+                    {
+                        //process early packet
+                        _earlyReceived[_remoteSequence % _windowSize] = false;
+                        _remoteSequence = (_remoteSequence + 1) % NetConstants.MaxSequence;
+                    }
+                }
+                return true;
+            }
+
+            //holden packet
+            if (_ordered)
+            {
+                _receivedPackets[ackIdx] = packet;
+            }
+            else
+            {
+                _earlyReceived[ackIdx] = true;
+                Peer.AddReliablePacket(_deliveryMethod, packet);
+            }
+            return true;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/ReliableChannel.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: f7e20c169333af54fa233b0d70b19a61
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/ReliableChannel.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/SequencedChannel.cs

@@ -0,0 +1,109 @@
+using System;
+
+namespace LiteNetLib
+{
+    internal sealed class SequencedChannel : BaseChannel
+    {
+        private int _localSequence;
+        private ushort _remoteSequence;
+        private readonly bool _reliable;
+        private NetPacket _lastPacket;
+        private readonly NetPacket _ackPacket;
+        private bool _mustSendAck;
+        private readonly byte _id;
+        private long _lastPacketSendTime;
+
+        public SequencedChannel(NetPeer peer, bool reliable, byte id) : base(peer)
+        {
+            _id = id;
+            _reliable = reliable;
+            if (_reliable)
+                _ackPacket = new(PacketProperty.Ack, 0) { ChannelId = id };
+        }
+
+        protected override bool SendNextPackets()
+        {
+            if (_reliable && OutgoingQueue.Count == 0)
+            {
+                long currentTime = DateTime.UtcNow.Ticks;
+                long packetHoldTime = currentTime - _lastPacketSendTime;
+                if (packetHoldTime >= Peer.ResendDelay * TimeSpan.TicksPerMillisecond)
+                {
+                    NetPacket packet = _lastPacket;
+                    if (packet != null)
+                    {
+                        _lastPacketSendTime = currentTime;
+                        Peer.SendUserData(packet);
+                    }
+                }
+            }
+            else
+            {
+                lock (OutgoingQueue)
+                {
+                    while (OutgoingQueue.Count > 0)
+                    {
+                        NetPacket packet = OutgoingQueue.Dequeue();
+                        _localSequence = (_localSequence + 1) % NetConstants.MaxSequence;
+                        packet.Sequence = (ushort)_localSequence;
+                        packet.ChannelId = _id;
+                        Peer.SendUserData(packet);
+
+                        if (_reliable && OutgoingQueue.Count == 0)
+                        {
+                            _lastPacketSendTime = DateTime.UtcNow.Ticks;
+                            _lastPacket = packet;
+                        }
+                        else
+                        {
+                            Peer.NetManager.PoolRecycle(packet);
+                        }
+                    }
+                }
+            }
+
+            if (_reliable && _mustSendAck)
+            {
+                _mustSendAck = false;
+                _ackPacket.Sequence = _remoteSequence;
+                Peer.SendUserData(_ackPacket);
+            }
+
+            return _lastPacket != null;
+        }
+
+        public override bool ProcessPacket(NetPacket packet)
+        {
+            if (packet.IsFragmented)
+                return false;
+            if (packet.Property == PacketProperty.Ack)
+            {
+                if (_reliable && _lastPacket != null && packet.Sequence == _lastPacket.Sequence)
+                    _lastPacket = null;
+                return false;
+            }
+            int relative = NetUtils.RelativeSequenceNumber(packet.Sequence, _remoteSequence);
+            bool packetProcessed = false;
+            if (packet.Sequence < NetConstants.MaxSequence && relative > 0)
+            {
+                if (Peer.NetManager.EnableStatistics)
+                {
+                    Peer.Statistics.AddPacketLoss(relative - 1);
+                    Peer.NetManager.Statistics.AddPacketLoss(relative - 1);
+                }
+
+                _remoteSequence = packet.Sequence;
+                Peer.NetManager.CreateReceiveEvent(packet, _reliable ? DeliveryMethod.ReliableSequenced : DeliveryMethod.Sequenced, (byte)(packet.ChannelId / NetConstants.ChannelTypeCount), NetConstants.ChanneledHeaderSize, Peer);
+                packetProcessed = true;
+            }
+
+            if (_reliable)
+            {
+                _mustSendAck = true;
+                AddToPeerChannelSendQueue();
+            }
+
+            return packetProcessed;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/SequencedChannel.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: c4e1f97908b70e642baea0fc22724282
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/SequencedChannel.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Trimming.cs

@@ -0,0 +1,12 @@
+#if NET5_0_OR_GREATER
+using System.Diagnostics.CodeAnalysis;
+using static System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes;
+
+namespace LiteNetLib
+{
+    internal static class Trimming
+    {
+        internal const DynamicallyAccessedMemberTypes SerializerMemberTypes = PublicProperties | NonPublicProperties;
+    }
+}
+#endif

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Trimming.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: af5a9e06ff14c6c42ab091c2c19e2028
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Trimming.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4ebeb715b0d0f844bad181703daa09db
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/CRC32C.cs

@@ -0,0 +1,138 @@
+#if NETCOREAPP3_0_OR_GREATER || NETCOREAPP3_1 || NET5_0
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics.X86;
+#endif
+#if NET5_0_OR_GREATER || NET5_0
+using System.Runtime.Intrinsics.Arm;
+#endif
+
+namespace LiteNetLib.Utils
+{
+    // Implementation from Crc32.NET
+    public static class CRC32C
+    {
+        public const int ChecksumSize = 4;
+        private const uint Poly = 0x82F63B78u;
+        private static readonly uint[] Table;
+
+        static CRC32C()
+        {
+#if NETCOREAPP3_0_OR_GREATER || NETCOREAPP3_1 || NET5_0
+            if (Sse42.IsSupported)
+                return;
+#endif
+#if NET5_0_OR_GREATER || NET5_0
+            if (Crc32.IsSupported)
+                return;
+#endif
+            Table = NetUtils.AllocatePinnedUninitializedArray<uint>(16 * 256);
+            for (uint i = 0; i < 256; i++)
+            {
+                uint res = i;
+                for (int t = 0; t < 16; t++)
+                {
+                    for (int k = 0; k < 8; k++)
+                        res = (res & 1) == 1 ? Poly ^ (res >> 1) : res >> 1;
+                    Table[t * 256 + i] = res;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Compute CRC32C for data
+        /// </summary>
+        /// <param name = "input">input data</param>
+        /// <param name = "offset">offset</param>
+        /// <param name = "length">length</param>
+        /// <returns>CRC32C checksum</returns>
+        public static uint Compute(byte[] input, int offset, int length)
+        {
+            uint crcLocal = uint.MaxValue;
+#if NETCOREAPP3_0_OR_GREATER || NETCOREAPP3_1 || NET5_0
+            if (Sse42.IsSupported)
+            {
+                var data = new ReadOnlySpan<byte>(input, offset, length);
+                int processed = 0;
+                if (Sse42.X64.IsSupported && data.Length > sizeof(ulong))
+                {
+                    processed = data.Length / sizeof(ulong) * sizeof(ulong);
+                    var ulongs = MemoryMarshal.Cast<byte, ulong>(data.Slice(0, processed));
+                    ulong crclong = crcLocal;
+                    for (int i = 0; i < ulongs.Length; i++)
+                    {
+                        crclong = Sse42.X64.Crc32(crclong, ulongs[i]);
+                    }
+
+                    crcLocal = (uint)crclong;
+                }
+                else if (data.Length > sizeof(uint))
+                {
+                    processed = data.Length / sizeof(uint) * sizeof(uint);
+                    var uints = MemoryMarshal.Cast<byte, uint>(data.Slice(0, processed));
+                    for (int i = 0; i < uints.Length; i++)
+                    {
+                        crcLocal = Sse42.Crc32(crcLocal, uints[i]);
+                    }
+                }
+
+                for (int i = processed; i < data.Length; i++)
+                {
+                    crcLocal = Sse42.Crc32(crcLocal, data[i]);
+                }
+
+                return crcLocal ^ uint.MaxValue;
+            }
+#endif
+#if NET5_0_OR_GREATER || NET5_0
+            if (Crc32.IsSupported)
+            {
+                var data = new ReadOnlySpan<byte>(input, offset, length);
+                int processed = 0;
+                if (Crc32.Arm64.IsSupported && data.Length > sizeof(ulong))
+                {
+                    processed = data.Length / sizeof(ulong) * sizeof(ulong);
+                    var ulongs = MemoryMarshal.Cast<byte, ulong>(data.Slice(0, processed));
+                    for (int i = 0; i < ulongs.Length; i++)
+                    {
+                        crcLocal = Crc32.Arm64.ComputeCrc32C(crcLocal, ulongs[i]);
+                    }
+                }
+                else if (data.Length > sizeof(uint))
+                {
+                    processed = data.Length / sizeof(uint) * sizeof(uint);
+                    var uints = MemoryMarshal.Cast<byte, uint>(data.Slice(0, processed));
+                    for (int i = 0; i < uints.Length; i++)
+                    {
+                        crcLocal = Crc32.ComputeCrc32C(crcLocal, uints[i]);
+                    }
+                }
+
+                for (int i = processed; i < data.Length; i++)
+                {
+                    crcLocal = Crc32.ComputeCrc32C(crcLocal, data[i]);
+                }
+
+                return crcLocal ^ uint.MaxValue;
+            }
+#endif
+            while (length >= 16)
+            {
+                uint a = Table[3 * 256 + input[offset + 12]] ^ Table[2 * 256 + input[offset + 13]] ^ Table[1 * 256 + input[offset + 14]] ^ Table[0 * 256 + input[offset + 15]];
+
+                uint b = Table[7 * 256 + input[offset + 8]] ^ Table[6 * 256 + input[offset + 9]] ^ Table[5 * 256 + input[offset + 10]] ^ Table[4 * 256 + input[offset + 11]];
+
+                uint c = Table[11 * 256 + input[offset + 4]] ^ Table[10 * 256 + input[offset + 5]] ^ Table[9 * 256 + input[offset + 6]] ^ Table[8 * 256 + input[offset + 7]];
+
+                uint d = Table[15 * 256 + ((byte)crcLocal ^ input[offset])] ^ Table[14 * 256 + ((byte)(crcLocal >> 8) ^ input[offset + 1])] ^ Table[13 * 256 + ((byte)(crcLocal >> 16) ^ input[offset + 2])] ^ Table[12 * 256 + ((crcLocal >> 24) ^ input[offset + 3])];
+
+                crcLocal = d ^ c ^ b ^ a;
+                offset += 16;
+                length -= 16;
+            }
+            while (--length >= 0)
+                crcLocal = Table[(byte)(crcLocal ^ input[offset++])] ^ (crcLocal >> 8);
+            return crcLocal ^ uint.MaxValue;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/CRC32C.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 912ba506b0945b743be5c4129177024c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/CRC32C.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/FastBitConverter.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace LiteNetLib.Utils
+{
+    public static class FastBitConverter
+    {
+#if (LITENETLIB_UNSAFE || NETCOREAPP3_1 || NET5_0 || NETCOREAPP3_0_OR_GREATER) && !BIGENDIAN
+#if LITENETLIB_UNSAFE
+        public static unsafe void GetBytes<T>(byte[] bytes, int startIndex, T value) where T : unmanaged
+        {
+            int size = sizeof(T);
+            if (bytes.Length < startIndex + size)
+                ThrowIndexOutOfRangeException();
+#if NETCOREAPP3_1 || NET5_0 || NETCOREAPP3_0_OR_GREATER
+            Unsafe.As<byte, T>(ref bytes[startIndex]) = value;
+#else
+            fixed (byte* ptr = &bytes[startIndex])
+            {
+#if UNITY_ANDROID
+                // On some android systems, assigning *(T*)ptr throws a NRE if
+                // the ptr isn't aligned (i.e. if Position is 1,2,3,5, etc.).
+                // Here we have to use memcpy.
+                //
+                // => we can't get a pointer of a struct in C# without
+                //    marshalling allocations
+                // => instead, we stack allocate an array of type T and use that
+                // => stackalloc avoids GC and is very fast. it only works for
+                //    value types, but all blittable types are anyway.
+                T* valueBuffer = stackalloc T[1] { value };
+                UnsafeUtility.MemCpy(ptr, valueBuffer, size);
+#else
+                *(T*)ptr = value;
+#endif
+            }
+#endif
+        }
+#else
+        public static void GetBytes<T>(byte[] bytes, int startIndex, T value) where T : unmanaged
+        {
+            if (bytes.Length < startIndex + Unsafe.SizeOf<T>())
+                ThrowIndexOutOfRangeException();
+            Unsafe.As<byte, T>(ref bytes[startIndex]) = value;
+        }
+#endif
+        private static void ThrowIndexOutOfRangeException() => throw new IndexOutOfRangeException();
+#else
+        [StructLayout(LayoutKind.Explicit)]
+        private struct ConverterHelperDouble
+        {
+            [FieldOffset(0)]
+            public ulong Along;
+            [FieldOffset(0)]
+            public double Adouble;
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        private struct ConverterHelperFloat
+        {
+            [FieldOffset(0)]
+            public int Aint;
+            [FieldOffset(0)]
+            public float Afloat;
+        }
+
+        private static void WriteLittleEndian(byte[] buffer, int offset, ulong data)
+        {
+#if BIGENDIAN
+            buffer[offset + 7] = (byte)(data);
+            buffer[offset + 6] = (byte)(data >> 8);
+            buffer[offset + 5] = (byte)(data >> 16);
+            buffer[offset + 4] = (byte)(data >> 24);
+            buffer[offset + 3] = (byte)(data >> 32);
+            buffer[offset + 2] = (byte)(data >> 40);
+            buffer[offset + 1] = (byte)(data >> 48);
+            buffer[offset] = (byte)(data >> 56);
+#else
+            buffer[offset] = (byte)data;
+            buffer[offset + 1] = (byte)(data >> 8);
+            buffer[offset + 2] = (byte)(data >> 16);
+            buffer[offset + 3] = (byte)(data >> 24);
+            buffer[offset + 4] = (byte)(data >> 32);
+            buffer[offset + 5] = (byte)(data >> 40);
+            buffer[offset + 6] = (byte)(data >> 48);
+            buffer[offset + 7] = (byte)(data >> 56);
+#endif
+        }
+
+        private static void WriteLittleEndian(byte[] buffer, int offset, int data)
+        {
+#if BIGENDIAN
+            buffer[offset + 3] = (byte)(data);
+            buffer[offset + 2] = (byte)(data >> 8);
+            buffer[offset + 1] = (byte)(data >> 16);
+            buffer[offset] = (byte)(data >> 24);
+#else
+            buffer[offset] = (byte)data;
+            buffer[offset + 1] = (byte)(data >> 8);
+            buffer[offset + 2] = (byte)(data >> 16);
+            buffer[offset + 3] = (byte)(data >> 24);
+#endif
+        }
+
+        public static void WriteLittleEndian(byte[] buffer, int offset, short data)
+        {
+#if BIGENDIAN
+            buffer[offset + 1] = (byte)(data);
+            buffer[offset] = (byte)(data >> 8);
+#else
+            buffer[offset] = (byte)data;
+            buffer[offset + 1] = (byte)(data >> 8);
+#endif
+        }
+
+        public static void GetBytes(byte[] bytes, int startIndex, double value)
+        {
+            ConverterHelperDouble ch = new() { Adouble = value };
+            WriteLittleEndian(bytes, startIndex, ch.Along);
+        }
+
+        public static void GetBytes(byte[] bytes, int startIndex, float value)
+        {
+            ConverterHelperFloat ch = new() { Afloat = value };
+            WriteLittleEndian(bytes, startIndex, ch.Aint);
+        }
+
+        public static void GetBytes(byte[] bytes, int startIndex, short value)
+        {
+            WriteLittleEndian(bytes, startIndex, value);
+        }
+
+        public static void GetBytes(byte[] bytes, int startIndex, ushort value)
+        {
+            WriteLittleEndian(bytes, startIndex, (short)value);
+        }
+
+        public static void GetBytes(byte[] bytes, int startIndex, int value)
+        {
+            WriteLittleEndian(bytes, startIndex, value);
+        }
+
+        public static void GetBytes(byte[] bytes, int startIndex, uint value)
+        {
+            WriteLittleEndian(bytes, startIndex, (int)value);
+        }
+
+        public static void GetBytes(byte[] bytes, int startIndex, long value)
+        {
+            WriteLittleEndian(bytes, startIndex, (ulong)value);
+        }
+
+        public static void GetBytes(byte[] bytes, int startIndex, ulong value)
+        {
+            WriteLittleEndian(bytes, startIndex, value);
+        }
+#endif
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/FastBitConverter.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 21018f84ccfb8244e99b5ec22ceb91c9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/FastBitConverter.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/INetSerializable.cs

@@ -0,0 +1,8 @@
+namespace LiteNetLib.Utils
+{
+    public interface INetSerializable
+    {
+        void Serialize(NetDataWriter writer);
+        void Deserialize(NetDataReader reader);
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/INetSerializable.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: c26b17a74d3fb8b498fc89d253f1742a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/INetSerializable.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NetDataReader.cs

@@ -0,0 +1,761 @@
+using System;
+using System.Net;
+using System.Runtime.CompilerServices;
+
+namespace LiteNetLib.Utils
+{
+    public class NetDataReader
+    {
+        protected byte[] _data;
+        protected int _position;
+        protected int _dataSize;
+        public byte[] RawData
+        {
+            get => _data;
+        }
+        public int RawDataSize
+        {
+            get => _dataSize;
+        }
+        public int UserDataOffset { get; private set; }
+        public int UserDataSize
+        {
+            get => _dataSize - UserDataOffset;
+        }
+        public bool IsNull
+        {
+            get => _data == null;
+        }
+        public int Position
+        {
+            get => _position;
+        }
+        public bool EndOfData
+        {
+            get => _position == _dataSize;
+        }
+        public int AvailableBytes
+        {
+            get => _dataSize - _position;
+        }
+
+        public void SkipBytes(int count)
+        {
+            _position += count;
+        }
+
+        public void SetPosition(int position)
+        {
+            _position = position;
+        }
+
+        public void SetSource(NetDataWriter dataWriter)
+        {
+            _data = dataWriter.Data;
+            _position = 0;
+            UserDataOffset = 0;
+            _dataSize = dataWriter.Length;
+        }
+
+        public void SetSource(byte[] source)
+        {
+            _data = source;
+            _position = 0;
+            UserDataOffset = 0;
+            _dataSize = source.Length;
+        }
+
+        public void SetSource(byte[] source, int offset, int maxSize)
+        {
+            _data = source;
+            _position = offset;
+            UserDataOffset = offset;
+            _dataSize = maxSize;
+        }
+
+        public NetDataReader() { }
+
+        public NetDataReader(NetDataWriter writer)
+        {
+            SetSource(writer);
+        }
+
+        public NetDataReader(byte[] source)
+        {
+            SetSource(source);
+        }
+
+        public NetDataReader(byte[] source, int offset, int maxSize)
+        {
+            SetSource(source, offset, maxSize);
+        }
+
+        #region GetMethods
+        public void Get<T>(out T result) where T : struct, INetSerializable
+        {
+            result = default;
+            result.Deserialize(this);
+        }
+
+        public void Get<T>(out T result, Func<T> constructor) where T : class, INetSerializable
+        {
+            result = constructor();
+            result.Deserialize(this);
+        }
+
+        public void Get(out IPEndPoint result)
+        {
+            result = GetNetEndPoint();
+        }
+
+        public void Get(out byte result)
+        {
+            result = GetByte();
+        }
+
+        public void Get(out sbyte result)
+        {
+            result = (sbyte)GetByte();
+        }
+
+        public void Get(out bool result)
+        {
+            result = GetBool();
+        }
+
+        public void Get(out char result)
+        {
+            result = GetChar();
+        }
+
+        public void Get(out ushort result)
+        {
+            result = GetUShort();
+        }
+
+        public void Get(out short result)
+        {
+            result = GetShort();
+        }
+
+        public void Get(out ulong result)
+        {
+            result = GetULong();
+        }
+
+        public void Get(out long result)
+        {
+            result = GetLong();
+        }
+
+        public void Get(out uint result)
+        {
+            result = GetUInt();
+        }
+
+        public void Get(out int result)
+        {
+            result = GetInt();
+        }
+
+        public void Get(out double result)
+        {
+            result = GetDouble();
+        }
+
+        public void Get(out float result)
+        {
+            result = GetFloat();
+        }
+
+        public void Get(out string result)
+        {
+            result = GetString();
+        }
+
+        public void Get(out string result, int maxLength)
+        {
+            result = GetString(maxLength);
+        }
+
+        public IPEndPoint GetNetEndPoint()
+        {
+            string host = GetString(1000);
+            int port = GetInt();
+            return NetUtils.MakeEndPoint(host, port);
+        }
+
+        public byte GetByte()
+        {
+            byte res = _data[_position];
+            _position++;
+            return res;
+        }
+
+        public sbyte GetSByte()
+        {
+            return (sbyte)GetByte();
+        }
+
+        public T[] GetArray<T>(ushort size)
+        {
+            ushort length = BitConverter.ToUInt16(_data, _position);
+            _position += 2;
+            T[] result = new T[length];
+            length *= size;
+            Buffer.BlockCopy(_data, _position, result, 0, length);
+            _position += length;
+            return result;
+        }
+
+        public T[] GetArray<T>() where T : INetSerializable, new()
+        {
+            ushort length = BitConverter.ToUInt16(_data, _position);
+            _position += 2;
+            T[] result = new T[length];
+            for (int i = 0; i < length; i++)
+            {
+                T item = new();
+                item.Deserialize(this);
+                result[i] = item;
+            }
+            return result;
+        }
+
+        public bool[] GetBoolArray()
+        {
+            return GetArray<bool>(1);
+        }
+
+        public ushort[] GetUShortArray()
+        {
+            return GetArray<ushort>(2);
+        }
+
+        public short[] GetShortArray()
+        {
+            return GetArray<short>(2);
+        }
+
+        public int[] GetIntArray()
+        {
+            return GetArray<int>(4);
+        }
+
+        public uint[] GetUIntArray()
+        {
+            return GetArray<uint>(4);
+        }
+
+        public float[] GetFloatArray()
+        {
+            return GetArray<float>(4);
+        }
+
+        public double[] GetDoubleArray()
+        {
+            return GetArray<double>(8);
+        }
+
+        public long[] GetLongArray()
+        {
+            return GetArray<long>(8);
+        }
+
+        public ulong[] GetULongArray()
+        {
+            return GetArray<ulong>(8);
+        }
+
+        public string[] GetStringArray()
+        {
+            ushort length = GetUShort();
+            string[] arr = new string[length];
+            for (int i = 0; i < length; i++)
+            {
+                arr[i] = GetString();
+            }
+            return arr;
+        }
+
+        /// <summary>
+        /// Note that "maxStringLength" only limits the number of characters in a string, not its size in bytes.
+        /// Strings that exceed this parameter are returned as empty
+        /// </summary>
+        public string[] GetStringArray(int maxStringLength)
+        {
+            ushort length = GetUShort();
+            string[] arr = new string[length];
+            for (int i = 0; i < length; i++)
+            {
+                arr[i] = GetString(maxStringLength);
+            }
+            return arr;
+        }
+
+        public bool GetBool()
+        {
+            return GetByte() == 1;
+        }
+
+        public char GetChar()
+        {
+            return (char)GetUShort();
+        }
+
+        public ushort GetUShort()
+        {
+            ushort result = BitConverter.ToUInt16(_data, _position);
+            _position += 2;
+            return result;
+        }
+
+        public short GetShort()
+        {
+            short result = BitConverter.ToInt16(_data, _position);
+            _position += 2;
+            return result;
+        }
+
+        public long GetLong()
+        {
+            long result = BitConverter.ToInt64(_data, _position);
+            _position += 8;
+            return result;
+        }
+
+        public ulong GetULong()
+        {
+            ulong result = BitConverter.ToUInt64(_data, _position);
+            _position += 8;
+            return result;
+        }
+
+        public int GetInt()
+        {
+            int result = BitConverter.ToInt32(_data, _position);
+            _position += 4;
+            return result;
+        }
+
+        public uint GetUInt()
+        {
+            uint result = BitConverter.ToUInt32(_data, _position);
+            _position += 4;
+            return result;
+        }
+
+        public float GetFloat()
+        {
+            float result = BitConverter.ToSingle(_data, _position);
+            _position += 4;
+            return result;
+        }
+
+        public double GetDouble()
+        {
+            double result = BitConverter.ToDouble(_data, _position);
+            _position += 8;
+            return result;
+        }
+
+        /// <summary>
+        /// Note that "maxLength" only limits the number of characters in a string, not its size in bytes.
+        /// </summary>
+        /// <returns>"string.Empty" if value > "maxLength"</returns>
+        public string GetString(int maxLength)
+        {
+            ushort size = GetUShort();
+            if (size == 0)
+            {
+                return string.Empty;
+            }
+
+            int actualSize = size - 1;
+            if (actualSize >= NetDataWriter.StringBufferMaxLength)
+            {
+                return null;
+            }
+
+            ArraySegment<byte> data = GetBytesSegment(actualSize);
+
+            return maxLength > 0 && NetDataWriter.uTF8Encoding.Value.GetCharCount(data.Array, data.Offset, data.Count) > maxLength ? string.Empty : NetDataWriter.uTF8Encoding.Value.GetString(data.Array, data.Offset, data.Count);
+        }
+
+        public string GetString()
+        {
+            ushort size = GetUShort();
+            if (size == 0)
+            {
+                return string.Empty;
+            }
+
+            int actualSize = size - 1;
+            if (actualSize >= NetDataWriter.StringBufferMaxLength)
+            {
+                return null;
+            }
+
+            ArraySegment<byte> data = GetBytesSegment(actualSize);
+
+            return NetDataWriter.uTF8Encoding.Value.GetString(data.Array, data.Offset, data.Count);
+        }
+
+        public ArraySegment<byte> GetBytesSegment(int count)
+        {
+            ArraySegment<byte> segment = new(_data, _position, count);
+            _position += count;
+            return segment;
+        }
+
+        public ArraySegment<byte> GetRemainingBytesSegment()
+        {
+            ArraySegment<byte> segment = new(_data, _position, AvailableBytes);
+            _position = _data.Length;
+            return segment;
+        }
+
+        public T Get<T>() where T : struct, INetSerializable
+        {
+            T obj = default(T);
+            obj.Deserialize(this);
+            return obj;
+        }
+
+        public T Get<T>(Func<T> constructor) where T : class, INetSerializable
+        {
+            T obj = constructor();
+            obj.Deserialize(this);
+            return obj;
+        }
+
+#if LITENETLIB_SPANS || NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || NETCOREAPP2_1 || NETCOREAPP3_1 || NET5_0 || NETSTANDARD2_1
+        public ReadOnlySpan<byte> GetRemainingBytesSpan()
+        {
+            return new(_data, _position, _dataSize - _position);
+        }
+#endif
+
+        public byte[] GetRemainingBytes()
+        {
+            byte[] outgoingData = new byte[AvailableBytes];
+            Buffer.BlockCopy(_data, _position, outgoingData, 0, AvailableBytes);
+            _position = _data.Length;
+            return outgoingData;
+        }
+
+        public void GetBytes(byte[] destination, int start, int count)
+        {
+            Buffer.BlockCopy(_data, _position, destination, start, count);
+            _position += count;
+        }
+
+        public void GetBytes(byte[] destination, int count)
+        {
+            Buffer.BlockCopy(_data, _position, destination, 0, count);
+            _position += count;
+        }
+
+        public sbyte[] GetSBytesWithLength()
+        {
+            return GetArray<sbyte>(1);
+        }
+
+        public byte[] GetBytesWithLength()
+        {
+            return GetArray<byte>(1);
+        }
+        #endregion
+
+        #region PeekMethods
+        public byte PeekByte()
+        {
+            return _data[_position];
+        }
+
+        public sbyte PeekSByte()
+        {
+            return (sbyte)_data[_position];
+        }
+
+        public bool PeekBool()
+        {
+            return _data[_position] == 1;
+        }
+
+        public char PeekChar()
+        {
+            return (char)PeekUShort();
+        }
+
+        public ushort PeekUShort()
+        {
+            return BitConverter.ToUInt16(_data, _position);
+        }
+
+        public short PeekShort()
+        {
+            return BitConverter.ToInt16(_data, _position);
+        }
+
+        public long PeekLong()
+        {
+            return BitConverter.ToInt64(_data, _position);
+        }
+
+        public ulong PeekULong()
+        {
+            return BitConverter.ToUInt64(_data, _position);
+        }
+
+        public int PeekInt()
+        {
+            return BitConverter.ToInt32(_data, _position);
+        }
+
+        public uint PeekUInt()
+        {
+            return BitConverter.ToUInt32(_data, _position);
+        }
+
+        public float PeekFloat()
+        {
+            return BitConverter.ToSingle(_data, _position);
+        }
+
+        public double PeekDouble()
+        {
+            return BitConverter.ToDouble(_data, _position);
+        }
+
+        /// <summary>
+        /// Note that "maxLength" only limits the number of characters in a string, not its size in bytes.
+        /// </summary>
+        public string PeekString(int maxLength)
+        {
+            ushort size = PeekUShort();
+            if (size == 0)
+            {
+                return string.Empty;
+            }
+
+            int actualSize = size - 1;
+            if (actualSize >= NetDataWriter.StringBufferMaxLength)
+            {
+                return null;
+            }
+
+            return maxLength > 0 && NetDataWriter.uTF8Encoding.Value.GetCharCount(_data, _position + 2, actualSize) > maxLength ? string.Empty : NetDataWriter.uTF8Encoding.Value.GetString(_data, _position + 2, actualSize);
+        }
+
+        public string PeekString()
+        {
+            ushort size = PeekUShort();
+            if (size == 0)
+            {
+                return string.Empty;
+            }
+
+            int actualSize = size - 1;
+            if (actualSize >= NetDataWriter.StringBufferMaxLength)
+            {
+                return null;
+            }
+
+            return NetDataWriter.uTF8Encoding.Value.GetString(_data, _position + 2, actualSize);
+        }
+        #endregion
+
+        #region TryGetMethods
+        public bool TryGetByte(out byte result)
+        {
+            if (AvailableBytes >= 1)
+            {
+                result = GetByte();
+                return true;
+            }
+            result = 0;
+            return false;
+        }
+
+        public bool TryGetSByte(out sbyte result)
+        {
+            if (AvailableBytes >= 1)
+            {
+                result = GetSByte();
+                return true;
+            }
+            result = 0;
+            return false;
+        }
+
+        public bool TryGetBool(out bool result)
+        {
+            if (AvailableBytes >= 1)
+            {
+                result = GetBool();
+                return true;
+            }
+            result = false;
+            return false;
+        }
+
+        public bool TryGetChar(out char result)
+        {
+            if (!TryGetUShort(out ushort uShortValue))
+            {
+                result = '\0';
+                return false;
+            }
+            result = (char)uShortValue;
+            return true;
+        }
+
+        public bool TryGetShort(out short result)
+        {
+            if (AvailableBytes >= 2)
+            {
+                result = GetShort();
+                return true;
+            }
+            result = 0;
+            return false;
+        }
+
+        public bool TryGetUShort(out ushort result)
+        {
+            if (AvailableBytes >= 2)
+            {
+                result = GetUShort();
+                return true;
+            }
+            result = 0;
+            return false;
+        }
+
+        public bool TryGetInt(out int result)
+        {
+            if (AvailableBytes >= 4)
+            {
+                result = GetInt();
+                return true;
+            }
+            result = 0;
+            return false;
+        }
+
+        public bool TryGetUInt(out uint result)
+        {
+            if (AvailableBytes >= 4)
+            {
+                result = GetUInt();
+                return true;
+            }
+            result = 0;
+            return false;
+        }
+
+        public bool TryGetLong(out long result)
+        {
+            if (AvailableBytes >= 8)
+            {
+                result = GetLong();
+                return true;
+            }
+            result = 0;
+            return false;
+        }
+
+        public bool TryGetULong(out ulong result)
+        {
+            if (AvailableBytes >= 8)
+            {
+                result = GetULong();
+                return true;
+            }
+            result = 0;
+            return false;
+        }
+
+        public bool TryGetFloat(out float result)
+        {
+            if (AvailableBytes >= 4)
+            {
+                result = GetFloat();
+                return true;
+            }
+            result = 0;
+            return false;
+        }
+
+        public bool TryGetDouble(out double result)
+        {
+            if (AvailableBytes >= 8)
+            {
+                result = GetDouble();
+                return true;
+            }
+            result = 0;
+            return false;
+        }
+
+        public bool TryGetString(out string result)
+        {
+            if (AvailableBytes >= 2)
+            {
+                ushort strSize = PeekUShort();
+                if (AvailableBytes >= strSize + 1)
+                {
+                    result = GetString();
+                    return true;
+                }
+            }
+            result = null;
+            return false;
+        }
+
+        public bool TryGetStringArray(out string[] result)
+        {
+            if (!TryGetUShort(out ushort strArrayLength))
+            {
+                result = null;
+                return false;
+            }
+
+            result = new string[strArrayLength];
+            for (int i = 0; i < strArrayLength; i++)
+            {
+                if (!TryGetString(out result[i]))
+                {
+                    result = null;
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public bool TryGetBytesWithLength(out byte[] result)
+        {
+            if (AvailableBytes >= 2)
+            {
+                ushort length = PeekUShort();
+                if (length >= 0 && AvailableBytes >= 2 + length)
+                {
+                    result = GetBytesWithLength();
+                    return true;
+                }
+            }
+            result = null;
+            return false;
+        }
+        #endregion
+
+        public void Clear()
+        {
+            _position = 0;
+            _dataSize = 0;
+            _data = null;
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NetDataReader.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 2876e12b475627f448ca5a6850748bc3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NetDataReader.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NetDataWriter.cs

@@ -0,0 +1,376 @@
+using System;
+using System.Net;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+
+namespace LiteNetLib.Utils
+{
+    public class NetDataWriter
+    {
+        protected byte[] _data;
+        protected int _position;
+        private const int InitialSize = 64;
+        private readonly bool _autoResize;
+        public int Capacity
+        {
+            get => _data.Length;
+        }
+        public byte[] Data
+        {
+            get => _data;
+        }
+        public int Length
+        {
+            get => _position;
+        }
+        public static readonly ThreadLocal<UTF8Encoding> uTF8Encoding = new(() => new(false, true));
+        public const int StringBufferMaxLength = 65535;
+        private readonly byte[] _stringBuffer = new byte[StringBufferMaxLength];
+        public NetDataWriter() : this(true, InitialSize) { }
+        public NetDataWriter(bool autoResize) : this(autoResize, InitialSize) { }
+
+        public NetDataWriter(bool autoResize, int initialSize)
+        {
+            _data = new byte[initialSize];
+            _autoResize = autoResize;
+        }
+
+        /// <summary>
+        /// Creates NetDataWriter from existing ByteArray
+        /// </summary>
+        /// <param name = "bytes">Source byte array</param>
+        /// <param name = "copy">Copy array to new location or use existing</param>
+        public static NetDataWriter FromBytes(byte[] bytes, bool copy)
+        {
+            if (copy)
+            {
+                NetDataWriter netDataWriter = new(true, bytes.Length);
+                netDataWriter.Put(bytes);
+                return netDataWriter;
+            }
+            return new(true, 0) { _data = bytes, _position = bytes.Length };
+        }
+
+        /// <summary>
+        /// Creates NetDataWriter from existing ByteArray (always copied data)
+        /// </summary>
+        /// <param name = "bytes">Source byte array</param>
+        /// <param name = "offset">Offset of array</param>
+        /// <param name = "length">Length of array</param>
+        public static NetDataWriter FromBytes(byte[] bytes, int offset, int length)
+        {
+            NetDataWriter netDataWriter = new(true, bytes.Length);
+            netDataWriter.Put(bytes, offset, length);
+            return netDataWriter;
+        }
+
+        public static NetDataWriter FromString(string value)
+        {
+            NetDataWriter netDataWriter = new();
+            netDataWriter.Put(value);
+            return netDataWriter;
+        }
+
+        public void ResizeIfNeed(int newSize)
+        {
+            if (_data.Length < newSize)
+            {
+                Array.Resize(ref _data, Math.Max(newSize, _data.Length * 2));
+            }
+        }
+
+        public void EnsureFit(int additionalSize)
+        {
+            if (_data.Length < _position + additionalSize)
+            {
+                Array.Resize(ref _data, Math.Max(_position + additionalSize, _data.Length * 2));
+            }
+        }
+
+        public void Reset(int size)
+        {
+            ResizeIfNeed(size);
+            _position = 0;
+        }
+
+        public void Reset()
+        {
+            _position = 0;
+        }
+
+        public byte[] CopyData()
+        {
+            byte[] resultData = new byte[_position];
+            Buffer.BlockCopy(_data, 0, resultData, 0, _position);
+            return resultData;
+        }
+
+        /// <summary>
+        /// Sets position of NetDataWriter to rewrite previous values
+        /// </summary>
+        /// <param name = "position">new byte position</param>
+        /// <returns>previous position of data writer</returns>
+        public int SetPosition(int position)
+        {
+            int prevPosition = _position;
+            _position = position;
+            return prevPosition;
+        }
+
+        public void Put(float value)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 4);
+            FastBitConverter.GetBytes(_data, _position, value);
+            _position += 4;
+        }
+
+        public void Put(double value)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 8);
+            FastBitConverter.GetBytes(_data, _position, value);
+            _position += 8;
+        }
+
+        public void Put(long value)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 8);
+            FastBitConverter.GetBytes(_data, _position, value);
+            _position += 8;
+        }
+
+        public void Put(ulong value)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 8);
+            FastBitConverter.GetBytes(_data, _position, value);
+            _position += 8;
+        }
+
+        public void Put(int value)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 4);
+            FastBitConverter.GetBytes(_data, _position, value);
+            _position += 4;
+        }
+
+        public void Put(uint value)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 4);
+            FastBitConverter.GetBytes(_data, _position, value);
+            _position += 4;
+        }
+
+        public void Put(char value)
+        {
+            Put((ushort)value);
+        }
+
+        public void Put(ushort value)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 2);
+            FastBitConverter.GetBytes(_data, _position, value);
+            _position += 2;
+        }
+
+        public void Put(short value)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 2);
+            FastBitConverter.GetBytes(_data, _position, value);
+            _position += 2;
+        }
+
+        public void Put(sbyte value)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 1);
+            _data[_position] = (byte)value;
+            _position++;
+        }
+
+        public void Put(byte value)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 1);
+            _data[_position] = value;
+            _position++;
+        }
+
+        public void Put(byte[] data, int offset, int length)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + length);
+            Buffer.BlockCopy(data, offset, _data, _position, length);
+            _position += length;
+        }
+
+        public void Put(byte[] data)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + data.Length);
+            Buffer.BlockCopy(data, 0, _data, _position, data.Length);
+            _position += data.Length;
+        }
+
+        public void PutSBytesWithLength(sbyte[] data, int offset, ushort length)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 2 + length);
+            FastBitConverter.GetBytes(_data, _position, length);
+            Buffer.BlockCopy(data, offset, _data, _position + 2, length);
+            _position += 2 + length;
+        }
+
+        public void PutSBytesWithLength(sbyte[] data)
+        {
+            PutArray(data, 1);
+        }
+
+        public void PutBytesWithLength(byte[] data, int offset, ushort length)
+        {
+            if (_autoResize)
+                ResizeIfNeed(_position + 2 + length);
+            FastBitConverter.GetBytes(_data, _position, length);
+            Buffer.BlockCopy(data, offset, _data, _position + 2, length);
+            _position += 2 + length;
+        }
+
+        public void PutBytesWithLength(byte[] data)
+        {
+            PutArray(data, 1);
+        }
+
+        public void Put(bool value)
+        {
+            Put((byte)(value ? 1 : 0));
+        }
+
+        public void PutArray(Array arr, int sz)
+        {
+            ushort length = arr == null ? (ushort)0 : (ushort)arr.Length;
+            sz *= length;
+            if (_autoResize)
+                ResizeIfNeed(_position + sz + 2);
+            FastBitConverter.GetBytes(_data, _position, length);
+            if (arr != null)
+                Buffer.BlockCopy(arr, 0, _data, _position + 2, sz);
+            _position += sz + 2;
+        }
+
+        public void PutArray(float[] value)
+        {
+            PutArray(value, 4);
+        }
+
+        public void PutArray(double[] value)
+        {
+            PutArray(value, 8);
+        }
+
+        public void PutArray(long[] value)
+        {
+            PutArray(value, 8);
+        }
+
+        public void PutArray(ulong[] value)
+        {
+            PutArray(value, 8);
+        }
+
+        public void PutArray(int[] value)
+        {
+            PutArray(value, 4);
+        }
+
+        public void PutArray(uint[] value)
+        {
+            PutArray(value, 4);
+        }
+
+        public void PutArray(ushort[] value)
+        {
+            PutArray(value, 2);
+        }
+
+        public void PutArray(short[] value)
+        {
+            PutArray(value, 2);
+        }
+
+        public void PutArray(bool[] value)
+        {
+            PutArray(value, 1);
+        }
+
+        public void PutArray(string[] value)
+        {
+            ushort strArrayLength = value == null ? (ushort)0 : (ushort)value.Length;
+            Put(strArrayLength);
+            for (int i = 0; i < strArrayLength; i++)
+                Put(value[i]);
+        }
+
+        public void PutArray(string[] value, int strMaxLength)
+        {
+            ushort strArrayLength = value == null ? (ushort)0 : (ushort)value.Length;
+            Put(strArrayLength);
+            for (int i = 0; i < strArrayLength; i++)
+                Put(value[i], strMaxLength);
+        }
+
+        public void PutArray<T>(T[] value) where T : INetSerializable, new()
+        {
+            ushort strArrayLength = (ushort)(value?.Length ?? 0);
+            Put(strArrayLength);
+            for (int i = 0; i < strArrayLength; i++)
+                value[i].Serialize(this);
+        }
+
+        public void Put(IPEndPoint endPoint)
+        {
+            Put(endPoint.Address.ToString());
+            Put(endPoint.Port);
+        }
+
+        public void Put(string value)
+        {
+            Put(value, 0);
+        }
+
+        /// <summary>
+        /// Note that "maxLength" only limits the number of characters in a string, not its size in bytes.
+        /// </summary>
+        public void Put(string value, int maxLength)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                Put((ushort)0);
+                return;
+            }
+
+            int length = maxLength > 0 && value.Length > maxLength ? maxLength : value.Length;
+            int size = uTF8Encoding.Value.GetBytes(value, 0, length, _stringBuffer, 0);
+
+            if (size == 0 || size >= StringBufferMaxLength)
+            {
+                Put((ushort)0);
+                return;
+            }
+
+            Put(checked((ushort)(size + 1)));
+            Put(_stringBuffer, 0, size);
+        }
+
+        public void Put<T>(T obj) where T : INetSerializable
+        {
+            obj.Serialize(this);
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NetDataWriter.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: bb3b55fb59ddd9044b1fd56b8543053b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NetDataWriter.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NetPacketProcessor.cs

@@ -0,0 +1,283 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace LiteNetLib.Utils
+{
+    public class NetPacketProcessor
+    {
+        private static class HashCache<T>
+        {
+            public static readonly ulong Id;
+
+            // FNV-1 64 bit hash
+            static HashCache()
+            {
+                ulong hash = 14695981039346656037UL; // offset
+                string typeName = typeof(T).ToString();
+                for (int i = 0; i < typeName.Length; i++)
+                {
+                    hash ^= typeName[i];
+                    hash *= 1099511628211UL; // prime
+                }
+                Id = hash;
+            }
+        }
+
+        protected delegate void SubscribeDelegate(NetDataReader reader, object userData);
+
+        private readonly NetSerializer _netSerializer;
+        private readonly Dictionary<ulong, SubscribeDelegate> _callbacks = new();
+
+        public NetPacketProcessor()
+        {
+            _netSerializer = new();
+        }
+
+        public NetPacketProcessor(int maxStringLength)
+        {
+            _netSerializer = new(maxStringLength);
+        }
+
+        protected virtual ulong GetHash<T>()
+        {
+            return HashCache<T>.Id;
+        }
+
+        protected virtual SubscribeDelegate GetCallbackFromData(NetDataReader reader)
+        {
+            ulong hash = reader.GetULong();
+            if (!_callbacks.TryGetValue(hash, out SubscribeDelegate action))
+            {
+                throw new ParseException("Undefined packet in NetDataReader");
+            }
+            return action;
+        }
+
+        protected virtual void WriteHash<T>(NetDataWriter writer)
+        {
+            writer.Put(GetHash<T>());
+        }
+
+        /// <summary>
+        /// Register nested property type
+        /// </summary>
+        /// <typeparam name = "T">INetSerializable structure</typeparam>
+        public void RegisterNestedType<T>() where T : struct, INetSerializable
+        {
+            _netSerializer.RegisterNestedType<T>();
+        }
+
+        /// <summary>
+        /// Register nested property type
+        /// </summary>
+        /// <param name = "writeDelegate"></param>
+        /// <param name = "readDelegate"></param>
+        public void RegisterNestedType<T>(Action<NetDataWriter, T> writeDelegate, Func<NetDataReader, T> readDelegate)
+        {
+            _netSerializer.RegisterNestedType(writeDelegate, readDelegate);
+        }
+
+        /// <summary>
+        /// Register nested property type
+        /// </summary>
+        /// <typeparam name = "T">INetSerializable class</typeparam>
+        public void RegisterNestedType<T>(Func<T> constructor) where T : class, INetSerializable
+        {
+            _netSerializer.RegisterNestedType(constructor);
+        }
+
+        /// <summary>
+        /// Reads all available data from NetDataReader and calls OnReceive delegates
+        /// </summary>
+        /// <param name = "reader">NetDataReader with packets data</param>
+        public void ReadAllPackets(NetDataReader reader)
+        {
+            while (reader.AvailableBytes > 0)
+                ReadPacket(reader);
+        }
+
+        /// <summary>
+        /// Reads all available data from NetDataReader and calls OnReceive delegates
+        /// </summary>
+        /// <param name = "reader">NetDataReader with packets data</param>
+        /// <param name = "userData">Argument that passed to OnReceivedEvent</param>
+        /// <exception cref = "ParseException">Malformed packet</exception>
+        public void ReadAllPackets(NetDataReader reader, object userData)
+        {
+            while (reader.AvailableBytes > 0)
+                ReadPacket(reader, userData);
+        }
+
+        /// <summary>
+        /// Reads one packet from NetDataReader and calls OnReceive delegate
+        /// </summary>
+        /// <param name = "reader">NetDataReader with packet</param>
+        /// <exception cref = "ParseException">Malformed packet</exception>
+        public void ReadPacket(NetDataReader reader)
+        {
+            ReadPacket(reader, null);
+        }
+
+        public void Write<
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(Trimming.SerializerMemberTypes)]
+#endif
+            T>(NetDataWriter writer, T packet) where T : class, new()
+        {
+            WriteHash<T>(writer);
+            _netSerializer.Serialize(writer, packet);
+        }
+
+        public void WriteNetSerializable<T>(NetDataWriter writer, ref T packet) where T : INetSerializable
+        {
+            WriteHash<T>(writer);
+            packet.Serialize(writer);
+        }
+
+        /// <summary>
+        /// Reads one packet from NetDataReader and calls OnReceive delegate
+        /// </summary>
+        /// <param name = "reader">NetDataReader with packet</param>
+        /// <param name = "userData">Argument that passed to OnReceivedEvent</param>
+        /// <exception cref = "ParseException">Malformed packet</exception>
+        public void ReadPacket(NetDataReader reader, object userData)
+        {
+            GetCallbackFromData(reader)(reader, userData);
+        }
+
+        /// <summary>
+        /// Register and subscribe to packet receive event
+        /// </summary>
+        /// <param name = "onReceive">event that will be called when packet deserialized with ReadPacket method</param>
+        /// <param name = "packetConstructor">Method that constructs packet instead of slow Activator.CreateInstance</param>
+        /// <exception cref = "InvalidTypeException"><typeparamref name = "T"/>'s fields are not supported, or it has no fields</exception>
+        public void Subscribe<
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(Trimming.SerializerMemberTypes)]
+#endif
+            T>(Action<T> onReceive, Func<T> packetConstructor) where T : class, new()
+        {
+            _netSerializer.Register<T>();
+            _callbacks[GetHash<T>()] = (reader, userData) =>
+            {
+                T reference = packetConstructor();
+                _netSerializer.Deserialize(reader, reference);
+                onReceive(reference);
+            };
+        }
+
+        /// <summary>
+        /// Register and subscribe to packet receive event (with userData)
+        /// </summary>
+        /// <param name = "onReceive">event that will be called when packet deserialized with ReadPacket method</param>
+        /// <param name = "packetConstructor">Method that constructs packet instead of slow Activator.CreateInstance</param>
+        /// <exception cref = "InvalidTypeException"><typeparamref name = "T"/>'s fields are not supported, or it has no fields</exception>
+        public void Subscribe<
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(Trimming.SerializerMemberTypes)]
+#endif
+            T, TUserData>(Action<T, TUserData> onReceive, Func<T> packetConstructor) where T : class, new()
+        {
+            _netSerializer.Register<T>();
+            _callbacks[GetHash<T>()] = (reader, userData) =>
+            {
+                T reference = packetConstructor();
+                _netSerializer.Deserialize(reader, reference);
+                onReceive(reference, (TUserData)userData);
+            };
+        }
+
+        /// <summary>
+        /// Register and subscribe to packet receive event
+        /// This method will overwrite last received packet class on receive (less garbage)
+        /// </summary>
+        /// <param name = "onReceive">event that will be called when packet deserialized with ReadPacket method</param>
+        /// <exception cref = "InvalidTypeException"><typeparamref name = "T"/>'s fields are not supported, or it has no fields</exception>
+        public void SubscribeReusable<
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(Trimming.SerializerMemberTypes)]
+#endif
+            T>(Action<T> onReceive) where T : class, new()
+        {
+            _netSerializer.Register<T>();
+            T reference = new();
+            _callbacks[GetHash<T>()] = (reader, userData) =>
+            {
+                _netSerializer.Deserialize(reader, reference);
+                onReceive(reference);
+            };
+        }
+
+        /// <summary>
+        /// Register and subscribe to packet receive event
+        /// This method will overwrite last received packet class on receive (less garbage)
+        /// </summary>
+        /// <param name = "onReceive">event that will be called when packet deserialized with ReadPacket method</param>
+        /// <exception cref = "InvalidTypeException"><typeparamref name = "T"/>'s fields are not supported, or it has no fields</exception>
+        public void SubscribeReusable<
+#if NET5_0_OR_GREATER
+            [DynamicallyAccessedMembers(Trimming.SerializerMemberTypes)]
+#endif
+            T, TUserData>(Action<T, TUserData> onReceive) where T : class, new()
+        {
+            _netSerializer.Register<T>();
+            T reference = new();
+            _callbacks[GetHash<T>()] = (reader, userData) =>
+            {
+                _netSerializer.Deserialize(reader, reference);
+                onReceive(reference, (TUserData)userData);
+            };
+        }
+
+        public void SubscribeNetSerializable<T, TUserData>(Action<T, TUserData> onReceive, Func<T> packetConstructor) where T : INetSerializable
+        {
+            _callbacks[GetHash<T>()] = (reader, userData) =>
+            {
+                T pkt = packetConstructor();
+                pkt.Deserialize(reader);
+                onReceive(pkt, (TUserData)userData);
+            };
+        }
+
+        public void SubscribeNetSerializable<T>(Action<T> onReceive, Func<T> packetConstructor) where T : INetSerializable
+        {
+            _callbacks[GetHash<T>()] = (reader, userData) =>
+            {
+                T pkt = packetConstructor();
+                pkt.Deserialize(reader);
+                onReceive(pkt);
+            };
+        }
+
+        public void SubscribeNetSerializable<T, TUserData>(Action<T, TUserData> onReceive) where T : INetSerializable, new()
+        {
+            T reference = new();
+            _callbacks[GetHash<T>()] = (reader, userData) =>
+            {
+                reference.Deserialize(reader);
+                onReceive(reference, (TUserData)userData);
+            };
+        }
+
+        public void SubscribeNetSerializable<T>(Action<T> onReceive) where T : INetSerializable, new()
+        {
+            T reference = new();
+            _callbacks[GetHash<T>()] = (reader, userData) =>
+            {
+                reference.Deserialize(reader);
+                onReceive(reference);
+            };
+        }
+
+        /// <summary>
+        /// Remove any subscriptions by type
+        /// </summary>
+        /// <typeparam name = "T">Packet type</typeparam>
+        /// <returns>true if remove is success</returns>
+        public bool RemoveSubscription<T>()
+        {
+            return _callbacks.Remove(GetHash<T>());
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NetPacketProcessor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: f0d5a653362556943a36db010a601057
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NetPacketProcessor.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NetSerializer.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 503136cdfd845ea439d6eb1e7fcfa924
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NetSerializer.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NtpPacket.cs

@@ -0,0 +1,406 @@
+using System;
+
+namespace LiteNetLib.Utils
+{
+    /// <summary>
+    /// Represents RFC4330 SNTP packet used for communication to and from a network time server.
+    /// </summary>
+    /// <remarks>
+    ///     <para>
+    ///     Most applications should just use the <see cref = "NtpPacket.CorrectionOffset"/> property.
+    ///     </para>
+    ///     <para>
+    ///     The same data structure represents both request and reply packets.
+    ///     Request and reply differ in which properties are set and to what values.
+    ///     </para>
+    ///     <para>
+    ///     The only real property is <see cref = "NtpPacket.Bytes"/>.
+    ///     All other properties read from and write to the underlying byte array
+    ///     with the exception of <see cref = "NtpPacket.DestinationTimestamp"/>,
+    ///     which is not part of the packet on network and it is instead set locally after receiving the packet.
+    ///     </para>
+    ///     <para>
+    ///     Copied from <a href = "https://guerrillantp.machinezoo.com/">GuerrillaNtp project</a>
+    ///     with permission from Robert Vazan (@robertvazan) under MIT license, see https://github.com/RevenantX/LiteNetLib/pull/236
+    ///     </para>
+    /// </remarks>
+    public class NtpPacket
+    {
+        private static readonly DateTime Epoch = new(1900, 1, 1);
+        /// <summary>
+        /// Gets RFC4330-encoded SNTP packet.
+        /// </summary>
+        /// <value>
+        /// Byte array containing RFC4330-encoded SNTP packet. It is at least 48 bytes long.
+        /// </value>
+        /// <remarks>
+        /// This is the only real property. All other properties except
+        /// <see cref = "NtpPacket.DestinationTimestamp"/> read from or write to this byte array.
+        /// </remarks>
+        public byte[] Bytes { get; }
+        /// <summary>
+        /// Gets the leap second indicator.
+        /// </summary>
+        /// <value>
+        /// Leap second warning, if any. Special value
+        /// <see cref = "NtpLeapIndicator.AlarmCondition"/> indicates unsynchronized server clock.
+        /// Default is <see cref = "NtpLeapIndicator.NoWarning"/>.
+        /// </value>
+        /// <remarks>
+        /// Only servers fill in this property. Clients can consult this property for possible leap second warning.
+        /// </remarks>
+        public NtpLeapIndicator LeapIndicator => (NtpLeapIndicator)((Bytes[0] & 0xC0) >> 6);
+        /// <summary>
+        /// Gets or sets protocol version number.
+        /// </summary>
+        /// <value>
+        /// SNTP protocol version. Default is 4, which is the latest version at the time of this writing.
+        /// </value>
+        /// <remarks>
+        /// In request packets, clients should leave this property at default value 4.
+        /// Servers usually reply with the same protocol version.
+        /// </remarks>
+        public int VersionNumber
+        {
+            get => (Bytes[0] & 0x38) >> 3;
+            private set => Bytes[0] = (byte)((Bytes[0] & ~0x38) | (value << 3));
+        }
+        /// <summary>
+        /// Gets or sets SNTP packet mode, i.e. whether this is client or server packet.
+        /// </summary>
+        /// <value>
+        /// SNTP packet mode. Default is <see cref = "NtpMode.Client"/> in newly created packets.
+        /// Server reply should have this property set to <see cref = "NtpMode.Server"/>.
+        /// </value>
+        public NtpMode Mode
+        {
+            get => (NtpMode)(Bytes[0] & 0x07);
+            private set => Bytes[0] = (byte)((Bytes[0] & ~0x07) | (int)value);
+        }
+        /// <summary>
+        /// Gets server's distance from the reference clock.
+        /// </summary>
+        /// <value>
+        ///     <para>
+        ///     Distance from the reference clock. This property is set only in server reply packets.
+        ///     Servers connected directly to reference clock hardware set this property to 1.
+        ///     Statum number is incremented by 1 on every hop down the NTP server hierarchy.
+        ///     </para>
+        ///     <para>
+        ///     Special value 0 indicates that this packet is a Kiss-o'-Death message
+        ///     with kiss code stored in <see cref = "NtpPacket.ReferenceId"/>.
+        ///     </para>
+        /// </value>
+        public int Stratum => Bytes[1];
+        /// <summary>
+        /// Gets server's preferred polling interval.
+        /// </summary>
+        /// <value>
+        /// Polling interval in log2 seconds, e.g. 4 stands for 16s and 17 means 131,072s.
+        /// </value>
+        public int Poll => Bytes[2];
+        /// <summary>
+        /// Gets the precision of server clock.
+        /// </summary>
+        /// <value>
+        /// Clock precision in log2 seconds, e.g. -20 for microsecond precision.
+        /// </value>
+        public int Precision => (sbyte)Bytes[3];
+        /// <summary>
+        /// Gets the total round-trip delay from the server to the reference clock.
+        /// </summary>
+        /// <value>
+        /// Round-trip delay to the reference clock. Normally a positive value smaller than one second.
+        /// </value>
+        public TimeSpan RootDelay => GetTimeSpan32(4);
+        /// <summary>
+        /// Gets the estimated error in time reported by the server.
+        /// </summary>
+        /// <value>
+        /// Estimated error in time reported by the server. Normally a positive value smaller than one second.
+        /// </value>
+        public TimeSpan RootDispersion => GetTimeSpan32(8);
+        /// <summary>
+        /// Gets the ID of the time source used by the server or Kiss-o'-Death code sent by the server.
+        /// </summary>
+        /// <value>
+        ///     <para>
+        ///     ID of server's time source or Kiss-o'-Death code.
+        ///     Purpose of this property depends on value of <see cref = "NtpPacket.Stratum"/> property.
+        ///     </para>
+        ///     <para>
+        ///     Stratum 1 servers write here one of several special values that describe the kind of hardware clock they use.
+        ///     </para>
+        ///     <para>
+        ///     Stratum 2 and lower servers set this property to IPv4 address of their upstream server.
+        ///     If upstream server has IPv6 address, the address is hashed, because it doesn't fit in this property.
+        ///     </para>
+        ///     <para>
+        ///     When server sets <see cref = "NtpPacket.Stratum"/> to special value 0,
+        ///     this property contains so called kiss code that instructs the client to stop querying the server.
+        ///     </para>
+        /// </value>
+        public uint ReferenceId => GetUInt32BE(12);
+        /// <summary>
+        /// Gets or sets the time when the server clock was last set or corrected.
+        /// </summary>
+        /// <value>
+        /// Time when the server clock was last set or corrected or <c>null</c> when not specified.
+        /// </value>
+        /// <remarks>
+        /// This Property is usually set only by servers. It usually lags server's current time by several minutes,
+        /// so don't use this property for time synchronization.
+        /// </remarks>
+        public DateTime? ReferenceTimestamp => GetDateTime64(16);
+        /// <summary>
+        /// Gets or sets the time when the client sent its request.
+        /// </summary>
+        /// <value>
+        /// This property is <c>null</c> in request packets.
+        /// In reply packets, it is the time when the client sent its request.
+        /// Servers copy this value from <see cref = "NtpPacket.TransmitTimestamp"/>
+        /// that they find in received request packet.
+        /// </value>
+        /// <seealso cref = "NtpPacket.CorrectionOffset"/>
+        /// <seealso cref = "NtpPacket.RoundTripTime"/>
+        public DateTime? OriginTimestamp => GetDateTime64(24);
+        /// <summary>
+        /// Gets or sets the time when the request was received by the server.
+        /// </summary>
+        /// <value>
+        /// This property is <c>null</c> in request packets.
+        /// In reply packets, it is the time when the server received client request.
+        /// </value>
+        /// <seealso cref = "NtpPacket.CorrectionOffset"/>
+        /// <seealso cref = "NtpPacket.RoundTripTime"/>
+        public DateTime? ReceiveTimestamp => GetDateTime64(32);
+        /// <summary>
+        /// Gets or sets the time when the packet was sent.
+        /// </summary>
+        /// <value>
+        /// Time when the packet was sent. It should never be <c>null</c>.
+        /// Default value is <see cref = "System.DateTime.UtcNow"/>.
+        /// </value>
+        /// <remarks>
+        /// This property must be set by both clients and servers.
+        /// </remarks>
+        /// <seealso cref = "NtpPacket.CorrectionOffset"/>
+        /// <seealso cref = "NtpPacket.RoundTripTime"/>
+        public DateTime? TransmitTimestamp
+        {
+            get { return GetDateTime64(40); }
+            private set { SetDateTime64(40, value); }
+        }
+        /// <summary>
+        /// Gets or sets the time of reception of response SNTP packet on the client.
+        /// </summary>
+        /// <value>
+        /// Time of reception of response SNTP packet on the client. It is <c>null</c> in request packets.
+        /// </value>
+        /// <remarks>
+        /// This property is not part of the protocol and has to be set when reply packet is received.
+        /// </remarks>
+        /// <seealso cref = "NtpPacket.CorrectionOffset"/>
+        /// <seealso cref = "NtpPacket.RoundTripTime"/>
+        public DateTime? DestinationTimestamp { get; private set; }
+        /// <summary>
+        /// Gets the round-trip time to the server.
+        /// </summary>
+        /// <value>
+        /// Time the request spent traveling to the server plus the time the reply spent traveling back.
+        /// This is calculated from timestamps in the packet as <c>(t1 - t0) + (t3 - t2)</c>
+        /// where t0 is <see cref = "NtpPacket.OriginTimestamp"/>,
+        /// t1 is <see cref = "NtpPacket.ReceiveTimestamp"/>,
+        /// t2 is <see cref = "NtpPacket.TransmitTimestamp"/>,
+        /// and t3 is <see cref = "NtpPacket.DestinationTimestamp"/>.
+        /// This property throws an exception in request packets.
+        /// </value>
+        public TimeSpan RoundTripTime
+        {
+            get
+            {
+                CheckTimestamps();
+                return ReceiveTimestamp.Value - OriginTimestamp.Value + (DestinationTimestamp.Value - TransmitTimestamp.Value);
+            }
+        }
+        /// <summary>
+        /// Gets the offset that should be added to local time to synchronize it with server time.
+        /// </summary>
+        /// <value>
+        /// Time difference between server and client. It should be added to local time to get server time.
+        /// It is calculated from timestamps in the packet as <c>0.5 * ((t1 - t0) - (t3 - t2))</c>
+        /// where t0 is <see cref = "NtpPacket.OriginTimestamp"/>,
+        /// t1 is <see cref = "NtpPacket.ReceiveTimestamp"/>,
+        /// t2 is <see cref = "NtpPacket.TransmitTimestamp"/>,
+        /// and t3 is <see cref = "NtpPacket.DestinationTimestamp"/>.
+        /// This property throws an exception in request packets.
+        /// </value>
+        public TimeSpan CorrectionOffset
+        {
+            get
+            {
+                CheckTimestamps();
+                return TimeSpan.FromTicks((ReceiveTimestamp.Value - OriginTimestamp.Value - (DestinationTimestamp.Value - TransmitTimestamp.Value)).Ticks / 2);
+            }
+        }
+
+        /// <summary>
+        /// Initializes default request packet.
+        /// </summary>
+        /// <remarks>
+        /// Properties <see cref = "NtpPacket.Mode"/> and <see cref = "NtpPacket.VersionNumber"/>
+        /// are set appropriately for request packet. Property <see cref = "NtpPacket.TransmitTimestamp"/>
+        /// is set to <see cref = "System.DateTime.UtcNow"/>.
+        /// </remarks>
+        public NtpPacket() : this(new byte[48])
+        {
+            Mode = NtpMode.Client;
+            VersionNumber = 4;
+            TransmitTimestamp = DateTime.UtcNow;
+        }
+
+        /// <summary>
+        /// Initializes packet from received data.
+        /// </summary>
+        internal NtpPacket(byte[] bytes)
+        {
+            if (bytes.Length < 48)
+                throw new ArgumentException("SNTP reply packet must be at least 48 bytes long.", "bytes");
+            Bytes = bytes;
+        }
+
+        /// <summary>
+        /// Initializes packet from data received from a server.
+        /// </summary>
+        /// <param name = "bytes">Data received from the server.</param>
+        /// <param name = "destinationTimestamp">Utc time of reception of response SNTP packet on the client.</param>
+        /// <returns></returns>
+        public static NtpPacket FromServerResponse(byte[] bytes, DateTime destinationTimestamp)
+        {
+            return new(bytes) { DestinationTimestamp = destinationTimestamp };
+        }
+
+        internal void ValidateRequest()
+        {
+            if (Mode != NtpMode.Client)
+                throw new InvalidOperationException("This is not a request SNTP packet.");
+            if (VersionNumber == 0)
+                throw new InvalidOperationException("Protocol version of the request is not specified.");
+            if (TransmitTimestamp == null)
+                throw new InvalidOperationException("TransmitTimestamp must be set in request packet.");
+        }
+
+        internal void ValidateReply()
+        {
+            if (Mode != NtpMode.Server)
+                throw new InvalidOperationException("This is not a reply SNTP packet.");
+            if (VersionNumber == 0)
+                throw new InvalidOperationException("Protocol version of the reply is not specified.");
+            if (Stratum == 0)
+                throw new InvalidOperationException(string.Format("Received Kiss-o'-Death SNTP packet with code 0x{0:x}.", ReferenceId));
+            if (LeapIndicator == NtpLeapIndicator.AlarmCondition)
+                throw new InvalidOperationException("SNTP server has unsynchronized clock.");
+            CheckTimestamps();
+        }
+
+        private void CheckTimestamps()
+        {
+            if (OriginTimestamp == null)
+                throw new InvalidOperationException("Origin timestamp is missing.");
+            if (ReceiveTimestamp == null)
+                throw new InvalidOperationException("Receive timestamp is missing.");
+            if (TransmitTimestamp == null)
+                throw new InvalidOperationException("Transmit timestamp is missing.");
+            if (DestinationTimestamp == null)
+                throw new InvalidOperationException("Destination timestamp is missing.");
+        }
+
+        private DateTime? GetDateTime64(int offset)
+        {
+            ulong field = GetUInt64BE(offset);
+            if (field == 0)
+                return null;
+            return new DateTime(Epoch.Ticks + Convert.ToInt64(field * (1.0 / (1L << 32) * 10000000.0)));
+        }
+
+        private void SetDateTime64(int offset, DateTime? value)
+        {
+            SetUInt64BE(offset, value == null ? 0 : Convert.ToUInt64((value.Value.Ticks - Epoch.Ticks) * (0.0000001 * (1L << 32))));
+        }
+
+        private TimeSpan GetTimeSpan32(int offset)
+        {
+            return TimeSpan.FromSeconds(GetInt32BE(offset) / (double)(1 << 16));
+        }
+
+        private ulong GetUInt64BE(int offset)
+        {
+            return SwapEndianness(BitConverter.ToUInt64(Bytes, offset));
+        }
+
+        private void SetUInt64BE(int offset, ulong value)
+        {
+            FastBitConverter.GetBytes(Bytes, offset, SwapEndianness(value));
+        }
+
+        private int GetInt32BE(int offset)
+        {
+            return (int)GetUInt32BE(offset);
+        }
+
+        private uint GetUInt32BE(int offset)
+        {
+            return SwapEndianness(BitConverter.ToUInt32(Bytes, offset));
+        }
+
+        private static uint SwapEndianness(uint x)
+        {
+            return ((x & 0xff) << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | ((x & 0xff000000) >> 24);
+        }
+
+        private static ulong SwapEndianness(ulong x)
+        {
+            return ((ulong)SwapEndianness((uint)x) << 32) | SwapEndianness((uint)(x >> 32));
+        }
+    }
+
+    /// <summary>
+    /// Represents leap second warning from the server that instructs the client to add or remove leap second.
+    /// </summary>
+    /// <seealso cref = "NtpPacket.LeapIndicator"/>
+    public enum NtpLeapIndicator
+    {
+        /// <summary>
+        /// No leap second warning. No action required.
+        /// </summary>
+        NoWarning,
+        /// <summary>
+        /// Warns the client that the last minute of the current day has 61 seconds.
+        /// </summary>
+        LastMinuteHas61Seconds,
+        /// <summary>
+        /// Warns the client that the last minute of the current day has 59 seconds.
+        /// </summary>
+        LastMinuteHas59Seconds,
+        /// <summary>
+        /// Special value indicating that the server clock is unsynchronized and the returned time is unreliable.
+        /// </summary>
+        AlarmCondition
+    }
+
+    /// <summary>
+    /// Describes SNTP packet mode, i.e. client or server.
+    /// </summary>
+    /// <seealso cref = "NtpPacket.Mode"/>
+    public enum NtpMode
+    {
+        /// <summary>
+        /// Identifies client-to-server SNTP packet.
+        /// </summary>
+        Client = 3,
+        /// <summary>
+        /// Identifies server-to-client SNTP packet.
+        /// </summary>
+        Server = 4
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NtpPacket.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: daf31cf4ab8132943b2c8ca301fc919a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NtpPacket.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NtpRequest.cs

@@ -0,0 +1,42 @@
+using System.Net;
+using System.Net.Sockets;
+
+namespace LiteNetLib.Utils
+{
+    internal sealed class NtpRequest
+    {
+        private const int ResendTimer = 1000;
+        private const int KillTimer = 10000;
+        public const int DefaultPort = 123;
+        private readonly IPEndPoint _ntpEndPoint;
+        private int _resendTime = ResendTimer;
+        private int _killTime = 0;
+
+        public NtpRequest(IPEndPoint endPoint)
+        {
+            _ntpEndPoint = endPoint;
+        }
+
+        public bool NeedToKill => _killTime >= KillTimer;
+
+        public bool Send(Socket socket, int time)
+        {
+            _resendTime += time;
+            _killTime += time;
+            if (_resendTime < ResendTimer)
+            {
+                return false;
+            }
+            NtpPacket packet = new();
+            try
+            {
+                int sendCount = socket.SendTo(packet.Bytes, 0, packet.Bytes.Length, SocketFlags.None, _ntpEndPoint);
+                return sendCount == packet.Bytes.Length;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NtpRequest.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: c3fa3bfbb02dd944e939070e3cf0638c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/NtpRequest.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/Preserve.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace LiteNetLib.Utils
+{
+    /// <summary>
+    ///     <para>PreserveAttribute prevents byte code stripping from removing a class, method, field, or property.</para>
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
+    public class PreserveAttribute : Attribute { }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/Preserve.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: c1036adeea398ef48b307b909966d955
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/Utils/Preserve.cs
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/package.json

@@ -0,0 +1,11 @@
+{
+    "name": "com.revenantx.litenetlib",
+    "version": "1.0.1-1",
+    "displayName": "LiteNetLib",
+    "description": "Lite reliable UDP library for .NET Standard 2.0 (Mono, .NET Core, .NET Framework)",
+    "unity": "2018.3",
+    "author": {
+        "name": "RevenantX",
+        "url": "https://github.com/RevenantX"
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/package.json.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: f46cc664b3dd2944a8b04542ecb07732
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/LiteNetLib/package.json
+  uploadId: 866910

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Tugboat.cs

@@ -0,0 +1,611 @@
+using FishNet.Managing;
+using FishNet.Managing.Transporting;
+using LiteNetLib.Layers;
+using System;
+using System.Runtime.CompilerServices;
+using LiteNetLib;
+using UnityEngine;
+
+namespace FishNet.Transporting.Tugboat
+{
+    [DisallowMultipleComponent]
+    [AddComponentMenu("FishNet/Transport/Tugboat")]
+    public class Tugboat : Transport
+    {
+        ~Tugboat()
+        {
+            Shutdown();
+        }
+
+        #region Serialized.
+        /* Settings / Misc. */
+        /// <summary>
+        /// True to stop local server and client sockets using a new thread.
+        /// </summary>
+        internal bool StopSocketsOnThread => _stopSocketsOnThread;
+        [Tooltip("True to stop local server and client sockets using a new thread.")]
+        [SerializeField]
+        private bool _stopSocketsOnThread = false;
+        /// <summary>
+        /// While true, forces sockets to send data directly to interface without routing.
+        /// </summary>
+        internal bool DontRoute => _dontRoute;
+        [Tooltip("While true, forces sockets to send data directly to interface without routing.")]
+        [SerializeField]
+        private bool _dontRoute;
+        /// <summary>
+        /// Allows the same address and port to be used multiple times by the server. This can be useful if you wish to launch multiple builds or server instances on the same machine using the same configuration.
+        /// </summary>
+        internal bool ReuseAddress => _reuseAddress;
+        [Tooltip("Allows the same address and port to be used multiple times by the server. This can be useful if you wish to launch multiple builds or server instances on the same machine using the same configuration.")]
+        [SerializeField]
+        private bool _reuseAddress;
+        /* Channels. */
+        /// <summary>
+        /// Maximum transmission unit for the unreliable channel.
+        /// </summary>
+        [Tooltip("Maximum transmission unit for the unreliable channel.")]
+        [Range(MINIMUM_UDP_MTU, MAXIMUM_UDP_MTU)]
+        [SerializeField]
+        private int _unreliableMtu = 1023;
+        /* Server. */
+        /// <summary>
+        /// IPv4 address to bind server to.
+        /// </summary>
+        [Tooltip("IPv4 Address to bind server to.")]
+        [SerializeField]
+        private string _ipv4BindAddress;
+        /// <summary>
+        /// Enable IPv6 only on demand to avoid problems in Linux environments where it may have been disabled on host
+        /// </summary>
+        [Tooltip("Enable IPv6, Server listens on IPv4 and IPv6 address")]
+        [SerializeField]
+        private bool _enableIpv6 = true;
+        /// <summary>
+        /// IPv6 address to bind server to.
+        /// </summary>
+        [Tooltip("IPv6 Address to bind server to.")]
+        [SerializeField]
+        private string _ipv6BindAddress;
+        /// <summary>
+        /// Port to use.
+        /// </summary>
+        [Tooltip("Port to use.")]
+        [SerializeField]
+        private ushort _port = 7770;
+        /// <summary>
+        /// Maximum number of players which may be connected at once.
+        /// </summary>
+        [Tooltip("Maximum number of players which may be connected at once.")]
+        [Range(1, 9999)]
+        [SerializeField]
+        private int _maximumClients = 4095;
+        /* Client. */
+        /// <summary>
+        /// Address to connect.
+        /// </summary>
+        [Tooltip("Address to connect.")]
+        [SerializeField]
+        private string _clientAddress = "localhost";
+        #endregion
+
+        #region Private.
+        /// <summary>
+        /// PacketLayer to use with LiteNetLib.
+        /// </summary>
+        private PacketLayerBase _packetLayer;
+        /// <summary>
+        /// Server socket and handler. This field is exposed for advanced-use. Use caution when accessing this outside of this class.
+        /// </summary>
+        public Server.ServerSocket ServerSocket = new();
+        /// <summary>
+        /// Client socket and handler. This field is exposed for advanced-use. Use caution when accessing this outside of this class.
+        /// </summary>
+        public Client.ClientSocket ClientSocket = new();
+        /// <summary>
+        /// Current timeout for the client.
+        /// </summary>
+        private int _clientTimeout = MAX_TIMEOUT_SECONDS;
+        /// <summary>
+        /// Current timeout for the server.
+        /// </summary>
+        private int _serverTimeout = MAX_TIMEOUT_SECONDS;
+        #endregion
+
+        #region Const.
+        /// <summary>
+        /// Maximum timeout value to use.
+        /// </summary>
+        private const ushort MAX_TIMEOUT_SECONDS = 1800;
+        /// <summary>
+        /// Minimum UDP packet size allowed.
+        /// </summary>
+        private const int MINIMUM_UDP_MTU = 576;
+        /// <summary>
+        /// Maximum UDP packet size allowed.
+        /// </summary>
+        private const int MAXIMUM_UDP_MTU = 1023;
+        #endregion
+
+        #region Initialization and unity.
+        public override void Initialize(NetworkManager networkManager, int transportIndex)
+        {
+            base.Initialize(networkManager, transportIndex);
+            networkManager.TimeManager.OnUpdate += TimeManager_OnUpdate;
+        }
+
+        protected void OnDestroy()
+        {
+            Shutdown();
+            if (NetworkManager != null)
+                NetworkManager.TimeManager.OnUpdate -= TimeManager_OnUpdate;
+        }
+        #endregion
+
+        #region ConnectionStates.
+        /// <summary>
+        /// Gets the address of a remote connection Id.
+        /// </summary>
+        /// <param name = "connectionId"></param>
+        /// <returns></returns>
+        public override string GetConnectionAddress(int connectionId)
+        {
+            return ServerSocket.GetConnectionAddress(connectionId);
+        }
+
+        /// <summary>
+        /// Called when a connection state changes for the local client.
+        /// </summary>
+        public override event Action<ClientConnectionStateArgs> OnClientConnectionState;
+        /// <summary>
+        /// Called when a connection state changes for the local server.
+        /// </summary>
+        public override event Action<ServerConnectionStateArgs> OnServerConnectionState;
+        /// <summary>
+        /// Called when a connection state changes for a remote client.
+        /// </summary>
+        public override event Action<RemoteConnectionStateArgs> OnRemoteConnectionState;
+
+        /// <summary>
+        /// Gets the current local ConnectionState.
+        /// </summary>
+        /// <param name = "server">True if getting ConnectionState for the server.</param>
+        public override LocalConnectionState GetConnectionState(bool server)
+        {
+            if (server)
+                return ServerSocket.GetConnectionState();
+            else
+                return ClientSocket.GetConnectionState();
+        }
+
+        /// <summary>
+        /// Gets the current ConnectionState of a remote client on the server.
+        /// </summary>
+        /// <param name = "connectionId">ConnectionId to get ConnectionState for.</param>
+        public override RemoteConnectionState GetConnectionState(int connectionId)
+        {
+            return ServerSocket.GetConnectionState(connectionId);
+        }
+
+        /// <summary>
+        /// Handles a ConnectionStateArgs for the local client.
+        /// </summary>
+        /// <param name = "connectionStateArgs"></param>
+        public override void HandleClientConnectionState(ClientConnectionStateArgs connectionStateArgs)
+        {
+            OnClientConnectionState?.Invoke(connectionStateArgs);
+        }
+
+        /// <summary>
+        /// Handles a ConnectionStateArgs for the local server.
+        /// </summary>
+        /// <param name = "connectionStateArgs"></param>
+        public override void HandleServerConnectionState(ServerConnectionStateArgs connectionStateArgs)
+        {
+            OnServerConnectionState?.Invoke(connectionStateArgs);
+        }
+
+        /// <summary>
+        /// Handles a ConnectionStateArgs for a remote client.
+        /// </summary>
+        /// <param name = "connectionStateArgs"></param>
+        public override void HandleRemoteConnectionState(RemoteConnectionStateArgs connectionStateArgs)
+        {
+            OnRemoteConnectionState?.Invoke(connectionStateArgs);
+        }
+        #endregion
+
+        #region Iterating.
+        /// <summary>
+        /// Called every update to poll for data.
+        /// </summary>
+        private void TimeManager_OnUpdate()
+        {
+            ServerSocket?.PollSocket();
+            ClientSocket?.PollSocket();
+        }
+
+        /// <summary>
+        /// Processes data received by the socket.
+        /// </summary>
+        /// <param name = "asServer">True to read data from clients, false to read data from the server.
+        public override void IterateIncoming(bool asServer)
+        {
+            if (asServer)
+                ServerSocket.IterateIncoming();
+            else
+                ClientSocket.IterateIncoming();
+        }
+
+        /// <summary>
+        /// Processes data to be sent by the socket.
+        /// </summary>
+        /// <param name = "asServer">True to send data from the local server to clients, false to send from the local client to server.
+        public override void IterateOutgoing(bool asServer)
+        {
+            if (asServer)
+                ServerSocket.IterateOutgoing();
+            else
+                ClientSocket.IterateOutgoing();
+        }
+        #endregion
+
+        #region Sending.
+        /// <summary>
+        /// Sends to the server or all clients.
+        /// </summary>
+        /// <param name = "channelId">Channel to use.</param>
+        /// <param name = "segment">Data to send.</param>
+        public override void SendToServer(byte channelId, ArraySegment<byte> segment)
+        {
+            SanitizeChannel(ref channelId);
+            ClientSocket.SendToServer(channelId, segment);
+        }
+
+        /// <summary>
+        /// Sends data to a client.
+        /// </summary>
+        /// <param name = "channelId"></param>
+        /// <param name = "segment"></param>
+        /// <param name = "connectionId"></param>
+        public override void SendToClient(byte channelId, ArraySegment<byte> segment, int connectionId)
+        {
+            SanitizeChannel(ref channelId);
+            ServerSocket.SendToClient(channelId, segment, connectionId);
+        }
+        #endregion
+
+        #region Receiving.
+        /// <summary>
+        /// Called when client receives data.
+        /// </summary>
+        public override event Action<ClientReceivedDataArgs> OnClientReceivedData;
+
+        /// <summary>
+        /// Handles a ClientReceivedDataArgs.
+        /// </summary>
+        /// <param name = "receivedDataArgs"></param>
+        public override void HandleClientReceivedDataArgs(ClientReceivedDataArgs receivedDataArgs)
+        {
+            OnClientReceivedData?.Invoke(receivedDataArgs);
+        }
+
+        /// <summary>
+        /// Called when server receives data.
+        /// </summary>
+        public override event Action<ServerReceivedDataArgs> OnServerReceivedData;
+
+        /// <summary>
+        /// Handles a ClientReceivedDataArgs.
+        /// </summary>
+        /// <param name = "receivedDataArgs"></param>
+        public override void HandleServerReceivedDataArgs(ServerReceivedDataArgs receivedDataArgs)
+        {
+            OnServerReceivedData?.Invoke(receivedDataArgs);
+        }
+
+        /// <summary>
+        /// Returns packet loss percentage. This transport supports this feature.
+        /// </summary>
+        /// <param name = "asServer">True to return packet loss on the server, false to return packet loss on the client.</param>
+        public override float GetPacketLoss(bool asServer)
+        {
+            NetManager nm;
+            if (asServer && ServerSocket != null)
+                nm = ServerSocket.NetManager;
+            else if (!asServer && ClientSocket != null)
+                nm = ClientSocket.NetManager;
+            else
+                nm = null;
+
+            if (nm == null)
+                return 0f;
+
+            return nm.Statistics.PacketLossPercent;
+        }
+        #endregion
+
+        #region Configuration.
+        /// <summary>
+        /// Sets which PacketLayer to use with LiteNetLib.
+        /// </summary>
+        /// <param name = "packetLayer"></param>
+        public void SetPacketLayer(PacketLayerBase packetLayer)
+        {
+            _packetLayer = packetLayer;
+            if (GetConnectionState(true) != LocalConnectionState.Stopped)
+                NetworkManager.LogWarning("PacketLayer is set but will not be applied until the server stops.");
+            if (GetConnectionState(false) != LocalConnectionState.Stopped)
+                NetworkManager.LogWarning("PacketLayer is set but will not be applied until the client stops.");
+
+            InitializeSocket(asServer: true);
+            InitializeSocket(asServer: false);
+        }
+
+        /// <summary>
+        /// How long in seconds until either the server or client socket must go without data before being timed out.
+        /// </summary>
+        /// <param name = "asServer">True to get the timeout for the server socket, false for the client socket.</param>
+        /// <returns></returns>
+        public override float GetTimeout(bool asServer)
+        {
+            // Server and client uses the same timeout.
+            return (float)MAX_TIMEOUT_SECONDS;
+        }
+
+        /// <summary>
+        /// Sets how long in seconds until either the server or client socket must go without data before being timed out.
+        /// </summary>
+        /// <param name = "asServer">True to set the timeout for the server socket, false for the client socket.</param>
+        public override void SetTimeout(float value, bool asServer)
+        {
+            int timeoutValue = (int)Math.Ceiling(value);
+            if (asServer)
+                _serverTimeout = timeoutValue;
+            else
+                _clientTimeout = timeoutValue;
+
+            UpdateTimeout();
+        }
+
+        /// <summary>
+        /// Returns the maximum number of clients allowed to connect to the server. If the transport does not support this method the value -1 is returned.
+        /// </summary>
+        /// <returns></returns>
+        public override int GetMaximumClients()
+        {
+            return ServerSocket.GetMaximumClients();
+        }
+
+        /// <summary>
+        /// Sets maximum number of clients allowed to connect to the server. If applied at runtime and clients exceed this value existing clients will stay connected but new clients may not connect.
+        /// </summary>
+        /// <param name = "value"></param>
+        public override void SetMaximumClients(int value)
+        {
+            _maximumClients = value;
+            ServerSocket.SetMaximumClients(value);
+        }
+
+        /// <summary>
+        /// Sets which address the client will connect to.
+        /// </summary>
+        /// <param name = "address"></param>
+        public override void SetClientAddress(string address)
+        {
+            _clientAddress = address;
+        }
+
+        /// <summary>
+        /// Gets which address the client will connect to.
+        /// </summary>
+        public override string GetClientAddress()
+        {
+            return _clientAddress;
+        }
+
+        /// <summary>
+        /// Sets which address the server will bind to.
+        /// </summary>
+        /// <param name = "address"></param>
+        public override void SetServerBindAddress(string address, IPAddressType addressType)
+        {
+            if (addressType == IPAddressType.IPv4)
+                _ipv4BindAddress = address;
+            else
+                _ipv6BindAddress = address;
+        }
+
+        /// <summary>
+        /// Gets which address the server will bind to.
+        /// </summary>
+        /// <param name = "address"></param>
+        public override string GetServerBindAddress(IPAddressType addressType)
+        {
+            if (addressType == IPAddressType.IPv4)
+                return _ipv4BindAddress;
+            else
+                return _ipv6BindAddress;
+        }
+
+        /// <summary>
+        /// Sets which port to use.
+        /// </summary>
+        /// <param name = "port"></param>
+        public override void SetPort(ushort port)
+        {
+            _port = port;
+        }
+
+        /// <summary>
+        /// Gets which port to use.
+        /// </summary>
+        /// <param name = "port"></param>
+        public override ushort GetPort()
+        {
+            // Server.
+            ushort? result = ServerSocket?.GetPort();
+            if (result.HasValue)
+                return result.Value;
+            // Client.
+            result = ClientSocket?.GetPort();
+            if (result.HasValue)
+                return result.Value;
+
+            return _port;
+        }
+        #endregion
+
+        #region Start and stop.
+        /// <summary>
+        /// Starts the local server or client using configured settings.
+        /// </summary>
+        /// <param name = "server">True to start server.</param>
+        public override bool StartConnection(bool server)
+        {
+            if (server)
+                return StartServer();
+            else
+                return StartClient(_clientAddress);
+        }
+
+        /// <summary>
+        /// Stops the local server or client.
+        /// </summary>
+        /// <param name = "server">True to stop server.</param>
+        public override bool StopConnection(bool server)
+        {
+            if (server)
+                return StopServer();
+            else
+                return StopClient();
+        }
+
+        /// <summary>
+        /// Stops a remote client from the server, disconnecting the client.
+        /// </summary>
+        /// <param name = "connectionId">ConnectionId of the client to disconnect.</param>
+        /// <param name = "immediately">
+        /// True to abrutly stop the client socket. The technique used to accomplish immediate disconnects may vary depending on the transport.
+        /// When not using immediate disconnects it's recommended to perform disconnects using the ServerManager rather than accessing the transport directly.
+        /// </param>
+        public override bool StopConnection(int connectionId, bool immediately)
+        {
+            return ServerSocket.StopConnection(connectionId);
+        }
+
+        /// <summary>
+        /// Stops both client and server.
+        /// </summary>
+        public override void Shutdown()
+        {
+            // Stops client then server connections.
+            StopConnection(false);
+            StopConnection(true);
+        }
+
+        #region Privates.
+        /// <summary>
+        /// Initializes client or server socket.
+        /// </summary>
+        private void InitializeSocket(bool asServer)
+        {
+            if (asServer)
+                ServerSocket.Initialize(this, _unreliableMtu, _packetLayer, _enableIpv6);
+            else
+                ClientSocket.Initialize(this, _unreliableMtu, _packetLayer);
+        }
+
+        /// <summary>
+        /// Starts server.
+        /// </summary>
+        private bool StartServer()
+        {
+            InitializeSocket(asServer: true);
+            UpdateTimeout();
+            return ServerSocket.StartConnection(_port, _maximumClients, _ipv4BindAddress, _ipv6BindAddress);
+        }
+
+        /// <summary>
+        /// Stops server.
+        /// </summary>
+        private bool StopServer()
+        {
+            if (ServerSocket == null)
+                return false;
+            else
+                return ServerSocket.StopConnection();
+        }
+
+        /// <summary>
+        /// Starts the client.
+        /// </summary>
+        /// <param name = "address"></param>
+        private bool StartClient(string address)
+        {
+            InitializeSocket(asServer: false);
+            UpdateTimeout();
+            return ClientSocket.StartConnection(address, _port);
+        }
+
+        /// <summary>
+        /// Updates clients timeout values.
+        /// </summary>
+        private void UpdateTimeout()
+        {
+            ClientSocket.UpdateTimeout(_clientTimeout);
+            ServerSocket.UpdateTimeout(_serverTimeout);
+        }
+
+        /// <summary>
+        /// Stops the client.
+        /// </summary>
+        private bool StopClient()
+        {
+            if (ClientSocket == null)
+                return false;
+            else
+                return ClientSocket.StopConnection();
+        }
+        #endregion
+        #endregion
+
+        #region Channels.
+        /// <summary>
+        /// If channelId is invalid then channelId becomes forced to reliable.
+        /// </summary>
+        /// <param name = "channelId"></param>
+        private void SanitizeChannel(ref byte channelId)
+        {
+            if (channelId < 0 || channelId >= TransportManager.CHANNEL_COUNT)
+            {
+                NetworkManager.LogWarning($"Channel of {channelId} is out of range of supported channels. Channel will be defaulted to reliable.");
+                channelId = 0;
+            }
+        }
+
+        /// <summary>
+        /// Gets the MTU for a channel. This should take header size into consideration.
+        /// For example, if MTU is 1200 and a packet header for this channel is 10 in size, this method should return 1190.
+        /// </summary>
+        /// <param name = "channel"></param>
+        /// <returns></returns>
+        public override int GetMTU(byte channel)
+        {
+            return _unreliableMtu;
+        }
+        #endregion
+
+        #region Editor.
+#if UNITY_EDITOR
+        private void OnValidate()
+        {
+            if (_unreliableMtu < 0)
+                _unreliableMtu = MINIMUM_UDP_MTU;
+            else if (_unreliableMtu > MAXIMUM_UDP_MTU)
+                _unreliableMtu = MAXIMUM_UDP_MTU;
+        }
+#endif
+        #endregion
+    }
+}

Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Tugboat.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 6f48f002b825cbd45a19bd96d90f9edb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: bf9191e2e07d29749bca3a1ae44e4bc8, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/Runtime/Transporting/Transports/Tugboat/Tugboat.cs
+  uploadId: 866910