private void SendConnectRequest()
{
//Make initial packet
var connectPacket = _packetPool.GetWithProperty(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 NetPeer(NetManager netManager, NetEndPoint remoteEndPoint)
{
Statistics = new NetStatistics();
_packetPool = netManager.NetPacketPool;
_netManager = netManager;
_remoteEndPoint = remoteEndPoint;
_avgRtt = 0;
_rtt = 0;
_pingSendTimer = 0;
_reliableOrderedChannel = new ReliableChannel(this, true);
_reliableUnorderedChannel = new ReliableChannel(this, false);
_sequencedChannel = new SequencedChannel(this);
_simpleChannel = new SimpleChannel(this);
_reliableSequencedChannel = new ReliableSequencedChannel(this);
_holdedFragments = new Dictionary <ushort, IncomingFragments>();
_mergeData = _packetPool.GetWithProperty(PacketProperty.Merged, NetConstants.MaxPacketSize);
}
private void SendInternal(
byte[] data,
int start,
int length,
byte channelNumber,
DeliveryMethod deliveryMethod,
object userData)
{
if (_connectionState == ConnectionState.ShutdownRequested ||
_connectionState == ConnectionState.Disconnected)
{
return;
}
if (channelNumber >= _channels.Length)
{
return;
}
//Select channel
PacketProperty property;
BaseChannel channel;
if (deliveryMethod == DeliveryMethod.Unreliable)
{
property = PacketProperty.Unreliable;
channel = _unreliableChannel;
}
else
{
property = PacketProperty.Channeled;
channel = CreateChannel((byte)(channelNumber * 4 + (byte)deliveryMethod));
}
//Prepare
NetDebug.Write("[RS]Packet: " + property);
//Check fragmentation
int headerSize = NetPacket.GetHeaderSize(property);
//Save mtu for multithread
int mtu = _mtu;
if (length + headerSize > mtu)
{
//if cannot be fragmented
if (deliveryMethod != DeliveryMethod.ReliableOrdered && deliveryMethod != DeliveryMethod.ReliableUnordered)
{
throw new TooBigPacketException("Unreliable packet size exceeded maximum of " + (_mtu - headerSize) + " bytes");
}
int packetFullSize = mtu - headerSize;
int packetDataSize = packetFullSize - NetConstants.FragmentHeaderSize;
int totalPackets = length / packetDataSize + (length % packetDataSize == 0 ? 0 : 1);
NetDebug.Write("FragmentSend:\n" +
" MTU: {0}\n" +
" headerSize: {1}\n" +
" packetFullSize: {2}\n" +
" packetDataSize: {3}\n" +
" totalPackets: {4}",
mtu, headerSize, packetFullSize, packetDataSize, totalPackets);
if (totalPackets > ushort.MaxValue)
{
throw new TooBigPacketException("Data was split in " + totalPackets + " fragments, which exceeds " + ushort.MaxValue);
}
lock (_sendLock)
{
for (ushort partIdx = 0; partIdx < totalPackets; partIdx++)
{
int sendLength = length > packetDataSize ? packetDataSize : length;
NetPacket p = _packetPool.GetWithProperty(property, sendLength + NetConstants.FragmentHeaderSize);
p.UserData = userData;
p.FragmentId = _fragmentId;
p.FragmentPart = partIdx;
p.FragmentsTotal = (ushort)totalPackets;
p.MarkFragmented();
Buffer.BlockCopy(data, partIdx * packetDataSize, p.RawData, NetConstants.FragmentTotalSize, sendLength);
channel.AddToQueue(p);
length -= sendLength;
}
_fragmentId++;
}
return;
}
//Else just send
NetPacket packet = _packetPool.GetWithData(property, data, start, length);
packet.UserData = userData;
channel.AddToQueue(packet);
}
/// <summary>
/// Send data to peer
/// </summary>
/// <param name="data">Data</param>
/// <param name="start">Start of data</param>
/// <param name="length">Length of data</param>
/// <param name="options">Send options (reliable, unreliable, etc.)</param>
/// <exception cref="TooBigPacketException">
/// If size exceeds maximum limit:<para/>
/// MTU - headerSize bytes for Unreliable<para/>
/// Fragment count exceeded ushort.MaxValue<para/>
/// </exception>
public void Send(byte[] data, int start, int length, DeliveryMethod options)
{
if (_connectionState == ConnectionState.ShutdownRequested ||
_connectionState == ConnectionState.Disconnected)
{
return;
}
//Prepare
PacketProperty property = SendOptionsToProperty(options);
NetUtils.DebugWrite("[RS]Packet: " + property);
//Select channel
BaseChannel channel;
switch (property)
{
case PacketProperty.ReliableUnordered:
channel = _reliableUnorderedChannel;
break;
case PacketProperty.Sequenced:
channel = _sequencedChannel;
break;
case PacketProperty.ReliableOrdered:
channel = _reliableOrderedChannel;
break;
case PacketProperty.Unreliable:
channel = _unreliableChannel;
break;
case PacketProperty.ReliableSequenced:
channel = _reliableSequencedChannel;
break;
default:
throw new InvalidPacketException("Unknown packet property: " + property);
}
//Check fragmentation
int headerSize = NetPacket.GetHeaderSize(property);
//Save mtu for multithread
int mtu = _mtu;
if (length + headerSize > mtu)
{
if (options == DeliveryMethod.Sequenced ||
options == DeliveryMethod.Unreliable ||
options == DeliveryMethod.ReliableSequenced)
{
throw new TooBigPacketException("Unreliable packet size exceeded maximum of " + (_mtu - headerSize) + " bytes");
}
int packetFullSize = mtu - headerSize;
int packetDataSize = packetFullSize - NetConstants.FragmentHeaderSize;
int fullPacketsCount = length / packetDataSize;
int lastPacketSize = length % packetDataSize;
int totalPackets = fullPacketsCount + (lastPacketSize == 0 ? 0 : 1);
NetUtils.DebugWrite("FragmentSend:\n" +
" MTU: {0}\n" +
" headerSize: {1}\n" +
" packetFullSize: {2}\n" +
" packetDataSize: {3}\n" +
" fullPacketsCount: {4}\n" +
" lastPacketSize: {5}\n" +
" totalPackets: {6}",
mtu, headerSize, packetFullSize, packetDataSize, fullPacketsCount, lastPacketSize, totalPackets);
if (totalPackets > ushort.MaxValue)
{
throw new TooBigPacketException("Data was split in " + totalPackets + " fragments, which exceeds " + ushort.MaxValue);
}
int dataOffset = headerSize + NetConstants.FragmentHeaderSize;
lock (_sendLock)
{
for (ushort i = 0; i < fullPacketsCount; i++)
{
NetPacket p = _packetPool.GetWithProperty(property, packetFullSize);
p.FragmentId = _fragmentId;
p.FragmentPart = i;
p.FragmentsTotal = (ushort)totalPackets;
p.MarkFragmented();
Buffer.BlockCopy(data, i * packetDataSize, p.RawData, dataOffset, packetDataSize);
channel.AddToQueue(p);
}
if (lastPacketSize > 0)
{
NetPacket p = _packetPool.GetWithProperty(property, lastPacketSize + NetConstants.FragmentHeaderSize);
p.FragmentId = _fragmentId;
p.FragmentPart = (ushort)fullPacketsCount; //last
p.FragmentsTotal = (ushort)totalPackets;
p.MarkFragmented();
Buffer.BlockCopy(data, fullPacketsCount * packetDataSize, p.RawData, dataOffset, lastPacketSize);
channel.AddToQueue(p);
}
_fragmentId++;
}
return;
}
//Else just send
NetPacket packet = _packetPool.GetWithData(property, data, start, length);
channel.AddToQueue(packet);
}
internal void AddReliablePacket(DeliveryMethod method, NetPacket p)
{
if (p.IsFragmented)
{
NetDebug.Write("Fragment. Id: {0}, Part: {1}, Total: {2}", p.FragmentId, p.FragmentPart, p.FragmentsTotal);
//Get needed array from dictionary
ushort packetFragId = p.FragmentId;
IncomingFragments incomingFragments;
if (!_holdedFragments.TryGetValue(packetFragId, out incomingFragments))
{
incomingFragments = new IncomingFragments
{
Fragments = new NetPacket[p.FragmentsTotal],
ChannelId = p.ChannelId
};
_holdedFragments.Add(packetFragId, incomingFragments);
}
//Cache
var fragments = incomingFragments.Fragments;
//Error check
if (p.FragmentPart >= fragments.Length ||
fragments[p.FragmentPart] != null ||
p.ChannelId != incomingFragments.ChannelId)
{
_packetPool.Recycle(p);
NetDebug.WriteError("Invalid fragment packet");
return;
}
//Fill array
fragments[p.FragmentPart] = p;
//Increase received fragments count
incomingFragments.ReceivedCount++;
//Increase total size
incomingFragments.TotalSize += p.Size - NetConstants.FragmentedHeaderTotalSize;
//Check for finish
if (incomingFragments.ReceivedCount != fragments.Length)
{
return;
}
//unreliable to save header space
NetPacket resultingPacket = _packetPool.GetWithProperty(
PacketProperty.Unreliable,
incomingFragments.TotalSize);
int firstFragmentSize = fragments[0].Size - NetConstants.FragmentedHeaderTotalSize;
for (int i = 0; i < incomingFragments.ReceivedCount; i++)
{
var fragment = fragments[i];
//Create resulting big packet
Buffer.BlockCopy(
fragment.RawData,
NetConstants.FragmentedHeaderTotalSize,
resultingPacket.RawData,
NetConstants.HeaderSize + firstFragmentSize * i,
fragment.Size - NetConstants.FragmentedHeaderTotalSize);
//Free memory
_packetPool.Recycle(fragment);
}
Array.Clear(fragments, 0, incomingFragments.ReceivedCount);
//Send to process
NetManager.CreateReceiveEvent(resultingPacket, method, this);
//Clear memory
_holdedFragments.Remove(packetFragId);
}
else //Just simple packet
{
NetManager.CreateReceiveEvent(p, method, this);
}
}
