/// <summary>
/// Connects to a server
/// </summary>
public bool Connect(IPAddress address, int port, byte[] customData)
{
if (m_serverConnection != null && m_serverConnection.Status != NetConnectionStatus.Disconnected)
{
m_serverConnection.Disconnect("Reconnecting");
}
IPEndPoint remoteIP = new IPEndPoint(address, port);
m_serverConnection = new NetConnection(this, remoteIP);
string remoteHost = remoteIP.ToString();
Log.Info("Connecting to " + remoteHost);
m_serverConnection.m_firstSentHandshake = NetTime.Now;
m_serverConnection.m_lastSentHandshake = m_serverConnection.m_firstSentHandshake;
m_serverConnection.SetStatus(NetConnectionStatus.Connecting, "Connecting");
// save custom data for repeat connect requests
if (customData != null)
{
m_serverConnection.m_savedConnectCustomData = new byte[customData.Length];
Array.Copy(customData, m_serverConnection.m_savedConnectCustomData, customData.Length);
}
int bytesSent = NetHandshake.SendConnect(this, remoteIP, customData);
// account for connect packet
m_serverConnection.Statistics.PacketsSent++;
m_serverConnection.Statistics.MessagesSent++;
m_serverConnection.Statistics.BytesSent += bytesSent;
return(true);
}
/// <summary>
/// Disconnects from remote host providing specified reason
/// </summary>
public void Disconnect(string reason)
{
if (m_status != NetConnectionStatus.Disconnected)
{
SendUnsentMessages(true, 1.0f); // flush
NetHandshake.SendDisconnected(m_parent, reason, this);
if (m_unsentMessages.Count < 1)
{
SetStatus(NetConnectionStatus.Disconnected, reason);
}
else
{
SetStatus(NetConnectionStatus.Disconnecting, reason);
m_pendingDisconnectedReason = reason;
}
}
}
internal override void HandlePacket(NetBuffer buffer, int bytesReceived, IPEndPoint senderEndpoint)
{
double now = NetTime.Now;
NetConnection sender = FindConnection(senderEndpoint);
if (sender != null)
{
sender.m_lastHeardFromRemote = now;
if (sender.m_encryption.SymmetricEncryptionKeyBytes != null)
{
bool ok = sender.m_encryption.DecryptSymmetric(buffer);
if (!ok)
{
Log.Warning("Failed to decrypt packet from client " + sender);
return;
}
}
}
try
{
NetMessage response;
int messagesReceived = 0;
int usrMessagesReceived = 0;
int ackMessagesReceived = 0;
while (buffer.ReadBitsLeft > 7)
{
NetMessage msg = NetMessage.Decode(buffer);
if (msg == null)
{
break; // done
}
messagesReceived++;
msg.Sender = sender;
switch (msg.m_type)
{
case NetMessageType.Acknowledge:
case NetMessageType.AcknowledgeBitField:
if (sender == null)
{
Log.Warning("Received Ack from not-connected source!");
}
else
{
//Log.Debug("Received ack " + msg.SequenceChannel + "|" + msg.SequenceNumber);
sender.ReceiveAcknowledge(msg);
ackMessagesReceived++;
}
break;
case NetMessageType.Handshake:
NetHandshakeType tp = (NetHandshakeType)msg.ReadByte();
if (tp == NetHandshakeType.ConnectResponse)
{
Log.Warning("Received ConnectResponse?!");
}
else if (tp == NetHandshakeType.Connect)
{
if (sender == null)
{
NetHandshake.HandleConnect(msg, this, senderEndpoint);
}
else
{
// resend response
NetHandshake.SendConnectResponse(this, sender, senderEndpoint);
Log.Verbose("Redundant Connect received; resending response");
}
}
else if (tp == NetHandshakeType.ConnectionEstablished)
{
if (sender == null)
{
Log.Warning("Received ConnectionEstablished, but no sender connection?!");
}
else
{
float rt = (float)(now - sender.m_firstSentHandshake);
sender.m_ping.Initialize(rt);
ushort remoteValue = msg.ReadUInt16();
sender.RemoteClockOffset = NetTime.CalculateOffset(now, remoteValue, rt);
Log.Verbose("Reinitializing remote clock offset to " + sender.RemoteClockOffset + " ms (roundtrip " + NetUtil.SecToMil(rt) + " ms)");
if (sender.Status == NetConnectionStatus.Connected)
{
Log.Verbose("Redundant ConnectionEstablished received");
}
else
{
Log.Debug("Connection established");
sender.SetStatus(NetConnectionStatus.Connected, "Connected by established");
}
}
}
else
{
// disconnected
if (sender == null)
{
Log.Warning("Disconnected received from unconnected source: " + senderEndpoint);
return;
}
string reason = msg.ReadString();
sender.Disconnected(reason);
}
break;
case NetMessageType.Discovery:
Log.Debug("Answering discovery response from " + senderEndpoint);
response = NetDiscovery.EncodeResponse(this);
SendSingleMessageAtOnce(response, null, senderEndpoint);
break;
case NetMessageType.PingPong:
if (sender == null)
{
return;
}
bool isPong = msg.ReadBoolean();
bool isOptimizeInfo = msg.ReadBoolean();
if (isOptimizeInfo)
{
// DON'T handle optimizeinfo... only clients should adapt to server ping info
}
else if (isPong)
{
if (sender.Status == NetConnectionStatus.Connected)
{
sender.m_ping.HandlePong(now, msg);
}
}
else
{
NetPing.ReplyPong(msg, sender); // send pong
}
break;
case NetMessageType.User:
case NetMessageType.UserFragmented:
usrMessagesReceived++;
if (sender == null)
{
Log.Warning("User message received from unconnected source: " + senderEndpoint);
return; // don't handle user messages from unconnected sources
}
if (sender.Status == NetConnectionStatus.Connecting)
{
sender.SetStatus(NetConnectionStatus.Connected, "Connected by user message");
}
sender.ReceiveMessage(now, msg);
break;
default:
Log.Warning("Bad message type: " + msg);
break;
}
}
if (sender != null)
{
NetStatistics stats = sender.Statistics;
stats.PacketsReceived++;
stats.MessagesReceived += messagesReceived;
stats.UserMessagesReceived += usrMessagesReceived;
stats.AckMessagesReceived += ackMessagesReceived;
stats.BytesReceived += bytesReceived;
}
}
catch (Exception ex)
{
Log.Error("Failed to parse packet correctly; read/write mismatch? " + ex);
}
}
/// <summary>
/// Connection heartbeat, normally called from NetClient.Heartbeat() or NetServer.Heartbeat()
/// Calling it manually may interfere with proper throttling
/// </summary>
public void Heartbeat(double now)
{
m_frameLength = now - m_lastHeartbeat;
m_lastHeartbeat = now;
// resend timed out saved packets
for (int i = 0; i < m_savedReliableMessages.Length; i++)
{
if (m_savedReliableMessages[i] != null && m_savedReliableMessages[i].Count > 0)
{
foreach (NetMessage msg in m_savedReliableMessages[i])
{
if (now > msg.m_nextResendTime)
{
// it might have been lost; resend it
if (msg.m_numResends >= Configuration.NumResendsBeforeFailing)
{
m_parent.Log.Error("Dropping outgoing packet " + msg + "; maximum number of resends reached!");
}
else
{
if (MessageResent != null)
{
MessageResent(this, new NetMessageEventArgs(msg));
}
//m_parent.Log.Verbose("Resending " + msg + " @ " + now);
m_unsentMessages.Enqueue(msg);
float nextResend = (float)now + (msg.m_numResends < 1 ? Configuration.ResendFirstUnacknowledgedDelay : Configuration.ResendSubsequentUnacknowledgedDelay);
msg.m_nextResendTime = nextResend;
msg.m_numResends++;
Statistics.MessagesResent++;
}
m_tmpRemoveList.Add(msg); // to be removed
}
}
if (m_tmpRemoveList.Count > 0)
{
foreach (NetMessage rm in m_tmpRemoveList)
{
m_savedReliableMessages[i].Remove(rm); // remove it; it will be readded upon sending
}
m_tmpRemoveList.Clear();
}
}
}
// send all messages (possibly forcing acks to be sent)
SendUnsentMessages((m_forceExplicitAckTime != 0.0 && now > m_forceExplicitAckTime),
(m_frameLength > 0.1 ? 0.1 : m_frameLength)); // throttling don't like unlikely long frames
if (now - m_lastHeardFromRemote > Configuration.ConnectionTimeOut)
{
NetHandshake.SendDisconnected(m_parent, "Connection timed out", this);
SetStatus(NetConnectionStatus.Disconnected, "Connection timed out");
return;
}
if (m_status == NetConnectionStatus.Connecting)
{
// keep sending connect packets
if (now - m_lastSentHandshake > NetConstants.SendHandshakeFrequency)
{
if (now - m_firstSentHandshake > NetConstants.ConnectAttemptTimeout)
{
m_parent.Log.Info("Failed to connect; no answer from remote host!");
SetStatus(NetConnectionStatus.Disconnected, "Connect attempt timeout");
}
else
{
NetClient client = m_parent as NetClient;
if (client != null)
{
int bytesSent = NetHandshake.SendConnect(client, m_remoteEndpoint, m_savedConnectCustomData);
client.ServerConnection.Statistics.PacketsSent++;
client.ServerConnection.Statistics.MessagesSent++;
client.ServerConnection.Statistics.BytesSent += bytesSent;
m_lastSentHandshake = now;
}
else
{
NetHandshake.SendConnectResponse(m_parent, this, m_remoteEndpoint);
m_lastSentHandshake = now;
}
}
}
return;
}
m_ping.Heartbeat(now);
}