Exemple #1
0
 public void JoinGame(Network.Connection connection)
 {
     using (Approval url = Facepunch.Pool.Get <Approval>())
     {
         uint num = (uint)ConVar.Server.encryption;
         if (num > 1 && connection.os == "editor" && DeveloperList.Contains(connection.ownerid))
         {
             num = 1;
         }
         url.level      = UnityEngine.Application.loadedLevelName;
         url.levelUrl   = World.Url;
         url.levelSeed  = World.Seed;
         url.levelSize  = World.Size;
         url.checksum   = World.Checksum;
         url.hostname   = ConVar.Server.hostname;
         url.official   = ConVar.Server.official;
         url.encryption = num;
         if (Network.Net.sv.write.Start())
         {
             Network.Net.sv.write.PacketID(Message.Type.Approved);
             url.WriteToStream(Network.Net.sv.write);
             Network.Net.sv.write.Send(new SendInfo(connection));
         }
         connection.encryptionLevel = num;
         connection.encryptOutgoing = true;
     }
     connection.connected = true;
 }
 private void OnValidateAuthTicketResponse(ulong SteamId, ulong OwnerId, ServerAuth.Status Status)
 {
     if (Auth_Steam.ValidateConnecting(SteamId, OwnerId, Status))
     {
         return;
     }
     Network.Connection connection = ((IEnumerable <Network.Connection>)((Network.Server)Network.Net.sv).connections).FirstOrDefault <Network.Connection>((Func <Network.Connection, bool>)(x => x.userid == (long)SteamId));
     if (connection == null)
     {
         Debug.LogWarning((object)("Steam gave us a " + (object)Status + " ticket response for unconnected id " + (object)SteamId));
     }
     else if (Status == null)
     {
         Debug.LogWarning((object)("Steam gave us a 'ok' ticket response for already connected id " + (object)SteamId));
     }
     else
     {
         if (Status == 5)
         {
             return;
         }
         connection.authStatus = (__Null)Status.ToString();
         ((Network.Server)Network.Net.sv).Kick(connection, "Steam: " + Status.ToString());
     }
 }
    private void SpawnNewPlayer(Network.Connection connection)
    {
        BasePlayer.SpawnPoint spawnPoint = ServerMgr.FindSpawnPoint();
        BasePlayer            player     = GameManager.server.CreateEntity("assets/prefabs/player/player.prefab", spawnPoint.pos, spawnPoint.rot, true).ToPlayer();

        if (Interface.CallHook("OnPlayerSpawn", (object)player) != null)
        {
            return;
        }
        player.health                = 0.0f;
        player.lifestate             = BaseCombatEntity.LifeState.Dead;
        player.ResetLifeStateOnSpawn = false;
        player.limitNetworking       = true;
        player.Spawn();
        player.limitNetworking = false;
        player.PlayerInit(connection);
        if (SleepingBag.FindForPlayer(player.userID, true).Length == 0 && !player.hasPreviousLife)
        {
            player.Respawn();
        }
        else
        {
            player.SendRespawnOptions();
        }
        DebugEx.Log((object)(((object)player.net.get_connection()).ToString() + " joined [" + (object)player.net.get_connection().os + "/" + (object)(ulong)player.net.get_connection().ownerid + "]"), (StackTraceLogType)0);
    }
 private void messageReceived(Packet packet, Connection connection)
 {
     TalkPacket request = (TalkPacket)packet;
     TalkPacket response = new TalkPacket();
     response.Message = "Message returning from server: " + request.Message;
     connection.Send(response);
 }
