示例#1
0
        internal static int CalculateOffset(double now, ushort val, double roundtrip)
        {
            int oneWayMillis = (int)(roundtrip * 500.0);
            int remoteNow    = NormalizeEncoded(val + oneWayMillis);
            int localNow     = NetTime.Encoded(now);

            return(remoteNow - localNow);
        }
示例#2
0
        /// <summary>
        /// Returns absolute timestamp
        /// Note; will only accept encoded timestamps IN THE PAST
        /// </summary>
        public static float FromEncoded(float now, int remoteMillisOffset, ushort encodedRemoteTimestamp, out int adjustRemoteMillis)
        {
            // my encoded time

            ushort localNow      = (ushort)(now * 1000 % ushort.MaxValue);
            ushort localStamp    = NetTime.NormalizeEncoded(encodedRemoteTimestamp - remoteMillisOffset);
            int    elapsedMillis = NetTime.GetElapsedMillis(localStamp, localNow);

            adjustRemoteMillis = 0;
            return(now - ((float)elapsedMillis / 1000.0f));
        }
示例#3
0
        internal static int SendConnectResponse(NetBase netBase, NetConnection clientConnection, IPEndPoint remoteEndpoint)
        {
            double     now      = NetTime.Now;
            ushort     nowEnc   = NetTime.Encoded(now);
            NetMessage response = new NetMessage(NetMessageType.Handshake, 3);

            response.Write((byte)NetHandshakeType.ConnectResponse);
            response.Write(nowEnc);
            clientConnection.m_firstSentHandshake = now;
            clientConnection.m_lastSentHandshake  = now;
            return(netBase.SendSingleMessageAtOnce(response, clientConnection, remoteEndpoint));
        }
        /// <summary>
        /// Reads a timestamp written using WriteSendStamp()
        /// </summary>
        public double ReadSentStamp(NetConnection connection)
        {
            if (connection == null)
            {
                throw new ArgumentNullException("connection");
            }
            ushort val = m_buffer.ReadUInt16();
            int    adjustRemoteMillis;
            float  retval = NetTime.FromEncoded((float)NetTime.Now, connection.RemoteClockOffset, val, out adjustRemoteMillis);

            //if (adjustRemoteMillis != 0)
            //	connection.RemoteClockOffset = (connection.RemoteClockOffset + adjustRemoteMillis) % ushort.MaxValue;
            return(retval);
        }
示例#5
0
        internal void HandlePong(double now, NetMessage pongMessage)
        {
            int nr = pongMessage.ReadByte(6);

            if (nr != m_pingNrInProgress)
            {
                m_connection.Parent.Log.Warning("Pong received for wrong ping; received " + nr + " expecting " + m_pingNrInProgress);
                return;
            }
            double roundtrip = now - m_lastSentPing;

            // spike, or can we use this roundtrip?
            double avgRT = pongMessage.Sender.AverageRoundtripTime;

            if (roundtrip > avgRT * 2.0)
            {
                // must be spike
                m_connection.Parent.Log.Verbose("Not adjusting clock due lag spike... (rt " + NetUtil.SecToMil(roundtrip) + " avg " + NetUtil.SecToMil(avgRT) + ")");
            }
            else
            {
                ushort val         = pongMessage.ReadUInt16();
                int    curOffset   = m_connection.RemoteClockOffset;
                int    foundOffset = NetTime.CalculateOffset(now, val, roundtrip);

                int res = NetTime.MergeOffsets(curOffset, foundOffset);

                int rtMillis = (int)(roundtrip * 1000.0);
                if (res != curOffset)
                {
                    //m_connection.Parent.Log.Verbose("Ping: " + rtMillis + " Local: " + NetTime.Encoded(now) + " CurOffset: " + curOffset + " Remote: " + val + " NewOffset: " + res + " (adjusted " + (res - curOffset) + ")");
                    m_connection.Parent.Log.Verbose("Roundtrip: " + rtMillis + " ms; Ajusted remote offset " + (res - curOffset) + " ms");
                    m_connection.RemoteClockOffset = res;
                }
            }

            AddRoundtrip((float)roundtrip);

            if (m_connection.Parent is NetServer)
            {
                // server is authorative on settings optimizing roundtrip numbers
                m_connection.Configuration.OptimizeSettings(m_averageRoundtrip);
                SendOptimizeInfo(m_averageRoundtrip);
            }

            return;
        }
示例#6
0
        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);
            }
        }
