public void Put(float value)
{
if (_autoResize)
{
ResizeIfNeed(_position + 4);
}
FastBitConverter.GetBytes(_data, _position, value);
_position += 4;
}
public static NetPacket Make(long connectId, byte connectNum, bool reusedPeer)
{
var packet = new NetPacket(PacketProperty.ConnectAccept, 0);
FastBitConverter.GetBytes(packet.RawData, 1, connectId);
packet.RawData[9] = connectNum;
packet.RawData[10] = (byte)(reusedPeer ? 1 : 0);
return(packet);
}
public void Put(short value)
{
if (_autoResize)
{
ResizeIfNeed(_position + 2);
}
FastBitConverter.GetBytes(_data, _position, value);
_position += 2;
}
public void Put(ulong value)
{
if (_autoResize)
{
ResizeIfNeed(_position + 8);
}
FastBitConverter.GetBytes(_data, _position, value);
_position += 8;
}
public static NetPacket MakeNetworkChanged(NetPeer peer)
{
var packet = new NetPacket(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);
}
private static byte[] GetTestPacketWithCrc()
{
byte[] testMsg = GetTestMessageBytes();
uint crc32 = CRC32C.Compute(testMsg, 0, testMsg.Length);
byte[] packet = new byte[testMsg.Length + CRC32C.ChecksumSize];
Buffer.BlockCopy(testMsg, 0, packet, 0, testMsg.Length);
FastBitConverter.GetBytes(packet, testMsg.Length, crc32);
return(packet);
}
public void PutBytesWithLength(byte[] data)
{
if (_autoResize)
{
ResizeIfNeed(_position + data.Length + 4);
}
FastBitConverter.GetBytes(_data, _position, data.Length);
Buffer.BlockCopy(data, 0, _data, _position + 4, data.Length);
_position += data.Length + 4;
}
public void PutBytesWithLength(byte[] data, int offset, int length)
{
if (_autoResize)
{
ResizeIfNeed(_position + length + 4);
}
FastBitConverter.GetBytes(_data, _position, length);
Buffer.BlockCopy(data, offset, _data, _position + 4, length);
_position += length + 4;
}
public static NetPacket Make(NetDataWriter connectData, long connectId)
{
//Make initial packet
var packet = new NetPacket(PacketProperty.ConnectRequest, connectData.Length);
//Add data
FastBitConverter.GetBytes(packet.RawData, 1, NetConstants.ProtocolId);
FastBitConverter.GetBytes(packet.RawData, 5, connectId);
Buffer.BlockCopy(connectData.Data, 0, packet.RawData, HeaderSize, connectData.Length);
return(packet);
}
public void OnSend(IMessageContext context, ref List <ArraySegment <byte> > lists, ArraySegment <byte> payload)
{
// 헤더 만들어 넣고
byte[] header = context.BufferManager.Take(SimpleBinaryMessageProtocol.HEADERSIZE);
FastBitConverter.GetBytes(payload.Count, header, 0);
lists.Add(new ArraySegment <byte>(header, 0, SimpleBinaryMessageProtocol.HEADERSIZE));
// payload 적재하고
byte[] copyPayload = context.BufferManager.Take(payload.Count);
Array.Copy(payload.Array, payload.Offset, copyPayload, 0, payload.Count);
lists.Add(new ArraySegment <byte>(copyPayload, 0, payload.Count));
}
private void SendConnectRequest()
{
//Make initial packet
var connectPacket = _packetPool.Get(PacketProperty.ConnectRequest, 12 + _connectData.Length);
//Add data
FastBitConverter.GetBytes(connectPacket.RawData, 1, NetConstants.ProtocolId);
FastBitConverter.GetBytes(connectPacket.RawData, 5, _connectId);
Buffer.BlockCopy(_connectData.Data, 0, connectPacket.RawData, 13, _connectData.Length);
//Send raw
_netManager.SendRawAndRecycle(connectPacket, _remoteEndPoint);
}
private void SendConnectAccept(NetPeer peer, ulong id)
{
//Reset connection timer
peer.StartConnectionTimer();
//Make initial packet
var connectPacket = NetPacket.CreateRawPacket(PacketProperty.ConnectAccept, 8);
//Add data
FastBitConverter.GetBytes(connectPacket, 1, id);
//Send raw
SendRaw(connectPacket, peer.EndPoint);
}
private void SendConnectAccept()
{
//Reset connection timer
_timeSinceLastPacket = 0;
//Make initial packet
var connectPacket = _packetPool.Get(PacketProperty.ConnectAccept, 0, sizeof(long)); // sizeof(_connectId)
//Add data
FastBitConverter.GetBytes(connectPacket.RawData, 0, _connectId);
//Send raw
_netManager.SendRawAndRecycle(connectPacket, _remoteEndPoint);
}
private void SendConnectAccept()
{
//Reset connection timer
_timeSinceLastPacket = 0;
//Make initial packet
var connectPacket = _packetPool.GetWithProperty(PacketProperty.ConnectAccept, 8);
//Add data
FastBitConverter.GetBytes(connectPacket.RawData, NetConstants.AcceptConnectIdIndex, _connectId);
//Send raw
_netManager.SendRawAndRecycle(connectPacket, _remoteEndPoint);
}
private void SendConnectAccept()
{
//Reset connection timer
_timeSinceLastPacket = 0;
//Make initial packet
var connectPacket = _packetPool.Get(PacketProperty.ConnectAccept, 8);
//Add data
FastBitConverter.GetBytes(connectPacket.RawData, 1, _connectId);
//Send raw
_peerListener.SendRawAndRecycle(connectPacket, _remoteEndPoint);
}
private void SendConnectAccept()
{
//Reset connection timer
_lastPacketReceivedStart = DateTime.UtcNow;
//Make initial packet
var connectPacket = NetPacket.CreateRawPacket(PacketProperty.ConnectAccept, 8);
//Add data
FastBitConverter.GetBytes(connectPacket, 1, _connectId);
//Send raw
_peerListener.SendRaw(connectPacket, _remoteEndPoint);
}
private void SendConnectRequest()
{
//Get connect key bytes
byte[] keyData = Encoding.UTF8.GetBytes(_connectKey);
//Make initial packet
var connectPacket = NetPacket.CreateRawPacket(PacketProperty.ConnectRequest, 8 + keyData.Length);
//Add data
FastBitConverter.GetBytes(connectPacket, 1, _connectId);
Buffer.BlockCopy(keyData, 0, connectPacket, 9, keyData.Length);
//Send raw
_peer.SendRawData(connectPacket);
}
private void CloseConnection(bool force)
{
if (_peer != null && !force)
{
//Send disconnect data
var disconnectPacket = NetPacket.CreateRawPacket(PacketProperty.Disconnect, 8);
FastBitConverter.GetBytes(disconnectPacket, 1, _connectId);
_peer.SendRawData(disconnectPacket);
}
_peer = null;
_connected = false;
_connectTimer = 0;
_connectAttempts = 0;
SocketClearPeers();
}
private void SendConnectRequest()
{
//Get connect key bytes
byte[] keyData = Encoding.UTF8.GetBytes(_peerListener.ConnectKey);
//Make initial packet
var connectPacket = _packetPool.Get(PacketProperty.ConnectRequest, 12 + keyData.Length);
//Add data
FastBitConverter.GetBytes(connectPacket.RawData, 1, NetConstants.ProtocolId);
FastBitConverter.GetBytes(connectPacket.RawData, 5, _connectId);
Buffer.BlockCopy(keyData, 0, connectPacket.RawData, 13, keyData.Length);
//Send raw
_peerListener.SendRawAndRecycle(connectPacket, _remoteEndPoint);
}
private 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 static NetPacket Make(NetDataWriter connectData, SocketAddress addressBytes, long connectId)
{
//Make initial packet
var packet = new NetPacket(PacketProperty.ConnectRequest, connectData.Length + addressBytes.Size);
//Add data
FastBitConverter.GetBytes(packet.RawData, 1, NetConstants.ProtocolId);
FastBitConverter.GetBytes(packet.RawData, 5, connectId);
packet.RawData[13] = (byte)addressBytes.Size;
for (int i = 0; i < addressBytes.Size; i++)
{
packet.RawData[14 + i] = addressBytes[i];
}
Buffer.BlockCopy(connectData.Data, 0, packet.RawData, 14 + addressBytes.Size, connectData.Length);
return(packet);
}
internal ShutdownResult Shutdown(byte[] data, int start, int length, bool force)
{
lock (_shutdownLock)
{
//trying to shutdown already disconnected
if (_connectionState == ConnectionState.Disconnected ||
_connectionState == ConnectionState.ShutdownRequested)
{
return(ShutdownResult.None);
}
var result = _connectionState == ConnectionState.Connected
? ShutdownResult.WasConnected
: ShutdownResult.Success;
//don't send anything
if (force)
{
_connectionState = ConnectionState.Disconnected;
return(result);
}
//reset time for reconnect protection
Interlocked.Exchange(ref _timeSinceLastPacket, 0);
//send shutdown packet
_shutdownPacket = new NetPacket(PacketProperty.Disconnect, length)
{
ConnectionNumber = _connectNum
};
FastBitConverter.GetBytes(_shutdownPacket.RawData, 1, _connectTime);
if (_shutdownPacket.Size >= _mtu)
{
//Drop additional data
NetDebug.WriteError("[Peer] Disconnect additional data size more than MTU - 8!");
}
else if (data != null && length > 0)
{
Buffer.BlockCopy(data, start, _shutdownPacket.RawData, 9, length);
}
_connectionState = ConnectionState.ShutdownRequested;
NetDebug.Write("[Peer] Send disconnect");
NetManager.SendRaw(_shutdownPacket, EndPoint);
return(result);
}
}
internal void SendShutdownPacket()
{
NetPacket _shutdownPacket = _packetPool.Get(PacketProperty.Disconnect, 0, sizeof(long) + _shutdownData.Length);
FastBitConverter.GetBytes(_shutdownPacket.RawData, 0, _connectId);
if (_shutdownData.Length + sizeof(long) >= _mtu)
{
//Drop additional data
NetUtils.DebugWriteError("[Peer] Disconnect additional data size more than MTU - 8!");
}
else if (_shutdownData != null && _shutdownData.Length > 0)
{
Buffer.BlockCopy(_shutdownData, 0, _shutdownPacket.RawData, sizeof(long), _shutdownData.Length);
}
_connectionState = ConnectionState.ShutdownRequested;
SendRawData(_shutdownPacket);
}
internal void FlushMergePacket()
{
//If merging enabled
if (_mergePos > 0)
{
if (_mergeCount > 1)
{
// build the mergeData
NetPacket _mergeData = _packetPool.Get(PacketProperty.Merged, 0, _mergePos);
_mergePos = 0;
_mergeCount = 0;
while (_mergedPackets.Empty == false)
{
_mergeCount++;
NetPacket packet = _mergedPackets.Dequeue();
FastBitConverter.GetBytes(_mergeData.RawData, _mergePos, (ushort)packet.Size);
Buffer.BlockCopy(packet.RawData, 0, _mergeData.RawData, _mergePos + sizeof(ushort), packet.Size);
_mergePos += packet.Size + sizeof(ushort);
packet.Recycle();
}
if (_mergeCount > 0)
{
NetUtils.DebugWrite("Send merged: " + _mergePos + ", count: " + _mergeCount);
_mergeData.Size = NetPacket.GetHeaderSize(PacketProperty.Merged) + _mergePos;
_mergeData.Property = PacketProperty.Merged;
_netManager.SendRawAndRecycle(_mergeData, _remoteEndPoint);
}
#if STATS_ENABLED
Statistics.PacketsSent++;
Statistics.BytesSent += (ulong)(NetConstants.HeaderSize + _mergePos);
#endif
}
else
{
NetPacket packet = _mergedPackets.Dequeue();
//Send without length information and merging
_netManager.SendRawAndRecycle(packet, _remoteEndPoint);
#if STATS_ENABLED
Statistics.PacketsSent++;
Statistics.BytesSent += (ulong)(_mergePos - 2);
#endif
}
_mergePos = 0;
_mergeCount = 0;
}
}
internal void SendRawData(byte[] data)
{
//2 - merge byte + minimal packet size + datalen(ushort)
if (_peerListener.MergeEnabled && _mergePos + data.Length + NetConstants.HeaderSize * 2 + 2 < _mtu)
{
FastBitConverter.GetBytes(_mergeData.RawData, _mergePos + NetConstants.HeaderSize, (ushort)data.Length);
Buffer.BlockCopy(data, 0, _mergeData.RawData, _mergePos + NetConstants.HeaderSize + 2, data.Length);
_mergePos += data.Length + 2;
_mergeCount++;
//DebugWriteForce("Merged: " + _mergePos + "/" + (_mtu - 2) + ", count: " + _mergeCount);
}
else
{
_peerListener.SendRaw(data, 0, data.Length, _remoteEndPoint);
}
}
public static NetPacket Make(long connectId, byte connectNum, bool reusedPeer, byte[] acceptData = null)
{
var dataSize = acceptData?.Length ?? 0;
// Make initial packet
var packet = new NetPacket(PacketProperty.ConnectAccept, dataSize);
// Add data
FastBitConverter.GetBytes(packet.RawData, 1, connectId);
packet.RawData[9] = connectNum;
packet.RawData[10] = (byte)(reusedPeer ? 1 : 0);
if (acceptData != null && dataSize > 0)
{
Buffer.BlockCopy(acceptData, 0, packet.RawData, Size, acceptData.Length);
}
return(packet);
}
//Connect constructor
internal NetPeer(NetManager netManager, IPEndPoint remoteEndPoint, NetDataWriter connectData) : this(netManager, remoteEndPoint)
{
_connectAttempts = 0;
_connectId = DateTime.UtcNow.Ticks;
_connectionState = ConnectionState.InProgress;
//Make initial packet
_connectRequestPacket = new NetPacket(PacketProperty.ConnectRequest, 12 + connectData.Length);
//Add data
FastBitConverter.GetBytes(_connectRequestPacket.RawData, 1, NetConstants.ProtocolId);
FastBitConverter.GetBytes(_connectRequestPacket.RawData, 5, _connectId);
Buffer.BlockCopy(connectData.Data, 0, _connectRequestPacket.RawData, 13, connectData.Length);
//Send request
_netManager.SendRaw(_connectRequestPacket, _remoteEndPoint);
NetUtils.DebugWrite(ConsoleColor.Cyan, "[CC] ConnectId: {0}", _connectId);
}
internal void SendRawData(NetPacket packet)
{
//2 - merge byte + minimal packet size + datalen(ushort)
if (_peerListener.MergeEnabled &&
CanMerge(packet.Property) &&
_mergePos + packet.Size + NetConstants.HeaderSize * 2 + 2 < _mtu)
{
FastBitConverter.GetBytes(_mergeData.RawData, _mergePos + NetConstants.HeaderSize, (ushort)packet.Size);
Buffer.BlockCopy(packet.RawData, 0, _mergeData.RawData, _mergePos + NetConstants.HeaderSize + 2, packet.Size);
_mergePos += packet.Size + 2;
_mergeCount++;
//DebugWriteForce("Merged: " + _mergePos + "/" + (_mtu - 2) + ", count: " + _mergeCount);
return;
}
NetUtils.DebugWrite(ConsoleColor.DarkYellow, "[P]SendingPacket: " + packet.Property);
_peerListener.SendRaw(packet.RawData, 0, packet.Size, _remoteEndPoint);
}
private void UpdateMtuLogic(int deltaTime)
{
if (_finishMtu)
{
return;
}
_mtuCheckTimer += deltaTime;
if (_mtuCheckTimer < MtuCheckDelay)
{
return;
}
_mtuCheckTimer = 0;
_mtuCheckAttempts++;
if (_mtuCheckAttempts >= MaxMtuCheckAttempts)
{
_finishMtu = true;
return;
}
lock (_mtuMutex)
{
if (_mtuIdx >= NetConstants.PossibleMtu.Length - 1)
{
return;
}
//Send increased packet
int newMtu = NetConstants.PossibleMtu[_mtuIdx + 1];
var p = _packetPool.GetPacket(newMtu);
p.Property = PacketProperty.MtuCheck;
FastBitConverter.GetBytes(p.RawData, 1, newMtu); //place into start
FastBitConverter.GetBytes(p.RawData, p.Size - 4, newMtu); //and end of packet
//Must check result for MTU fix
if (NetManager.SendRawAndRecycle(p, EndPoint) <= 0)
{
_finishMtu = true;
}
}
}
/// <summary>
/// Force closes connection and stop all threads.
/// </summary>
public void Stop()
{
//Send disconnect packets
lock (_peers)
foreach (NetPeer netPeer in _peers.Values)
{
var disconnectPacket = NetPacket.CreateRawPacket(PacketProperty.Disconnect, 8);
FastBitConverter.GetBytes(disconnectPacket, 1, netPeer.ConnectId);
SendRaw(disconnectPacket, netPeer.EndPoint);
}
//Clear
ClearPeers();
//Stop
if (IsRunning)
{
_logicThread.Stop();
_socket.Close();
}
}