Exemple #5
0
    private void SpawnNewPlayer(Network.Connection connection)
    {
        BasePlayer.SpawnPoint spawnPoint = ServerMgr.FindSpawnPoint();
        BasePlayer            player     = GameManager.server.CreateEntity("assets/prefabs/player/player.prefab", spawnPoint.pos, spawnPoint.rot, true).ToPlayer();

        if (Interface.CallHook("OnPlayerSpawn", player) != null)
        {
            return;
        }
        player.health                = 0f;
        player.lifestate             = BaseCombatEntity.LifeState.Dead;
        player.ResetLifeStateOnSpawn = false;
        player.limitNetworking       = true;
        player.Spawn();
        player.limitNetworking = false;
        player.PlayerInit(connection);
        if (SleepingBag.FindForPlayer(player.userID, true).Length != 0 || player.hasPreviousLife)
        {
            player.SendRespawnOptions();
        }
        else
        {
            player.Respawn();
        }
        DebugEx.Log(string.Concat(new object[] { player.net.connection.ToString(), " joined [", player.net.connection.os, "/", player.net.connection.ownerid, "]" }), StackTraceLogType.None);
    }
 public void JoinGame(Network.Connection connection)
 {
     using (Approval approval = (Approval)Pool.Get <Approval>())
     {
         uint num = (uint)ConVar.Server.encryption;
         if (num > 1U && (string)connection.os == "editor" && DeveloperList.Contains((ulong)connection.ownerid))
         {
             num = 1U;
         }
         approval.level      = (__Null)Application.get_loadedLevelName();
         approval.levelUrl   = (__Null)World.Url;
         approval.levelSeed  = (__Null)(int)World.Seed;
         approval.levelSize  = (__Null)(int)World.Size;
         approval.checksum   = (__Null)World.Checksum;
         approval.hostname   = (__Null)ConVar.Server.hostname;
         approval.official   = (__Null)(ConVar.Server.official ? 1 : 0);
         approval.encryption = (__Null)(int)num;
         if (((Write)((NetworkPeer)Network.Net.sv).write).Start())
         {
             ((Write)((NetworkPeer)Network.Net.sv).write).PacketID((Message.Type) 3);
             approval.WriteToStream((Stream)((NetworkPeer)Network.Net.sv).write);
             ((Write)((NetworkPeer)Network.Net.sv).write).Send(new SendInfo(connection));
         }
         connection.encryptionLevel = (__Null)(int)num;
         connection.encryptOutgoing = (__Null)1;
     }
     connection.connected = (__Null)1;
 }
Exemple #7
0
 public override ulong GetStat(Network.Connection connection, NetworkPeer.StatTypeLong type)
 {
     if (this.peer == null)
     {
         return((ulong)0);
     }
     return(this.peer.GetStat(connection, type));
 }
        private void connectionEstablished(Connection connection, ConnectionType connectionType)
        {
            TalkPacket talkPacket = new TalkPacket();
            talkPacket.Message = "Hello World!";

            Console.WriteLine("Client: Connection Established!");
            connection.Send(talkPacket);
        }
 public static void OnEnterVisibility(Network.Connection connection, Group group)
 {
     if (!((Network.Server)Network.Net.sv).IsConnected() || !((Write)((NetworkPeer)Network.Net.sv).write).Start())
     {
         return;
     }
     ((Write)((NetworkPeer)Network.Net.sv).write).PacketID((Message.Type) 19);
     ((Write)((NetworkPeer)Network.Net.sv).write).GroupID((uint)group.ID);
     ((Write)((NetworkPeer)Network.Net.sv).write).Send(new SendInfo(connection));
 }
Exemple #10
0
 public override string GetDebug(Network.Connection connection)
 {
     if (this.peer == null)
     {
         return("");
     }
     if (connection == null)
     {
         return(this.peer.GetStatisticsString((ulong)0));
     }
     return(this.peer.GetStatisticsString(connection.guid));
 }
Exemple #11
0
 public static void OnEnterVisibility(Network.Connection connection, Group group)
 {
     if (!Network.Net.sv.IsConnected())
     {
         return;
     }
     if (Network.Net.sv.write.Start())
     {
         Network.Net.sv.write.PacketID(Message.Type.GroupEnter);
         Network.Net.sv.write.GroupID(group.ID);
         Network.Net.sv.write.Send(new SendInfo(connection));
     }
 }
Exemple #12
0
    public void OnDisconnected(string strReason, Network.Connection connection)
    {
        this.connectionQueue.RemoveConnection(connection);
        ConnectionAuth.OnDisconnect(connection);
        SteamServer.EndSession(connection.userid);
        EACServer.OnLeaveGame(connection);
        BasePlayer basePlayer = connection.player as BasePlayer;

        if (basePlayer)
        {
            Interface.CallHook("OnPlayerDisconnected", basePlayer, strReason);
            basePlayer.OnDisconnected();
        }
    }
    public void OnDisconnected(string strReason, Network.Connection connection)
    {
        this.connectionQueue.RemoveConnection(connection);
        ConnectionAuth.OnDisconnect(connection);
        Global.get_SteamServer().get_Auth().EndSession((ulong)connection.userid);
        EACServer.OnLeaveGame(connection);
        BasePlayer player = connection.player as BasePlayer;

        if (!Object.op_Implicit((Object)player))
        {
            return;
        }
        Interface.CallHook("OnPlayerDisconnected", (object)player, (object)strReason);
        player.OnDisconnected();
    }