示例#7
0
        internal override void HandlePacket(NetBuffer buffer, int bytesReceived, IPEndPoint sender)
        {
            double now = NetTime.Now;

            try
            {
                NetMessage msg;
                if (m_serverConnection == null || m_serverConnection.Status == NetConnectionStatus.Disconnected)
                {
                    //
                    // unconnected packet
                    //
                    msg = NetMessage.Decode(buffer);
                    if (msg == null)
                    {
                        Log.Warning("Malformed NetMessage?");
                        return;                         // malformed?
                    }

                    Log.Verbose("Received unconnected message: " + msg);

                    // discovery response?
                    if (msg.m_type == NetMessageType.Discovery)
                    {
                        NetServerInfo info = NetDiscovery.DecodeResponse(msg, sender);
                        if (ServerDiscovered != null)
                        {
                            ServerDiscovered(this, new NetServerDiscoveredEventArgs(info));
                        }
                        return;
                    }

                    if (m_serverConnection != null && sender.Equals(m_serverConnection.RemoteEndpoint))
                    {
                        // we have m_serverConnection, but status is disconnected
                        Log.Warning("Received " + buffer.LengthBytes + " from server; but we're disconnected!");
                        return;
                    }

                    Log.Warning("Received " + buffer.LengthBytes + " bytes from non-server source: " + sender + "(server is " + m_serverConnection.RemoteEndpoint + ")");
                    return;
                }

                // decrypt in place
                if (m_serverConnection.m_encryption.SymmetricEncryptionKeyBytes != null)
                {
                    byte[] savedBuffer = null;
                    if (m_serverConnection.Status == NetConnectionStatus.Connecting)
                    {
                        // special case; save buffer in case we get unencrypted response
                        savedBuffer = new byte[buffer.LengthBytes];
                        Array.Copy(buffer.Data, 0, savedBuffer, 0, buffer.LengthBytes);
                    }

                    bool ok = m_serverConnection.m_encryption.DecryptSymmetric(buffer);
                    if (!ok)
                    {
                        // failed to decrypt; drop this packet UNLESS we're in a connecting state,
                        // in which case the server may want to tell us something
                        if (m_serverConnection.Status == NetConnectionStatus.Connecting)
                        {
                            // ok let this one thru unencrypted
                            Array.Copy(savedBuffer, buffer.Data, savedBuffer.Length);
                        }
                        else
                        {
                            Log.Warning("Failed to decrypt packet from server!");
                            return;
                        }
                    }
                }

                m_serverConnection.m_lastHeardFromRemote = now;

                int messagesReceived    = 0;
                int usrMessagesReceived = 0;
                int ackMessagesReceived = 0;
                while (buffer.ReadBitsLeft > 7)
                {
                    msg = NetMessage.Decode(buffer);

                    if (msg == null)
                    {
                        break;                         // done
                    }
                    messagesReceived++;
                    msg.Sender = m_serverConnection;
                    switch (msg.m_type)
                    {
                    case NetMessageType.Handshake:
                        NetHandshakeType tp = (NetHandshakeType)msg.ReadByte();
                        if (tp == NetHandshakeType.Connect || tp == NetHandshakeType.ConnectionEstablished)
                        {
                            Log.Warning("Client received " + tp + "?!");
                        }
                        else if (tp == NetHandshakeType.ConnectResponse)
                        {
                            if (m_serverConnection.Status != NetConnectionStatus.Connecting)
                            {
                                Log.Verbose("Received redundant ConnectResponse!");
                                break;
                            }
                            // Log.Debug("ConnectResponse received");
                            m_serverConnection.SetStatus(NetConnectionStatus.Connected, "Connected");
                            Log.Info("Connected to " + m_serverConnection.RemoteEndpoint);

                            // initialize ping to now - m_firstSentConnect
                            float initRoundtrip = (float)(now - m_serverConnection.m_firstSentHandshake);
                            m_serverConnection.m_ping.Initialize(initRoundtrip);

                            ushort remoteValue = msg.ReadUInt16();
                            m_serverConnection.RemoteClockOffset = NetTime.CalculateOffset(now, remoteValue, initRoundtrip);
                            Log.Verbose("Initializing remote clock offset to " + m_serverConnection.RemoteClockOffset + " ms (roundtrip " + NetUtil.SecToMil(initRoundtrip) + " ms)");

                            NetMessage established = new NetMessage(NetMessageType.Handshake, 3);
                            established.Write((byte)NetHandshakeType.ConnectionEstablished);
                            established.WriteSendStamp();
                            SendSingleMessageAtOnce(established, m_serverConnection, m_serverConnection.RemoteEndpoint);
                        }
                        else
                        {                                 // Disconnected
                            string reason = msg.ReadString();
                            m_serverConnection.SetStatus(NetConnectionStatus.Disconnected, reason);
                        }
                        break;

                    case NetMessageType.Acknowledge:
                        //Log.Debug("Received ack " + msg.SequenceChannel + "|" + msg.SequenceNumber);
                        m_serverConnection.ReceiveAcknowledge(msg);
                        ackMessagesReceived++;
                        break;

                    case NetMessageType.PingPong:
                        bool isPong         = msg.ReadBoolean();
                        bool isOptimizeInfo = msg.ReadBoolean();
                        if (isOptimizeInfo)
                        {
                            m_serverConnection.m_ping.HandleOptimizeInfo(now, msg);
                        }
                        else if (isPong)
                        {
                            if (m_serverConnection.Status == NetConnectionStatus.Connected)
                            {
                                m_serverConnection.m_ping.HandlePong(now, msg);
                            }
                        }
                        else
                        {
                            NetPing.ReplyPong(msg, m_serverConnection);
                        }
                        break;

                    case NetMessageType.User:
                    case NetMessageType.UserFragmented:
                        //Log.Debug("User message received; " + msg.m_buffer.LengthBytes + " bytes");
                        m_serverConnection.ReceiveMessage(now, msg);
                        usrMessagesReceived++;
                        break;

                    case NetMessageType.Discovery:
                        NetServerInfo info = NetDiscovery.DecodeResponse(msg, sender);
                        if (ServerDiscovered != null)
                        {
                            ServerDiscovered(this, new NetServerDiscoveredEventArgs(info));
                        }
                        break;

                    default:
                        Log.Warning("Client received " + msg.m_type + "?!");
                        break;
                    }
                }

                // add statistics
                NetStatistics stats = m_serverConnection.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>
 /// Write a timestamp IN THE PAST
 /// </summary>
 public void WriteSendStamp(double pastTimestamp)
 {
     m_buffer.Write(NetTime.Encoded(pastTimestamp));
 }
示例#9
0
        internal static void HandleConnect(NetMessage connectMsg, NetServer server, IPEndPoint senderEndpoint)
        {
            NetMessage response;

            if (server.NumConnected >= server.Configuration.MaximumConnections)
            {
                // server full
                response = new NetMessage(NetMessageType.Handshake, "Server full".Length + 1);
                response.Write((byte)NetHandshakeType.Disconnected);
                response.Write("Server full");
                server.SendSingleMessageAtOnce(response, null, senderEndpoint);
                return;
            }

            ushort remoteNow = connectMsg.ReadUInt16();
            //server.Log.Debug("Setting remote clock based on guess of 50 ms lag...");
            int remoteClockOffset = NetTime.CalculateOffset(NetTime.Now, remoteNow, 0.05);             // assume 50ms...

            // read symmetric key
            int encSymKeyLen = connectMsg.ReadUInt16();

            byte[] encSymKey = null;
            if (encSymKeyLen > 0)
            {
                encSymKey = connectMsg.ReadBytes(encSymKeyLen);
            }

            // read custom data
            int cdLen = (int)connectMsg.Read7BitEncodedUInt();

            byte[] customData = null;
            if (cdLen > 0)
            {
                customData = connectMsg.ReadBytes(cdLen);
            }

            string failReason = null;
            bool   ok         = server.ApproveConnection(senderEndpoint, customData, out failReason);

            if (!ok)
            {
                if (!string.IsNullOrEmpty(failReason))
                {
                    // send disconnect reason; unencrypted, client can handle it because status is connecting
                    response = new NetMessage(NetMessageType.Handshake, failReason.Length + 3);
                    response.Write((byte)NetHandshakeType.Disconnected);
                    response.Write(failReason);
                    server.SendSingleMessageAtOnce(response, null, senderEndpoint);
                }

                // connection not approved
                return;
            }

            NetConnection connection = server.AddConnection(senderEndpoint, remoteClockOffset);

            if (connection == null)
            {
                return;                 // uh oh
            }
            if (encSymKeyLen > 0)
            {
                byte[] symKey = connection.m_encryption.DecryptRSA(encSymKey);
                if (symKey == null)
                {
                    // send disconnect unencrypted, client can handle it because status is connecting
                    string bye = "RSA failed; are you using correct public key?";
                    response = new NetMessage(NetMessageType.Handshake, bye.Length + 3);
                    response.Write((byte)NetHandshakeType.Disconnected);
                    response.Write(bye);
                    server.SendSingleMessageAtOnce(response, null, senderEndpoint);

                    server.Log.Warning("Failed to decrypt RSA encrypted symmetric key from " + senderEndpoint);
                    return;
                }
                connection.m_encryption.SetSymmetricKey(symKey);

                server.Log.Debug("Received Connect containing key: " + Convert.ToBase64String(symKey));
            }
            else
            {
                if (server.Configuration.UsesEncryption)
                {
                    server.Log.Warning("Client tried to connect without encryption from " + senderEndpoint);

                    // denied
                    response = new NetMessage(NetMessageType.Handshake, "Encryption required".Length + 1);
                    response.Write((byte)NetHandshakeType.Disconnected);
                    response.Write("Encryption required");
                    server.SendSingleMessageAtOnce(response, null, senderEndpoint);
                    return;
                }
                server.Log.Debug("Received Connect - using unencrypted connection!");
            }

            // send connect response
            int bytesSent = SendConnectResponse(server, connection, senderEndpoint);

            if (connection != null)
            {
                // account for connectresponse
                connection.Statistics.PacketsSent++;
                connection.Statistics.MessagesSent++;
                connection.Statistics.BytesSent += bytesSent;
            }
        }