internal void SendHail()
{
HailStatus.Attempts++;
HailStatus.LastAttempt = NetTime.Now;
// Packet size
int size = 2 + (byte)Config.ChannelTypes.Length;
// Allocate memory
HeapMemory memory = MemoryManager.AllocHeapMemory((uint)size);
// Write the header
memory.Buffer[0] = HeaderPacker.Pack(MessageType.Hail);
// Write the amount of channels
memory.Buffer[1] = (byte)Config.ChannelTypes.Length;
// Write the channel types
for (byte i = 0; i < (byte)Config.ChannelTypes.Length; i++)
{
memory.Buffer[2 + i] = ChannelTypeUtils.ToByte(Config.ChannelTypes[i]);
}
// Send the response
SendInternal(new ArraySegment <byte>(memory.Buffer, 0, (int)memory.VirtualCount), true);
// Release memory
MemoryManager.DeAlloc(memory);
// Print Debug
if (Logging.CurrentLogLevel <= LogLevel.Debug)
{
Logging.LogInfo("Client " + EndPoint + " was sent a hail");
}
}
public void SendPacket(Packet packet, ChannelType channelType = ChannelType.ReliableOrdered)
{
NetOutgoingMessage msg = client.CreateMessage();
msg.Write(packet.Serialize());
#if DEBUG
Debug.Log($"Send packet: {packet.GetType().FullName}");
#endif
NetDeliveryMethod deliveryMethod = ChannelTypeUtils.ChannelTypeToLidgren(channelType);
client.SendMessage(msg, deliveryMethod);
}
public bool SendPacketToAll(Packet packet, ChannelType channelType = ChannelType.ReliableOrdered)
{
#if DEBUG
Console.WriteLine($"Send - Type: {packet.GetType().Name}");
#endif
NetOutgoingMessage msg = server.CreateMessage();
msg.Write(packet.Serialize());
NetDeliveryMethod deliveryMethod = ChannelTypeUtils.ChannelTypeToLidgren(channelType);
server.SendToAll(msg, deliveryMethod, 1);
return(true);
}
public bool SendPacketToAllExcept(Packet packet, Guid playerId, ChannelType channelType = ChannelType.ReliableOrdered)
{
#if DEBUG
Console.WriteLine($"Send - Type: {packet.GetType().Name}");
#endif
if (!playerConnections.ContainsKey(playerId))
{
Console.WriteLine("Failed to send packet to players: Excluded player not found.");
return(false);
}
long excludedId = playerConnections[playerId];
NetOutgoingMessage msg = server.CreateMessage();
msg.Write(packet.Serialize());
NetDeliveryMethod deliveryMethod = ChannelTypeUtils.ChannelTypeToLidgren(channelType);
server.SendToAll(msg, server.Connections.First(p => p.RemoteUniqueIdentifier == excludedId), deliveryMethod, 1);
return(true);
}
internal void HandleHail(ArraySegment <byte> channelTypes)
{
_stateLock.EnterUpgradeableReadLock();
try
{
if (State == ConnectionState.Connected)
{
// TODO: Add time check
// We already got this hail. Send new confirmation.
SendHailConfirmed();
}
else if (State == ConnectionState.SolvingChallenge)
{
_stateLock.EnterWriteLock();
try
{
for (byte i = 0; i < channelTypes.Count; i++)
{
// Assign the channel
Channels[i] = Socket.ChannelPool.GetChannel(ChannelTypeUtils.FromByte(channelTypes.Array[channelTypes.Offset + i]), i, this, Config, MemoryManager);
}
// Change state to connected
State = ConnectionState.Connected;
}
finally
{
_stateLock.ExitWriteLock();
}
// Print connected
if (Logging.CurrentLogLevel <= LogLevel.Info)
{
Logging.LogInfo("Client " + EndPoint + " successfully connected");
}
SendHailConfirmed();
// Send to userspace
Socket.PublishEvent(new NetworkEvent()
{
Connection = this,
Socket = Socket,
Type = NetworkEventType.Connect,
AllowUserRecycle = false,
ChannelId = 0,
Data = new ArraySegment <byte>(),
InternalMemory = null,
SocketReceiveTime = NetTime.Now,
MemoryManager = MemoryManager,
EndPoint = EndPoint
});
}
}
finally
{
_stateLock.ExitUpgradeableReadLock();
}
}
public List <string> GetInvalidConfiguration()
{
List <string> messages = new List <string>();
if (MaxMergeMessageSize > MaximumMTU)
{
messages.Add("MaxMergeMessageSize cannot be greater than MaxMessageSize");
}
if (AmplificationPreventionHandshakePadding > MaximumMTU)
{
messages.Add("AmplificationPreventionHandshakePadding cannot be greater than MaxMessageSize");
}
if (ChannelTypes.Length > Constants.MAX_CHANNELS)
{
messages.Add("Cannot have more than " + Constants.MAX_CHANNELS + " channels");
}
if (SocketThreads < 1)
{
messages.Add("SocketThreads cannot be less than 1");
}
if (LogicThreads < 0)
{
messages.Add("LogicThreads cannot be less than 0. Use 0 to process on the SocketThread");
}
if (ProcessingThreads < 0)
{
messages.Add("ProcessingThreads cannot be less than 0. Use 0 to process on the SocketThread");
}
for (int i = 0; i < ChannelTypes.Length; i++)
{
if (!ChannelTypeUtils.IsValidChannelType(ChannelTypes[i]))
{
messages.Add("ChannelType at index " + i + " is not a valid ChannelType");
}
}
if (DualListenPort > ushort.MaxValue)
{
messages.Add("DualListenPort cannot be greater than " + ushort.MaxValue);
}
if (DualListenPort < 0)
{
messages.Add("DualListenPort cannot be less than 0. Use 0 to get a random port");
}
if (IPv4ListenAddress == null)
{
messages.Add("IPv4ListenAddress cannot be null");
}
if (IPv6ListenAddress == null)
{
messages.Add("IPv6ListenAddress cannot be null");
}
if (LogicDelay < 0)
{
messages.Add("LogicDelay cannot be less than 0. Use 0 for no delay");
}
if (MaxMergeMessageSize < 32)
{
messages.Add("MaxMergeMessageSize cannot be less than 32. Set EnablePacketMerging to false to disable merging");
}
if (MaxMergeDelay < 0)
{
messages.Add("MaxMergeDelay cannot be less than 0. Set EnablePacketMerging to false to disable merging");
}
if (MergedAckBytes < 1)
{
messages.Add("MergedAckBytes cannot be less than 1. Set EnableMergedAcks to false to disable merged acks");
}
if (MinimumMTU < Constants.MINIMUM_MTU)
{
messages.Add("MinimumMTU cannot be less than " + Constants.MINIMUM_MTU);
}
if (MaxBufferSize < MaximumMTU)
{
messages.Add("MaxBufferSize cannot be less than MaximumMTU");
}
if (MaximumMTU < MinimumMTU)
{
messages.Add("MaximumMTU cannot be less than MinimumMTU");
}
if (MaxMTUAttempts < 1)
{
messages.Add("MaxMTUAttempts cannot be less than 1. Set EnablePathMTU to false to disable PathMTU");
}
if (MTUAttemptDelay < 0)
{
messages.Add("MTUAttemptDelay cannot be less than 0");
}
if (MTUGrowthFactor < 1)
{
messages.Add("MTUGrowthFactor cannot be less than 1");
}
if (MaxFragments < 1)
{
messages.Add("MaxFragments cannot be less than 1");
}
if (MaxFragments > Constants.MAX_FRAGMENTS)
{
messages.Add("MaxFragments cannot be greater than " + Constants.MAX_FRAGMENTS);
}
if (HandshakeTimeout < 0)
{
messages.Add("HandshakeTimeout cannot be less than 0");
}
if (ConnectionTimeout < 0)
{
messages.Add("ConnectionTimeout cannot be less than 0");
}
if (HeartbeatDelay < 0)
{
messages.Add("HeartbeatDelay cannot be less than 0");
}
if (HandshakeResendDelay < 0)
{
messages.Add("HandshakeResendDelay cannot be less than 0");
}
if (MaxHandshakeResends < 0)
{
messages.Add("MaxHandshakeResends cannot be less than 0");
}
if (ConnectionRequestMinResendDelay < 0)
{
messages.Add("ConnectionRequestMinResendDelay cannot be less than 0");
}
if (MaxConnectionRequestResends < 0)
{
messages.Add("MaxConnectionRequestResends cannot be less than 0");
}
if (ConnectionRequestTimeout < 0)
{
messages.Add("ConnectionRequestTimeout cannot be less than 0");
}
if (ChallengeDifficulty < 0)
{
messages.Add("ChallengeDifficulty cannot be less than 0");
}
if (ChallengeDifficulty > byte.MaxValue)
{
messages.Add("ChallengeDifficulty cannot be greater than " + byte.MaxValue);
}
if (ConnectionChallengeHistory < 0)
{
messages.Add("ConnectionChallengeHistory cannot be less than 0");
}
if (ConnectionChallengeTimeWindow < 1)
{
messages.Add("ConnectionChallengeTimeWindow cannot be less than 1");
}
if (AmplificationPreventionHandshakePadding < 0)
{
messages.Add("AmplificationPreventionHandshakePadding cannot be less than 0");
}
if (ReliabilityWindowSize < 1)
{
messages.Add("ReliabilityWindowSize cannot be less than 1");
}
if (ReliableAckFlowWindowSize < 1)
{
messages.Add("ReliableAckFlowWindowSize cannot be less than 1");
}
if (ReliabilityMaxResendAttempts < 0)
{
messages.Add("ReliabilityMaxResendAttempts cannot be less than 0");
}
if (ReliabilityResendRoundtripMultiplier < 0)
{
messages.Add("ReliabilityResendRoundtripMultiplier cannot be less than 0");
}
if (ReliabilityMinPacketResendDelay < 0)
{
messages.Add("ReliabilityMinPacketResendDelay cannot be less than 0");
}
if (ReliabilityMinAckResendDelay < 0)
{
messages.Add("ReliabilityMinAckResendDelay cannot be less than 0");
}
if (SimulatorConfig.DropPercentage < 0)
{
messages.Add("SimulatorConfig.DropPercentage cannot be less than 0");
}
if (SimulatorConfig.DropPercentage > 1)
{
messages.Add("SimulatorConfig.DropPercentage cannot be greater than 1");
}
if (SimulatorConfig.MinLatency < 0)
{
messages.Add("SimulatorConfig.MinLatency cannot be less than 0");
}
if (SimulatorConfig.MaxLatency < 0)
{
messages.Add("SimulatorConfig.MaxLatency cannot be less than 0");
}
if (SimulatorConfig.MaxLatency < SimulatorConfig.MinLatency)
{
messages.Add("SimulatorConfig.MaxLatency cannot be less than SimulatorConfig.MinLatency");
}
if (EventQueueSize < 1)
{
messages.Add("EventQueueSize cannot be less than 1");
}
if (ProcessingQueueSize < 1)
{
messages.Add("ProcessingQueueSize cannot be less than 1");
}
if (HeapPointersPoolSize < 0)
{
messages.Add("HeapPointersPoolSize cannot be less than 0");
}
if (HeapMemoryPoolSize < 0)
{
messages.Add("HeapMemoryPoolSize cannot be less than 0");
}
if (MemoryWrapperPoolSize < 0)
{
messages.Add("MemoryWrapperPoolSize cannot be less than 0");
}
if (ChannelPoolSize < 0)
{
messages.Add("ChannelPoolSize cannot be less than 0");
}
if (EnableBandwidthTracking && CreateBandwidthTracker == null)
{
messages.Add("EnableBandwidthTracking is enabled but no CreateBandwidthTracker delegate is provided");
}
return(messages);
}