Exemple #14
0
 private void DoTick()
 {
     if (SteamServer.IsValid)
     {
         Interface.CallHook("OnTick");
         SteamServer.RunCallbacks();
     }
     RCon.Update();
     for (int i = 0; i < Network.Net.sv.connections.Count; i++)
     {
         Network.Connection item = Network.Net.sv.connections[i];
         if (!item.isAuthenticated && item.GetSecondsConnected() >= (float)ConVar.Server.authtimeout)
         {
             Network.Net.sv.Kick(item, "Authentication Timed Out");
         }
     }
 }
 private void DoTick()
 {
     if (Global.get_SteamServer() != null)
     {
         Interface.CallHook("OnTick");
         ((BaseSteamworks)Global.get_SteamServer()).Update();
     }
     RCon.Update();
     for (int index = 0; index < ((List <Network.Connection>)((Network.Server)Network.Net.sv).connections).Count; ++index)
     {
         Network.Connection connection = ((List <Network.Connection>)((Network.Server)Network.Net.sv).connections)[index];
         if (!connection.get_isAuthenticated() && (double)connection.GetSecondsConnected() >= (double)ConVar.Server.authtimeout)
         {
             ((Network.Server)Network.Net.sv).Kick(connection, "Authentication Timed Out");
         }
     }
 }
Exemple #16
0
        public void Process(Connection connection)
        {
            Connection = connection;

            using (Reader = new BinaryReader(new MemoryStream(connection.Buffer)))
            {
                Read();
            }

            try
            {
                Process();
            }
            catch (Exception ex)
            {
                Log.WarnException("ARecvPacket", ex);
            }
        }
Exemple #17
0
        public void Process(Connection connection)
        {
            Connection = connection;

            using (Reader = new BinaryReader(new MemoryStream(connection.Buffer)))
            {
                Read();
            }

            try
            {
                Process();
            }
            catch (Exception ex)
            {
                Logger.WriteLine(LogState.Warn, "ARecvPacket:" + ex);
            }
        }
Exemple #18
0
        // BasePlayer.PlayerInit()
        public static void PlayerConnected(Network.Connection connection)
        {
            var player = connection.player as BasePlayer;
            var p      = new Player(player);

            if (Server.GetServer().OfflinePlayers.ContainsKey(player.userID))
            {
                Server.GetServer().OfflinePlayers.Remove(player.userID);
            }
            if (!Server.GetServer().Players.ContainsKey(player.userID))
            {
                Server.GetServer().Players.Add(player.userID, p);
            }

            OnPlayerConnected.OnNext(p);
            p.Message("Welcome " + p.Name + "!");
            p.Message(String.Format("This server is powered by Pluton[v{0}]!", Bootstrap.Version));
            p.Message("Visit fougerite.com for more information or to report bugs!");
        }
    private bool SpawnPlayerSleeping(Network.Connection connection)
    {
        BasePlayer sleeping = BasePlayer.FindSleeping((ulong)connection.userid);

        if (Object.op_Equality((Object)sleeping, (Object)null))
        {
            return(false);
        }
        if (!sleeping.IsSleeping())
        {
            Debug.LogWarning((object)"Player spawning into sleeper that isn't sleeping!");
            sleeping.Kill(BaseNetworkable.DestroyMode.None);
            return(false);
        }
        sleeping.PlayerInit(connection);
        sleeping.inventory.SendSnapshot();
        DebugEx.Log((object)(((object)sleeping.net.get_connection()).ToString() + " joined [" + (object)sleeping.net.get_connection().os + "/" + (object)(ulong)sleeping.net.get_connection().ownerid + "]"), (StackTraceLogType)0);
        return(true);
    }
