private void CreateOutgoingMessageInternal(ArraySegment <byte> payload, bool noMerge, ulong notificationKey)
{
// Calculate the amount of fragments required
int fragmentsRequired = (payload.Count + (connection.MTU - 1)) / connection.MTU;
if (fragmentsRequired >= config.MaxFragments)
{
if (Logging.CurrentLogLevel <= LogLevel.Error)
{
Logging.LogError("Tried to create message that was too large. [Size=" + payload.Count + "] [FragmentsRequired=" + fragmentsRequired + "] [Config.MaxFragments=" + config.MaxFragments + "]");
}
return;
}
if (!_sendSequencer.CanSet((ushort)(_lastOutgoingSequence + 1)))
{
if (Logging.CurrentLogLevel <= LogLevel.Warning)
{
Logging.LogWarning("Outgoing packet window is exhausted. Expect delays");
}
// Alloc memory
HeapMemory memory = memoryManager.AllocHeapMemory((uint)payload.Count);
// Copy the payload
Buffer.BlockCopy(payload.Array, payload.Offset, memory.Buffer, 0, payload.Count);
// Enqueue it
_pendingSends.Enqueue(new PendingSend()
{
Memory = memory,
NoMerge = noMerge,
NotificationKey = notificationKey
});
}
else
{
// Increment the sequence number
_lastOutgoingSequence++;
// Alloc array
HeapPointers memoryParts = memoryManager.AllocHeapPointers((uint)fragmentsRequired);
int position = 0;
for (ushort i = 0; i < fragmentsRequired; i++)
{
// Calculate message size
int messageSize = Math.Min(connection.MTU, payload.Count - position);
// Allocate memory for each fragment
memoryParts.Pointers[memoryParts.VirtualOffset + i] = memoryManager.AllocHeapMemory((uint)(messageSize + 6));
// Write headers
((HeapMemory)memoryParts.Pointers[memoryParts.VirtualOffset + i]).Buffer[0] = HeaderPacker.Pack(MessageType.Data);
((HeapMemory)memoryParts.Pointers[memoryParts.VirtualOffset + i]).Buffer[1] = channelId;
// Write the sequence
((HeapMemory)memoryParts.Pointers[memoryParts.VirtualOffset + i]).Buffer[2] = (byte)_lastOutgoingSequence;
((HeapMemory)memoryParts.Pointers[memoryParts.VirtualOffset + i]).Buffer[3] = (byte)(_lastOutgoingSequence >> 8);
// Write the fragment
((HeapMemory)memoryParts.Pointers[memoryParts.VirtualOffset + i]).Buffer[4] = (byte)(i & 32767);
((HeapMemory)memoryParts.Pointers[memoryParts.VirtualOffset + i]).Buffer[5] = (byte)(((i & 32767) >> 8) | (byte)(i == fragmentsRequired - 1 ? 128 : 0));
// Write the payload
Buffer.BlockCopy(payload.Array, payload.Offset + position, ((HeapMemory)memoryParts.Pointers[memoryParts.VirtualOffset + i]).Buffer, 6, messageSize);
// Increase the position
position += messageSize;
}
// Alloc outgoing fragment structs
HeapPointers outgoingFragments = memoryManager.AllocHeapPointers((uint)fragmentsRequired);
for (int i = 0; i < fragmentsRequired; i++)
{
// Add the memory to the outgoing sequencer array
outgoingFragments.Pointers[outgoingFragments.VirtualOffset + i] = new PendingOutgoingFragment()
{
Attempts = 1,
LastSent = NetTime.Now,
FirstSent = NetTime.Now,
Memory = ((HeapMemory)memoryParts.Pointers[memoryParts.VirtualOffset + i])
};
}
// Add the memory to the outgoing sequencer
_sendSequencer.Set(_lastOutgoingSequence, new PendingOutgoingPacketFragmented()
{
Fragments = outgoingFragments,
NotificationKey = notificationKey
});
// Send the message to the router. Tell the router to NOT dealloc the memory as the channel needs it for resend purposes.
ChannelRouter.SendMessage(memoryParts, false, connection, noMerge, memoryManager);
}
}
private void CreateOutgoingMessageInternal(ArraySegment <byte> payload, bool noMerge, ulong notificationKey)
{
if (payload.Count > connection.MTU)
{
if (Logging.CurrentLogLevel <= LogLevel.Error)
{
Logging.LogError("Tried to send message that was too large. Use a fragmented channel instead. [Size=" + payload.Count + "] [MaxMessageSize=" + config.MaxFragments + "]");
}
return;
}
if (!_sendSequencer.CanSet((ushort)(_lastOutgoingSequence + 1)))
{
if (Logging.CurrentLogLevel <= LogLevel.Warning)
{
Logging.LogWarning("Outgoing packet window is exhausted. Expect delays");
}
// Alloc memory
HeapMemory memory = memoryManager.AllocHeapMemory((uint)payload.Count);
// Copy the payload
Buffer.BlockCopy(payload.Array, payload.Offset, memory.Buffer, 0, payload.Count);
// Enqueue it
_pendingSends.Enqueue(new PendingSend()
{
Memory = memory,
NoMerge = noMerge,
NotificationKey = notificationKey
});
}
else
{
// Increment the sequence number
_lastOutgoingSequence++;
// Allocate the memory
HeapMemory memory = memoryManager.AllocHeapMemory((uint)payload.Count + 4);
// Write headers
memory.Buffer[0] = HeaderPacker.Pack(MessageType.Data);
memory.Buffer[1] = channelId;
// Write the sequence
memory.Buffer[2] = (byte)_lastOutgoingSequence;
memory.Buffer[3] = (byte)(_lastOutgoingSequence >> 8);
// Copy the payload
Buffer.BlockCopy(payload.Array, payload.Offset, memory.Buffer, 4, payload.Count);
// Add the memory to pending
_sendSequencer.Set(_lastOutgoingSequence, new PendingOutgoingPacket()
{
Attempts = 1,
LastSent = NetTime.Now,
FirstSent = NetTime.Now,
Memory = memory,
NotificationKey = notificationKey
});
// Allocate pointers
HeapPointers pointers = memoryManager.AllocHeapPointers(1);
// Point the first pointer to the memory
pointers.Pointers[0] = memory;
// Send the message to the router. Tell the router to NOT dealloc the memory as the channel needs it for resend purposes.
ChannelRouter.SendMessage(pointers, false, connection, noMerge, memoryManager);
}
}