Exemple #20
0
    private bool SpawnPlayerSleeping(Network.Connection connection)
    {
        BasePlayer basePlayer = BasePlayer.FindSleeping(connection.userid);

        if (basePlayer == null)
        {
            return(false);
        }
        if (!basePlayer.IsSleeping())
        {
            UnityEngine.Debug.LogWarning("Player spawning into sleeper that isn't sleeping!");
            basePlayer.Kill(BaseNetworkable.DestroyMode.None);
            return(false);
        }
        basePlayer.PlayerInit(connection);
        basePlayer.inventory.SendSnapshot();
        DebugEx.Log(string.Concat(new object[] { basePlayer.net.connection.ToString(), " joined [", basePlayer.net.connection.os, "/", basePlayer.net.connection.ownerid, "]" }), StackTraceLogType.None);
        return(true);
    }
Exemple #21
0
        public static void PlayerConnected(Network.Connection connection)
        {
            var player = connection.player as BasePlayer;
            var p      = new Player(player);

            if (Server.GetInstance().OfflinePlayers.ContainsKey(player.userID))
            {
                Server.GetInstance().OfflinePlayers.Remove(player.userID);
            }
            if (!Server.GetInstance().Players.ContainsKey(player.userID))
            {
                Server.GetInstance().Players.Add(player.userID, p);
            }

            OnPlayerConnected.OnNext(p);
            if (Config.GetInstance().GetBoolValue("Config", "welcomeMessage", true))
            {
                p.Message("Welcome " + p.Name + "!");
                p.Message(String.Format("This server is powered by Pluton[v{0}]!", Bootstrap.Version));
                p.Message("Visit pluton-team.org for more information or to report bugs!");
            }
        }
Exemple #22
0
 private void OnValidateAuthTicketResponse(Steamworks.SteamId SteamId, Steamworks.SteamId OwnerId, AuthResponse Status)
 {
     if (Auth_Steam.ValidateConnecting(SteamId, OwnerId, Status))
     {
         return;
     }
     Network.Connection str = Network.Net.sv.connections.FirstOrDefault <Network.Connection>((Network.Connection x) => x.userid == SteamId);
     if (str == null)
     {
         UnityEngine.Debug.LogWarning(string.Format("Steam gave us a {0} ticket response for unconnected id {1}", Status, SteamId));
         return;
     }
     if (Status == AuthResponse.OK)
     {
         UnityEngine.Debug.LogWarning(string.Format("Steam gave us a 'ok' ticket response for already connected id {0}", SteamId));
         return;
     }
     if (Status == AuthResponse.VACCheckTimedOut)
     {
         return;
     }
     str.authStatus = Status.ToString();
     Network.Net.sv.Kick(str, string.Concat("Steam: ", Status.ToString()));
 }
 private void connectionEstablished(Connection connection, ConnectionType type)
 {
     Console.WriteLine("Connection established!");
     Console.WriteLine($"{connection.GetType()} connected on port {connection.IPLocalEndPoint.Port}");
     connection.RegisterPacketHandler(typeof(TalkPacket), messageReceived);
 }
 private void messageReceived(Packet packet, Connection connection)
 {
     TalkPacket response = (TalkPacket)packet;
     Console.WriteLine($"Client: Message received! {response.Message}");
 }
Exemple #25
0
        /// <summary>
        /// Replies to the player with a specific message
        /// </summary>
        /// <param name="connection"></param>
        /// <param name="key"></param>
        /// <param name="args"></param>
        private void ReplyWith(Connection connection, string key, params object[] args)
        {
            var player = connection?.player as BasePlayer;

            if (player == null)
            {
                Interface.Oxide.LogInfo(string.Format(lang.GetMessage(key, this), args));
                return;
            }

            player.SendConsoleCommand("chat.add", 0, string.Format(lang.GetMessage(key, this, connection.userid.ToString()), args));
        }
Exemple #26
0
        private object IOnUserApprove(Connection connection)
        {
            // Call out and see if we should reject
            var canlogin = Interface.CallHook("CanClientLogin", connection);
            if (canlogin != null && (!(canlogin is bool) || !(bool)canlogin))
            {
                // Reject the user with the message
                ConnectionAuth.Reject(connection, canlogin.ToString());
                return true;
            }

            return Interface.CallHook("OnUserApprove", connection);
        }
Exemple #27
0
        private object OnUserApprove(Connection connection)
        {
            // Call out and see if we should reject
            object canlogin = Interface.CallHook("CanClientLogin", connection);
            if (canlogin != null)
            {
                // If it's a bool and it's true, let them in
                if (canlogin is bool && (bool)canlogin) return null;

                // If it's a string, reject them with a message
                if (canlogin is string)
                {
                    ConnectionAuth.Reject(connection, (string)canlogin);
                    return true;
                }

                // We don't know what type it is, reject them with it anyway
                ConnectionAuth.Reject(connection, canlogin.ToString());
                return true;
            }
            return null;
        }
Exemple #28
0
        private object IOnUserApprove(Connection connection)
        {
            var id = connection.userid.ToString();
            var ip = Regex.Replace(connection.ipaddress, @":{1}[0-9]{1}\d*", "");

            // Migrate user from 'player' group to 'default'
            if (permission.UserHasGroup(id, "player"))
            {
                permission.AddUserGroup(id, "default");
                permission.RemoveUserGroup(id, "player");
                Interface.Oxide.LogWarning($"Migrated '{id}' to the new 'default' group");
            }

            // Call out and see if we should reject
            var canLogin = Interface.Call("CanClientLogin", connection) ?? Interface.Call("CanUserLogin", connection.username, id, ip);
            if (canLogin != null && (!(canLogin is bool) || !(bool)canLogin))
            {
                // Reject the user with the message
                ConnectionAuth.Reject(connection, canLogin.ToString());
                return true;
            }

            return Interface.Call("OnUserApprove", connection) ?? Interface.Call("OnUserApproved", connection.username, id, ip);
        }
Exemple #29
0
 public AuthEvent(Connection connection)
 {
     Connection = connection;
     Approved = true;
 }
Exemple #30
0
        private object IOnUserApprove(Connection connection)
        {
            // Reject invalid connections
            if (connection.userid == 0 || string.IsNullOrEmpty(connection.username))
            {
                ConnectionAuth.Reject(connection, "Your Steam ID or username is invalid");
                return true;
            }

            // Call out and see if we should reject
            object canlogin = Interface.CallHook("CanClientLogin", connection);
            if (canlogin != null)
            {
                // If it's a bool and it's true, let them in
                if (canlogin is bool && (bool)canlogin) return null;

                // If it's a string, reject them with a message
                if (canlogin is string)
                {
                    ConnectionAuth.Reject(connection, (string)canlogin);
                    return true;
                }

                // We don't know what type it is, reject them with it anyway
                ConnectionAuth.Reject(connection, canlogin.ToString());
                return true;
            }
            return Interface.CallHook("OnUserApprove", connection);
        }
Exemple #31
0
 private object CanBypassQueue(Connection connection)
 {
     return Interface.CallDeprecatedHook("OnBypassQueue", "CanBypassQueue", new DateTime(2016, 8, 1), connection);
 }
Exemple #32
0
 public PlayerKickEvent(Connection connection, string reason)
 {
     Connection = connection;
     Reason = reason;
 }
        /// <summary>
        /// TCPs the or UDP connection closed.
        /// </summary>
        /// <param name="closeReason">The close reason.</param>
        /// <param name="connection">The connection.</param>
        private void tcpOrUdpConnectionClosed(CloseReason closeReason, Connection connection)
        {
            if(connection.GetType().Equals(typeof(TcpConnection)))
            {
                //If it is an tcp connection we have to close all the udp connections.
                this[(TcpConnection)connection].ForEach(c => c.Close(closeReason));
                connections.Remove((TcpConnection)connection);
            }
            else
            {
                //Remove the udp connection from the list.
                this[this[(UdpConnection)connection]].Remove((UdpConnection)connection);
            }

            if (connectionLost != null &&
                connectionLost.GetInvocationList().Length > 0 &&
                connection.GetType().Equals(typeof(TcpConnection)))
                connectionLost(connection, ConnectionType.TCP, closeReason);
            else if (connectionLost != null &&
                connectionLost.GetInvocationList().Length > 0 &&
                connection.GetType().Equals(typeof(UdpConnection)))
                connectionLost(connection, ConnectionType.UDP, closeReason);
        }
Exemple #34
0
 public string UserIDFromConnection(Connection connection)
 {
     return connection.userid.ToString();
 }
Exemple #35
0
        // ConnectionAuth.Approve()
        public static void ClientAuth(ConnectionAuth ca, Connection connection)
        {
            var ae = new Events.AuthEvent(connection);

            OnClientAuth.OnNext(ae);

            ca.m_AuthConnection.Remove(connection);
            if (!ae.approved) {
                ConnectionAuth.Reject(connection, ae._reason);
                return;
            }
            SingletonComponent<ServerMgr>.Instance.ConnectionApproved(connection);
        }