Пример #1
0
        public static void EntityAction(RemoteClient client, MinecraftServer server, IPacket _packet)
        {
            var packet = (EntityActionPacket)_packet;
            switch (packet.Action)
            {
                case EntityActionPacket.EntityAction.Crouch:
                    client.Entity.IsCrouching = true;
                    break;
                case EntityActionPacket.EntityAction.Uncrouch:
                    client.Entity.IsCrouching = false;
                    break;
                case EntityActionPacket.EntityAction.StartSprinting:
                    client.Entity.IsSprinting = true;
                    break;
                case EntityActionPacket.EntityAction.StopSprinting:
                    client.Entity.IsSprinting = false;
                    break;
//                case EntityActionPacket.EntityAction.LeaveBed:
//                    client.Entity.LeaveBed();
//                    break;
            }
            if (packet.Action != EntityActionPacket.EntityAction.LeaveBed) // NOTE: Does this matter?
            {
                // TODO ?
            }
        }
Пример #2
0
        /// <summary>
        /// Handles the packet.
        /// </summary>
        /// <param name="Server">The server.</param>
        /// <param name="Client">The client.</param>
        /// <remarks></remarks>
        public override void HandlePacket(MultiplayerServer Server, RemoteClient Client)
        {
            if (EntityID != Client.PlayerEntity.ID)
            {
                Server.KickPlayer(Client.PlayerEntity.Name, "Hacking!");
                return;
            }

            if (Action == EntityAction.Crouch || Action == EntityAction.UnCrouch)
            {
                Animation animation = Action == EntityAction.Crouch ? Animation.Crouch : Animation.UnCrouch;
                foreach (RemoteClient c in Server.GetClientsInWorldExcept(Server.GetWorld(Client), Client))
                {
                    c.PacketQueue.Enqueue(new AnimationPacket(Client.PlayerEntity.ID, animation));
                }
            }
            if (Action == EntityAction.LeaveBed)
            {
                //Unoccupy the metadata of the block
                Block bed = Server.GetWorld(Client.PlayerEntity).GetBlock(Client.PlayerEntity.OccupiedBed); //Get the block
                bed.Metadata = (byte)(bed.Metadata & ~0x4); // Remove flag
                Server.GetWorld(Client.PlayerEntity).SetBlock(Client.PlayerEntity.OccupiedBed, bed); //Set block

                Client.PlayerEntity.OccupiedBed = null; //Nullify the clients bed position

                Server.EnqueueToAllClients(new AnimationPacket(Client.PlayerEntity.ID, Animation.LeaveBed));
            }
        }
Пример #3
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PacketEventArgs"/> class.
 /// </summary>
 /// <param name="PacketID">The packet ID.</param>
 /// <param name="RemoteClient">The remote client.</param>
 /// <param name="PacketMode">The packet mode.</param>
 /// <param name="Packet">The packet.</param>
 /// <remarks></remarks>
 public PacketEventArgs(PacketID PacketID, RemoteClient RemoteClient, PacketMode PacketMode, Packet Packet)
 {
     this.PacketID = PacketID;
     this.RemoteClient = RemoteClient;
     this.Handled = false;
     this.Packet = Packet;
 }
Пример #4
0
 public static void Handshake(RemoteClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (HandshakePacket)_packet;
     if (packet.ProtocolVersion < PacketReader.ProtocolVersion)
     {
         client.SendPacket(new DisconnectPacket("Outdated client!"));
         return;
     }
     if (packet.ProtocolVersion > PacketReader.ProtocolVersion)
     {
         client.SendPacket(new DisconnectPacket("Outdated server!"));
         return;
     }
     if (server.Clients.Any(c => c.Username == packet.Username))
     {
         client.SendPacket(new DisconnectPacket(""));
         return;
     }
     client.Username = packet.Username;
     client.Hostname = packet.ServerHostname + ":" + packet.ServerPort;
     if (server.Settings.OnlineMode)
         client.AuthenticationHash = CreateHash();
     else
         client.AuthenticationHash = "-";
     if (server.Settings.EnableEncryption)
         client.SendPacket(CreateEncryptionRequest(client, server));
     else
         server.LogInPlayer(client);
 }
Пример #5
0
 public static void Animation(RemoteClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (AnimationPacket)_packet;
     var clients = server.EntityManager.GetKnownClients(client.Entity);
     foreach (var _client in clients)
         _client.SendPacket(packet);
 }
Пример #6
0
 public static void PlayerLook(RemoteClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (PlayerLookPacket)_packet;
     client.Entity.Pitch = packet.Pitch;
     client.Entity.Yaw = packet.Yaw;
     client.Entity.HeadYaw = packet.Yaw;
 }
Пример #7
0
        public override void Send(RemoteClient RemoteClient, Message message)
        {
            if (!(message is NetworkMessage)) throw new Exception("Network IE: Can send only networkmessage");

            message._fromId = RemoteClient.Id.ToString();
            (message as NetworkMessage).FromIP = Addresses[RemoteClient].ToString();
        }
Пример #8
0
 /// <summary>
 /// Initializes a new instance of the <see cref="RespawnPacket"/> class.
 /// </summary>
 /// <param name="client">The client.</param>
 /// <param name="world">The world.</param>
 /// <remarks></remarks>
 public RespawnPacket(RemoteClient client, World world)
 {
     this.Dimension = client.PlayerEntity.Dimension;
     this.Difficulty = world.Level.Difficulty;
     this.GameMode = client.PlayerEntity.GameMode;
     this.WorldHeight = World.Height;
     this.LevelType = world.Level.WorldGenerator.Name;
 }
Пример #9
0
 public override void OnRecived(RemoteClient from, Client to)
 {
     Environment.ParentClient.Log(LogLevel.Info, "{1}: удалить файл {0}",RelativePath,from);
     base.OnRecived(from, to);
     var fs = Environment.ParentClient.FileSystem as MockFS;
     var fsobj = fs.Find(RelativePath);
     if (fsobj == null) return;
     Environment.ParentClient.FileSystem.Delete(fsobj,FSObjectEvents.remote_delete);
 }
Пример #10
0
 public override void OnRecived(RemoteClient from, Client to)
 {
     base.OnRecived(from, to);
     if (!string.IsNullOrEmpty(RelativePath))
     srcFile = Environment.ParentClient.FileSystem.Find(RelativePath) as BaseFile;
     if (srcFile == null)
     {
         throw new Exception(string.Format("File {0} not fount (request from {1})", RelativePath, from.Id));
         Environment.ParentClient.Log(LogLevel.Error, "File {0} not fount (request from {1})", RelativePath, from.Id);
     }
 }
Пример #11
0
        public ChatServer()
        {
            _packetLogger = new PacketLogger();
            _logger = new Logger() { WriteToConsole = true };
            _logger.Load(Path.Combine("logs", string.Format("chat_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
            AppDomain.CurrentDomain.UnhandledException += (s, e) =>
            {
                Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
                Environment.Exit(0);
            };

            _packetLogger.Load("chat_packets.log");

            _logger.Info("Loading chat_config.xml...");
            ChatConfig.Load();
            _logger.Info("Setting up servers...");
            _server = new TcpServer(IPAddress.Parse(ChatConfig.Instance.IP), ChatConfig.Instance.Port);
            _server.PacketReceived += HandlePacket;
            _server.ClientDisconnected += ClientDisconnected;
            _server.Error += Error;

            var isMono = Type.GetType("Mono.Runtime") != null;
            switch (ChatConfig.Instance.AuthRemote.Binding)
            {
                case "pipe":
                    if (isMono)
                    {
                        _logger.Error("pipe is not supported in mono, use http!");
                        Environment.Exit(1);
                        return;
                    }
                    _authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("localhost/AuthServer/{0}/", SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password)));
                    break;

                case "tcp":
                    if (isMono)
                    {
                        _logger.Error("pipe is not supported in mono, use http!");
                        Environment.Exit(1);
                        return;
                    }
                    _authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("{0}:{1}/AuthServer/{2}/", ChatConfig.Instance.AuthRemote.Server, ChatConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password)));
                    break;

                case "http":
                    _authRemoteClient = new RemoteClient(ERemoteBinding.Http, string.Format("{0}:{1}/AuthServer/{2}/", ChatConfig.Instance.AuthRemote.Server, ChatConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(ChatConfig.Instance.AuthRemote.Password)));
                    break;

                default:
                    _logger.Error("Invalid remote binding '{0}' for AuthRemote", ChatConfig.Instance.AuthRemote.Binding);
                    Environment.Exit(1);
                    break;
            }
        }
Пример #12
0
 public override void MessageRecieved(RemoteClient client, byte[] data)
 {
     if (ServerPingReceived != null)
     {
         var stream = new MinecraftStream(new MemoryStream(data));
         var eventArgs = new ServerPingEventArgs(
             stream.ReadInt32(),
             stream.ReadString(),
             stream.ReadInt32());
         ServerPingReceived(this, eventArgs);
     }
 }
Пример #13
0
        public static void ClientStatus(RemoteClient client, MinecraftServer server, IPacket _packet)
        {
            var packet = (ClientStatusPacket)_packet;
            if (packet.Status == ClientStatusPacket.ClientStatus.InitialSpawn)
            {
                // Create a hash for session verification
                AsnKeyBuilder.AsnMessage encodedKey = AsnKeyBuilder.PublicKeyToX509(server.ServerKey);
                byte[] shaData = Encoding.UTF8.GetBytes(client.AuthenticationHash)
                    .Concat(client.SharedKey)
                    .Concat(encodedKey.GetBytes()).ToArray();
                string hash = Cryptography.JavaHexDigest(shaData);

                // Talk to session.minecraft.net
                if (server.Settings.OnlineMode)
                {
                    var webClient = new WebClient();
                    var webReader = new StreamReader(webClient.OpenRead(
                        new Uri(string.Format(sessionCheckUri, client.Username, hash))));
                    string response = webReader.ReadToEnd();
                    webReader.Close();
                    if (response != "YES")
                    {
                        client.Disconnect("Failed to verify username!");
                        return;
                    }
                }

                var eventArgs = new ConnectionEstablishedEventArgs(client);
                server.OnConnectionEstablished(eventArgs);
                if (eventArgs.PermitConnection)
                    server.LogInPlayer(client);
                else
                    client.Disconnect(eventArgs.DisconnectReason);
            }
            else if (packet.Status == ClientStatusPacket.ClientStatus.Respawn)
            {
                var world = client.Entity.World;
                client.Entity.Position = new Vector3(
                    client.Entity.SpawnPoint.X,
                    // FIXME: This seems to drop the player camera from half the height of a login spawn
                    client.Entity.SpawnPoint.Y,
                    client.Entity.SpawnPoint.Z);
                client.Entity.Health = client.Entity.MaxHealth;
                client.Entity.Food = 20;
                client.Entity.FoodSaturation = 20;
                server.EntityManager.SpawnEntity(world, client.Entity);
                client.SendPacket(new UpdateHealthPacket(client.Entity.Health, client.Entity.Food, client.Entity.FoodSaturation));
                client.SendPacket(new RespawnPacket(Dimension.Overworld, server.Settings.Difficulty, client.GameMode, World.Height, world.WorldGenerator.GeneratorName));
                client.SendPacket(new PlayerPositionAndLookPacket(client.Entity.Position.X, client.Entity.Position.Y, client.Entity.Position.Z,
                    client.Entity.Position.Y + PlayerEntity.Height, client.Entity.Yaw, client.Entity.Pitch, true));
            }
        }
Пример #14
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="packet"></param>
 public void HandleChatPacket(RemoteClient client, string chatMessage)
 {
     if (m_customEmotes.ContainsKey(chatMessage.ToLower()))
     {
         var animationController = client.GetComponent<Player.PlayerAnimationController>();
         animationController.PerformEmote(m_customEmotes[chatMessage.ToLower()]);
     }
     else
     {
         AddMessage(client.Username, chatMessage);
         client.SetChatLine(chatMessage);
     }
 }
Пример #15
0
 public static void HeldItemChange(RemoteClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (HeldItemChangePacket)_packet;
     if (packet.SlotIndex < 10 && packet.SlotIndex >= 0)
     {
         // TODO: Move the equipment update packet to an OnPropertyChanged event handler
         client.Entity.SelectedSlot = (short)(InventoryWindow.HotbarIndex + packet.SlotIndex);
         var clients = server.EntityManager.GetKnownClients(client.Entity);
         foreach (var _client in clients)
             _client.SendPacket(new EntityEquipmentPacket(client.Entity.EntityId, EntityEquipmentPacket.EntityEquipmentSlot.HeldItem,
                                                          client.Entity.Inventory[client.Entity.SelectedSlot]));
     }
 }
Пример #16
0
        private void ConnectButtonClick(object sender, RoutedEventArgs e)
        {
            if(string.IsNullOrEmpty(ServerBox.Text) || string.IsNullOrEmpty(PasswordBox.Password))
            {
                System.Windows.MessageBox.Show("You didn't fill in the required fields.", "Error!",
                                    MessageBoxButton.OK,
                                    MessageBoxImage.Error);
                return;
            }

            try
            {
                _server = ServerBox.Text;
                _password = PasswordBox.Password;
                _rmc = new RemoteClient("BasicHttpBinding_IRemote",
                                           new EndpointAddress(_server));

                _rmc.Open();

                if(!_rmc.Authorize(Utility.MD5String(_password)))
                {
                    System.Windows.MessageBox.Show("Invalid password entered!", "Error!", MessageBoxButton.OK,
                                    MessageBoxImage.Error);

                    _rmc.Close();

                    return;
                }

            }
            catch(Exception x)
            {
                System.Windows.MessageBox.Show(string.Format("Something unexpexted happened! Please report this to devs!{0}{1}---------------------------------------------------------------------------{2}{3}",
                    Environment.NewLine,
                    Environment.NewLine,
                    Environment.NewLine,
                    x), "Error!",   MessageBoxButton.OK,
                                    MessageBoxImage.Error);

                _rmc.Close();

                return;
            }

            MessageTab.IsEnabled = true;

            System.Windows.MessageBox.Show("Connection successful!", "Success!", MessageBoxButton.OK, MessageBoxImage.Information);
            _connected = true;
        }
Пример #17
0
 public static void Handshake(RemoteClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (HandshakePacket)_packet;
     if (packet.ProtocolVersion < NetworkManager.ProtocolVersion)
     {
         client.SendPacket(new DisconnectPacket("Outdated client!"));
         return;
     }
     if (packet.ProtocolVersion > NetworkManager.ProtocolVersion)
     {
         client.SendPacket(new DisconnectPacket("Outdated server!"));
         return;
     }
     client.Hostname = packet.ServerHostname + ":" + packet.ServerPort;
 }
Пример #18
0
        public override void OnRecived(RemoteClient from, Client to)
        {
            ////check folder exists

            Environment.ParentClient.Log(LogLevel.Info, "{1}: Создать папку {0}", Name,from);

            base.OnRecived(from, to);
            var fs = Environment.ParentClient.FileSystem;
               var fsobj = fs.Find(RelativePath) as BaseFolder;

               if (fsobj == null)
               fsobj = Environment.ParentClient.FileSystem.CreateFolder(Environment.ParentClient.FileSystem.RootDir, RelativePath, FSObjectEvents.remote_create);

               Environment.ParentClient.FileSystem.CreateFolder(fsobj, Name, FSObjectEvents.remote_create);
        }
Пример #19
0
    public static RemoteClient GetInstance(string applicationName)
    {
        //读取本地信息
        myConfigurationManager = new PPLiveRemoteLibrary.ConfigurationManager();

        //读取并应用配置           
        PPLiveRemoteLibrary.ConfigurationManager.Configure(System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration("/").FilePath);

        //获取远程对象
        manager = System.Activator.CreateInstance(typeof(PPLiveRemoteLibrary.PPLiveRemoteManager)) as PPLiveRemoteLibrary.PPLiveRemoteManager;

        RemoteClient rc = new RemoteClient(applicationName);

        return rc;
    }
Пример #20
0
        public static void PlayerPosition(RemoteClient client, MinecraftServer server, IPacket _packet)
        {
            var packet = (PlayerPositionPacket)_packet;
            client.Entity.FoodExhaustion += (float)client.Entity.Position.DistanceTo(
                new Vector3(packet.X, packet.Y, packet.Z));// *
                //(client.Entity.IsSprinting ? 0.1f : 0.01f); // TODO: Swimming

            if ((packet.Y - client.Entity.Position.Y) > 0)
                client.Entity.PositiveDeltaY += (packet.Y - client.Entity.Position.Y);
            else
                client.Entity.PositiveDeltaY = 0;

            client.Entity.Position = new Vector3(packet.X, packet.Y, packet.Z);
            client.UpdateChunksAsync();
        }
Пример #21
0
 public static void EncryptionKeyResponse(RemoteClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (EncryptionKeyResponsePacket)_packet;
     var decryptedToken = server.CryptoServiceProvider.Decrypt(packet.VerificationToken, false);
     for (int i = 0; i < decryptedToken.Length; i++)
     {
         if (decryptedToken[i] != client.VerificationToken[i])
         {
             client.Disconnect("Unable to authenticate.");
             return;
         }
     }
     client.SharedKey = server.CryptoServiceProvider.Decrypt(packet.SharedSecret, false);
     client.SendPacket(new EncryptionKeyResponsePacket(new byte[0], new byte[0]));
 }
Пример #22
0
        public override void OnRecived(RemoteClient from, Client to)
        {
            Environment.ParentClient.Log(LogLevel.Info, "{1}: загрузить файл {0}", RelativePath,from);
            Environment.ParentClient.Log(LogLevel.Info, "Отправка файла {0} на узел {1}", RelativePath, from);
            base.OnRecived(from, to);

            var newfilename = Path.Combine(ExchageFolder.FullName,specdir, srcFile.Name);
            if (File.Exists(newfilename))
                File.Delete(newfilename);

                if (File.Exists(srcFile.RealPath))
                    File.Copy(srcFile.RealPath, newfilename);
               // else
               //         from.Send(new SendFileMessage());
            from.Send(new SendFileMessage(srcFile,specdir));
        }
Пример #23
0
 public override bool CheckRemoteClientState(RemoteClient rc)
 {
     Client c = null;
     // lock (Clients)
     {
         for (int i = 0; i < Clients.Count; i++)
             if (Clients[i].Id == rc.Id)
             {
                 c = Clients[i];
                 break;
             }
     }
     if (c == null) return false;
     var res = (c.State != ClientStates.Offline);
     return res;
 }
Пример #24
0
        private void Teleport(Point16 from, Point16 to, bool auto)
        {
            Rectangle fromRect = new Rectangle(from.X * 16 - 16, from.Y * 16 - 48, 48, 48);
            Rectangle toRect   = new Rectangle(to.X * 16 - 16, to.Y * 16 - 48, 48, 48);
            Vector2   delta    = new Vector2(toRect.X - fromRect.X, toRect.Y - fromRect.Y);

            if (!Wiring.blockPlayerTeleportationForOneIteration)
            {
                for (int i = 0; i < Main.player.Length; i++)
                {
                    if (Main.player[i].active && !Main.player[i].dead && !Main.player[i].teleporting && fromRect.Intersects(Main.player[i].getRect()))
                    {
                        if (!CanAuto(i) && auto)
                        {
                            continue;
                        }

                        Vector2 newPos = Main.player[i].position + delta;
                        if (Main.netMode == 2)
                        {
                            RemoteClient.CheckSection(i, newPos, 1);
                        }
                        Main.player[i].Teleport(newPos, 0, 0);
                        if (Main.netMode == 2)
                        {
                            NetMessage.SendData(65, -1, -1, null, 0, (float)i, newPos.X, newPos.Y, 0, 0, 0);
                        }
                    }
                }
            }

            if (!auto)
            {
                for (int i = 0; i < Main.npc.Length; i++)
                {
                    if (Main.npc[i].active && !Main.npc[i].teleporting && Main.npc[i].lifeMax > 5 && !Main.npc[i].boss && !Main.npc[i].noTileCollide)
                    {
                        int type = Main.npc[i].type;
                        if (!NPCID.Sets.TeleportationImmune[type] && fromRect.Intersects(Main.npc[i].getRect()))
                        {
                            Main.npc[i].Teleport(Main.npc[i].position + delta, 0, 0);
                        }
                    }
                }
            }
        }
Пример #25
0
        private static async Task AsyncRPC2(string url)
        {
            ConsoleColor color  = ConsoleColor.Cyan;
            RemoteClient client = new RemoteClient();

            ColorConsole.WriteLine("AsyncRPC2 -> var task = await client.GetBodyAsync(url);", color);
            var task = await client.GetBodyAsync(url, "AsyncRPC2", color);

            ColorConsole.WriteLine("AsyncRPC2 -> WasteTime.Waste(2000);", color);
            WasteTime.Waste(2000);
            ColorConsole.WriteLine("AsyncRPC2 -> string html = task;", color);
            string html = task;

            ColorConsole.WriteLine("AsyncRPC2 -> end", color);
            ColorConsole.WriteLine("AsyncRPC2 -> body = ", color);
            ColorConsole.WriteLine(Limit(html, "AsyncRPC2"), color);
        }
Пример #26
0
        public static bool IsPlayerLocalServerOwner(int whoAmI)
        {
            if (Main.netMode == NetmodeID.MultiplayerClient)
            {
                return(Netplay.Connection.Socket.GetRemoteAddress().IsLocalHost());
            }

            for (int i = 0; i < Main.maxPlayers; i++)
            {
                RemoteClient client = Netplay.Clients[i];
                if (client.State == 10 && i == whoAmI && client.Socket.GetRemoteAddress().IsLocalHost())
                {
                    return(true);
                }
            }
            return(false);
        }
Пример #27
0
        public static void EncryptionKeyResponse(RemoteClient client, MinecraftServer server, IPacket _packet)
        {
            var packet = (EncryptionKeyResponsePacket)_packet;
            var decryptedToken = server.CryptoServiceProvider.Decrypt(packet.VerificationToken, false);
            for (int i = 0; i < decryptedToken.Length; i++)
            {
                if (decryptedToken[i] != client.VerificationToken[i])
                {
                    client.Disconnect("Unable to authenticate.");
                    return;
                }
            }
            client.SharedKey = server.CryptoServiceProvider.Decrypt(packet.SharedSecret, false);
            // Create a hash for session verification
            AsnKeyBuilder.AsnMessage encodedKey = AsnKeyBuilder.PublicKeyToX509(server.ServerKey);
            byte[] shaData = Encoding.UTF8.GetBytes(client.ServerId)
                .Concat(client.SharedKey)
                .Concat(encodedKey.GetBytes()).ToArray();
            string hash = Cryptography.JavaHexDigest(shaData);

            // Talk to sessionserver.minecraft.net
            if (server.Settings.OnlineMode)
            {
                var webClient = new WebClient();
                var webReader = new StreamReader(webClient.OpenRead(
                    new Uri(string.Format(sessionCheckUri, client.Username, hash))));
                string response = webReader.ReadToEnd();
                webReader.Close();
                var json = JToken.Parse(response);
                if (string.IsNullOrEmpty(response))
                {
                    client.Disconnect("Failed to verify username!");
                    return;
                }
                client.UUID = json["id"].Value<string>();
            }
            client.NetworkStream = new AesStream(client.NetworkClient.GetStream(), client.SharedKey);
            client.NetworkManager.BaseStream = client.NetworkStream;
            client.EncryptionEnabled = true;
            var eventArgs = new ConnectionEstablishedEventArgs(client);
            server.OnConnectionEstablished(eventArgs);
            if (eventArgs.PermitConnection)
                server.LogInPlayer(client);
            else
                client.Disconnect(eventArgs.DisconnectReason);
        }
Пример #28
0
 public static void ChatMessage(RemoteClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (ChatMessagePacket)_packet;
     //LogProvider.Log("<" + client.Username + "> " + packet.Message, LogImportance.Medium);
     var args = new ChatMessageEventArgs(client, packet.Message);
     server.OnChatMessage(args);
     if (!args.Handled)
     {
         //var team = server.ScoreboardManager.GetPlayerTeam(client.Username);
         string chat;
         //if (team != null)
         //    chat = string.Format("<{0}{1}{2}> {3}", team.PlayerPrefix, client.Username, team.PlayerSuffix, packet.Message);
         //else
             chat = string.Format("<{0}> {1}", client.Username, packet.Message);
         server.SendChat(chat);
     }
 }
Пример #29
0
        public static void Handshake(RemoteClient client, Proxy proxy, IPacket _packet)
        {
            var packet = (HandshakePacket)_packet;

            if (packet.ProtocolVersion < PacketReader.ProtocolVersion)
            {
                client.SendPacket(new DisconnectPacket("Outdated client!"));
                return;
            }
            if (packet.ProtocolVersion > PacketReader.ProtocolVersion)
            {
                client.SendPacket(new DisconnectPacket("Outdated server!"));
                return;
            }
            client.AuthenticationHash = "-";
            client.Username           = packet.Username;
            client.SendPacket(CreateEncryptionRequest(client, proxy));
        }
Пример #30
0
        public static void ChatMessage(RemoteClient client, MinecraftServer server, IPacket _packet)
        {
            var packet = (ChatMessagePacket)_packet;
            //LogProvider.Log("<" + client.Username + "> " + packet.Message, LogImportance.Medium);
            var args = new ChatMessageEventArgs(client, packet.Message);

            server.OnChatMessage(args);
            if (!args.Handled)
            {
                //var team = server.ScoreboardManager.GetPlayerTeam(client.Username);
                ChatMessage chat;
                //if (team != null)
                //    chat = string.Format("<{0}{1}{2}> {3}", team.PlayerPrefix, client.Username, team.PlayerSuffix, packet.Message);
                //else
                chat = new ChatMessage(string.Format("<{0}> {1}", client.Username, packet.Message));
                server.SendChat(chat);
            }
        }
Пример #31
0
        public async Task <List <Product> > GetByNameAsync(GetProductsByNameQuery query)
        {
            var client = new RemoteClient();
            Dictionary <string, string> data = new Dictionary <string, string>();

            data.Add("name", query.Name);

            var response = await client.sendRequest("POST", data);

            List <Product> products = JsonConvert.DeserializeObject <List <Product> >(response);

            foreach (var product in products)
            {
                product.PriceRecords = product.PriceRecords.Where(x => x.CurrencyCode == "ZAR").ToList();
            }

            return(products);
        }
Пример #32
0
        //Обработка запрососа на логин
        private void HandleLogin(RemoteClient client, LoginMessage loginMessage)
        {
            //Находим пользователя в базе, у которого имя и пароль имеют переданные логин и пароль
            var targetaccount = storage.Find(U => U.Name == loginMessage.Name && U.Password == loginMessage.Password);

            //Если пользователя не найдено
            if (targetaccount == null)
            {
                //отправляем ответ, с инфой о том, что пара логин пароль неверна
                client.Send(new Response(StatusCode.IncorrectLoginOrPassword));
                //Ну и больше ничего не делаем
                return;
            }
            //нашли пользователя, который подходит по переданным параметрам
            client.UserView = targetaccount;
            //Отправляем сообщение что всё хорошо, пользотель вошел
            client.Send(Response.GoodResponse);
        }
Пример #33
0
        public override void Execute(Server server, RemoteClient user, string text, params string[] parameters)
        {
            if (parameters.Length < 2)
            {
                user.SendChat(ChatColors.Red + "Insufficient parameters. Use \"/help tell\" for more information.");
                return;
            }
            var client = server.MinecraftServer.GetClient(parameters[0]);

            if (client == null)
            {
                user.SendChat(parameters[0] + " is not online.");
                return;
            }
            var format = server.SettingsProvider.Get <string>("chat.private.format");

            client.SendChat(string.Format(format, user.Username, client.Username, text));
        }
Пример #34
0
        public override void Execute(Server server, RemoteClient user, string text, params string[] parameters)
        {
            if (parameters.Length != 1)
            {
                user.SendChat(ChatColors.Red + "Invalid parameters. Use /help op for more information.");
                return;
            }
            var groups = server.GetUserGroups(parameters[0]);

            if (groups.Contains("server.op"))
            {
                user.SendChat(ChatColors.Red + "User is already an op.");
                return;
            }
            groups.Add("server.op");
            server.SetUserGroups(parameters[0], groups);
            server.SendChatToGroup("server.op", ChatColors.Gray + user.Username + " adds " + parameters[0] + " to server.op group.");
        }
Пример #35
0
    private void clientDisconnectedHandler(RemoteClient client)
    {
        Log("clientDisconnectedHandler");
        if (
            clientWaitingToMatch != null &&
            clientWaitingToMatch.remoteClient != null &&
            clientWaitingToMatch.remoteClient.ClientID == client.ClientID
            )
        {
            clientWaitingToMatch = null;
        }
        if (clientList.ContainsKey(client.ClientID) && clientList[client.ClientID].remoteOpponent != null)
        {
            server.Disconnect(clientList[client.ClientID].remoteOpponent.remoteClient);
        }

        clientList.Remove(client.ClientID);
    }
Пример #36
0
        /// <summary>
        /// Handles the packet.
        /// </summary>
        /// <param name="Server">The server.</param>
        /// <param name="Client">The client.</param>
        /// <remarks></remarks>
        public override void HandlePacket(ClassicServer Server, RemoteClient Client)
        {
            Client.LoggedIn = true;
            Client.UserName = UserNameOrServerName;
            Client.World    = Server.MainLevel;
            Client.PacketQueue.Enqueue(new IdentificationPacket(Server.Server.Name, Server.Server.MotD, Client.UserType));
            Client.PlayerID = (byte)(Server.Clients.Count() - 1);
            Client.PacketQueue.Enqueue(new WorldInitializePacket());

            MemoryStream ms = new MemoryStream();
            GZipStream   s  = new GZipStream(ms, CompressionMode.Compress, true);

            s.Write(BitConverter.GetBytes(IPAddress.HostToNetworkOrder(World.Find(Client.World).Data.Length)), 0, sizeof(int));
            s.Write(World.Find(Client.World).Data, 0, World.Find(Client.World).Data.Length);
            s.Close();
            byte[] data = ms.GetBuffer();
            ms.Close();

            double numChunks  = data.Length / 1024;
            double chunksSent = 0;

            for (int i = 0; i < data.Length; i += 1024)
            {
                byte[] chunkData = new byte[1024];

                short chunkLength = 1024;
                if (data.Length - i < chunkLength)
                {
                    chunkLength = (short)(data.Length - i);
                }

                Array.Copy(data, i, chunkData, 0, chunkLength);

                Client.PacketQueue.Enqueue(new WorldDataChunkPacket(chunkLength, chunkData, (byte)((chunksSent / numChunks) * 100)));
                chunksSent++;
            }

            Client.PacketQueue.Enqueue(new WorldFinalizePacket(World.Find(Client.World).Width, World.Find(Client.World).Height, World.Find(Client.World).Depth));
            Client.Position = World.Find(Client.World).Spawn.Clone();
            Client.Yaw      = 0; Client.Pitch = 0;
            unchecked { Client.PacketQueue.Enqueue(new PositionAndOrientationPacket((byte)-1, Client.Position, Client.Yaw, Client.Pitch)); }
            Server.LoadAllClientsToClient(Client);
            Server.EnqueueToAllClientsInWorld(new SpawnPlayerPacket(Client.PlayerID, Client.UserName, Client.Position, Client.Yaw, Client.Pitch), Client.World, Client);
        }
Пример #37
0
        public override void Execute(Server server, RemoteClient user, string text, params string[] parameters)
        {
            string   player = user.Username;
            GameMode gameMode;

            if (parameters.Length == 0 || parameters.Length > 2)
            {
                user.SendChat(ChatColors.Red + "Incorrect usage. Use /help gamemode for more information.");
                return;
            }
            int value;

            if (int.TryParse(parameters[0], out value))
            {
                if (value < 0 || value > 2)
                {
                    user.SendChat(ChatColors.Red + "Incorrect usage. Use /help gamemode for more information.");
                    return;
                }
                gameMode = (GameMode)value;
            }
            else
            {
                if (!Enum.TryParse <GameMode>(parameters[0], true, out gameMode))
                {
                    user.SendChat(ChatColors.Red + "Incorrect usage. Use /help gamemode for more information.");
                    return;
                }
            }
            if (parameters.Length == 2)
            {
                player = parameters[1];
            }
            var client = server.MinecraftServer.GetClient(player);

            if (client == null)
            {
                user.SendChat(ChatColors.Red + player + " is not online."); // TODO: Set it anyway
                return;
            }
            client.GameMode = gameMode;
            server.SendChatToGroup("server.op", ChatColors.Gray + user.Username + " sets " + player + " to " + gameMode + " mode.");
        }
Пример #38
0
        static void Main(string[] args)
        {
            try
            {
                RemoteClient client = new RemoteClient();

                while (true)
                {
                    Console.WriteLine("1. Ping");
                    Console.WriteLine("2. Echo");
                    Console.WriteLine("3. Login");
                    Console.WriteLine("Enter command:");
                    var choose = int.Parse(Console.ReadLine());
                    switch (choose)
                    {
                    case 1: Console.WriteLine(client.Ping()); break;

                    case 2:
                        Console.WriteLine("Enter text: ");
                        var text = Console.ReadLine();
                        Console.WriteLine(client.Echo(text));
                        break;

                    case 3:
                        Console.WriteLine("Enter name: ");
                        var name = Console.ReadLine();
                        Console.WriteLine("Enter pass: "******"Press <ENTER> to terminate client.");
                Console.ReadLine();
            }
            catch (EndpointNotFoundException ex)
            {
                Console.WriteLine("Service endpoint not found: {0}", ex.Message);
                Console.ReadLine();
            }
        }
Пример #39
0
        static void Main(string[] args)
        {
            var data = new string[]
            {
                "1",
                "2",
                "3"
            };

            var remoteService = new RemoteService();
            var remoteClient  = new RemoteClient(remoteService);

            var result = remoteClient.SendData(data);

            foreach (var item in result.Exceptions)
            {
                System.Console.WriteLine(item.Message);
            }
        }
Пример #40
0
        public override void Execute(Server server, RemoteClient user, string text, params string[] parameters)
        {
            if (parameters.Length > 2 || parameters.Length == 0)
            {
                user.SendChat(ChatColors.Red + "Incorrect usage. Use /help speed for more information.");
                return;
            }
            if (parameters[0].ToLower() == "reset")
            {
                user.Entity.Abilities.WalkingSpeed = 12;
                user.Entity.Abilities.FlyingSpeed  = 24;
                return;
            }
            string player = user.Username;
            int    speed;

            if (parameters.Length == 2)
            {
                player = parameters[0];
                if (!int.TryParse(parameters[1], out speed))
                {
                    user.SendChat(ChatColors.Red + "Incorrect usage. Use /help speed for more information.");
                    return;
                }
            }
            else
            {
                if (!int.TryParse(parameters[0], out speed))
                {
                    user.SendChat(ChatColors.Red + "Incorrect usage. Use /help speed for more information.");
                    return;
                }
            }
            var client = server.MinecraftServer.GetClient(player);

            if (client == null)
            {
                user.SendChat(ChatColors.Red + player + " is not online.");
                return;
            }
            client.Entity.Abilities.WalkingSpeed = (byte)speed;
            client.Entity.Abilities.FlyingSpeed  = (byte)(speed * 2);
        }
Пример #41
0
        /// <summary>
        /// Disconnects this connection.
        /// </summary>
        public void Disconnect()
        {
            if (_disconnectCalls > 0)
            {
                return;
            }

            _disconnectCalls++;
            _writeDone.WaitOne();

            try
            {
                ClientDisconnected(this, EventArgs.Empty);
            }
            catch
            {
                // ignore
            }

            try
            {
#if !NET452
                RemoteClient.Dispose();
                SecureStream?.Dispose();
                NetworkStream?.Dispose();
#else
                RemoteClient.Close();
                SecureStream?.Close();
                NetworkStream?.Close();
#endif
            }
            catch
            {
                // ignored
            }
            finally
            {
                NetworkStream            = null;
                SecureStream             = null;
                RemoteClient             = null;
                _continuousReadingThread = null;
            }
        }
Пример #42
0
    private IEnumerator ConnectServer()
    {
        rc            = new RemoteClient(ml);
        rc.evtHandler = EvtHandler;
        rc.msgHandler = MsgHandler;

        rc.Connect("127.0.0.1", 12031);
        while (lastEvt == RemoteClientEvent.None)
        {
            yield return(null);
        }
        if (lastEvt == RemoteClientEvent.Connected)
        {
            //var logic = gameObject.AddComponent<Logic>();
            //logic.Init();
            var mobaLogic = gameObject.AddComponent <MobaLogic>();
            mobaLogic.Init();
        }
    }
Пример #43
0
        public static void ClientStatus(RemoteClient client, Proxy proxy, IPacket _packet)
        {
            var packet = (ClientStatusPacket)_packet;

            if (packet.Status == ClientStatusPacket.ClientStatus.InitialSpawn)
            {
                // Throw them into an empty world and inform them that we'll be connecting them shortly.
                client.SendPacket(new LoginRequestPacket(1, "FLAT", GameMode.Creative, Dimension.Overworld, Difficulty.Normal, 100));
                client.SendPacket(new PlayerAbilitiesPacket(0, 0.05f, 0.1f));
                client.SendPacket(new EntityPropertiesPacket(1, new[] { new EntityProperty("generic.movementSpeed", 0.05f) }));
                client.SendPacket(new PlayerPositionAndLookPacket(0, 1.72, 0, 0.1, 0, 0, false));
                client.SendChat(ChatColors.Yellow + "Connecting to the classic server, please wait.");
                proxy.Connect(client);
            }
            else if (packet.Status == ClientStatusPacket.ClientStatus.Respawn)
            {
                // TODO
            }
        }
Пример #44
0
    /// <summary>
    /// Connect to DF, and register basic RPC functions.
    /// </summary>
    void Connect()
    {
        blockRequest.blocks_needed = BlocksToFetch;
        networkClient = new RemoteClient(dfNetworkOut);
        bool success = networkClient.Connect();

        if (!success)
        {
            networkClient.Disconnect();
            networkClient = null;
            ModalPanel.Instance.Choice(
                "Armok Vision could not find a running instance of Dwarf Fortress!\n\n" +
                "Please make sure you have Dwarf Fortress running, with the latest version of DFHack installed.", Connect, QuitGame, "Retry", "Quit");
            throw new UnityException("DF Connection Failure");
        }

        BindStaticMethods();

        if (dfWorldInfoCall != null)
        {
            dfWorldInfoCall.TryExecute(null, out netWorldInfo);
            if (netWorldInfo == null)
            {
                Debug.Log("World not loaded.");
            }
            else
            {
                Debug.Log("World Mode: " + netWorldInfo.mode);
                WorldMode = netWorldInfo.mode;
            }
        }



        if (GameSettings.Instance.game.askToUpdatePlugin)
        {
            CheckPlugin();
        }
        else
        {
            Init();
        }
    }
            /// <summary>
            /// Initializes a new instance of the <see cref="TcpClientConnectionHandler" /> class.
            /// </summary>
            /// <param name="server">The underlying server.</param>
            /// <param name="client">The underlying client.</param>
            /// <exception cref="ArgumentNullException">
            /// At least one argument is <see langword="null" />.
            /// </exception>
            public TcpClientConnectionHandler(Server server, RemoteClient client)
            {
                if (server == null)
                {
                    throw new ArgumentNullException("server");
                }

                if (client == null)
                {
                    throw new ArgumentNullException("client");
                }

                this._STREAM = new NetworkStream(client.Client.Client, true);

                this._REMOTE_CLIENT = client;
                this._SERVER = server;

                this.CloseConnection = true;
            }
Пример #46
0
        private static async void AsyncRPC1(string url)
        {
            ConsoleColor color  = ConsoleColor.DarkYellow;
            RemoteClient client = new RemoteClient();

            ColorConsole.WriteLine("AsyncRPC1 -> var task = client.GetBodyAsync(url);", color);
            var task = client.GetBodyAsync(url, "AsyncRPC1", color);

            ColorConsole.WriteLine("AsyncRPC1 -> WasteTime.Waste(2000);", color);
            WasteTime.Waste(2000);
            ColorConsole.WriteLine("AsyncRPC1 -> string html = await task;", color);
            string html = await task;

            ColorConsole.WriteLine("AsyncRPC1 -> Task.WaitAll(task);", color);
            Task.WaitAll(task);
            ColorConsole.WriteLine("AsyncRPC1 -> end", color);
            ColorConsole.WriteLine("AsyncRPC1 -> body = ", color);
            ColorConsole.WriteLine(Limit(html, "AsyncRPC1"), color);
        }
Пример #47
0
 public override void Execute(Server server, RemoteClient user, string text, params string[] parameters)
 {
     Server = server;
     if (parameters.Length != 0)
     {
         user.SendChat(ChatColors.Red + "Invalid parameters. Use /help repl for more information.");
         return;
     }
     if (ReplContext.Self != null)
     {
         user.SendChat(ChatColors.Red + ReplContext.Self.Username + " is currently in REPL mode. Only one user may be in REPL mode at a time.");
         // TODO: Upgrade Mono.CSharp to Mono 3.0 and support several REPLs at once
         return;
     }
     server.ChatMessage -= HandleChatMessage;
     server.ChatMessage += HandleChatMessage;
     server.MinecraftServer.PlayerLoggedOut += (s, e) =>
     {
         if (Evaluators.ContainsKey(e.Username))
         {
             Evaluators.Remove(e.Username);
         }
         ReplContext.Self = null;
     };
     Evaluators[user.Username] = new Evaluator(new CompilerContext(new CompilerSettings(), new MinecraftReportPrinter(user)));
     Evaluators[user.Username].ReferenceAssembly(typeof(Server).Assembly);
     Evaluators[user.Username].ReferenceAssembly(typeof(MinecraftServer).Assembly);
     Evaluators[user.Username].ReferenceAssembly(typeof(Craft.Net.Networking.IPacket).Assembly);
     Evaluators[user.Username].ReferenceAssembly(typeof(World).Assembly);
     Evaluators[user.Username].ReferenceAssembly(typeof(IServer).Assembly);
     Evaluators[user.Username].InteractiveBaseClass = typeof(ReplContext);
     Evaluators[user.Username].Run("using Craft.Net");
     Evaluators[user.Username].Run("using Craft.Net.Data");
     Evaluators[user.Username].Run("using Craft.Net.Data.Blocks");
     Evaluators[user.Username].Run("using Craft.Net.Data.Items");
     Evaluators[user.Username].Run("using Craft.Net.Server");
     Evaluators[user.Username].Run("using PartyCraft");
     ReplContext.Self   = user;
     ReplContext.Server = server;
     user.SendChat(ChatColors.Blue + "Entering C# Interactive Mode");
     user.SendChat(ChatColors.Blue + "Use `Exit()` to exit REPL mode.");
 }
Пример #48
0
        public override void Execute(Server server, RemoteClient user, string text, params string[] parameters)
        {
            string player = user.Username;
            int    x      = (int)user.Entity.Position.X;
            int    y      = (int)user.Entity.Position.Y;
            int    z      = (int)user.Entity.Position.Z;

            if (parameters.Length == 1)
            {
                player = parameters[0];
            }
            else if (parameters.Length == 3)
            {
                if (!int.TryParse(parameters[0], out x) &&
                    !int.TryParse(parameters[1], out y) &&
                    !int.TryParse(parameters[2], out z))
                {
                    user.SendChat(ChatColors.Red + "Incorrect usage. Use /help spawnpoint for more information.");
                    return;
                }
            }
            else if (parameters.Length == 4)
            {
                player = parameters[0];
                if (!int.TryParse(parameters[1], out x) &&
                    !int.TryParse(parameters[2], out y) &&
                    !int.TryParse(parameters[3], out z))
                {
                    user.SendChat(ChatColors.Red + "Incorrect usage. Use /help spawnpoint for more information.");
                    return;
                }
            }
            var client = server.MinecraftServer.GetClient(player);

            if (player == null)
            {
                user.SendChat(ChatColors.Red + player + " is not online."); // TODO: Set it anyway
                return;
            }
            client.Entity.SpawnPoint = new Vector3(x, y, z);
            server.SendChatToGroup("server.op", user.Username + " set " + player + " spawn point to " + client.Entity.SpawnPoint);
        }
Пример #49
0
        //Метод обработки конкретного клиента
        private async Task HandleClient(TcpClient client)
        {
            //Оборачиваем TcpClient в наш собственный класс RemoteClient
            //Сделано для сопоставления TCP соединения и нашей моделей пользователя
            //Чтобы понимать, по какому соединению необходимо отправлять данные
            RemoteClient remoteClient = new RemoteClient(
                //Аргументом является функция отправки сообщения
                //Этому клиенту. Мы и пишем, что при отправке сообщения
                //Этому клиенту надо отправить данное сообщение именно на этот client
                R => SendResponseToClient(R, client));

            //Вызываем событие о том, что клиент присоединился.
            //Так внешний код сможет узнать о том, что подсоединился новый клиент
            //И начать следить ща его действиями
            ClientAccepted?.Invoke(remoteClient);
            //Пока не отменили работу
            while (!cancellationToken.IsCancellationRequested)
            {
                //Буффер для хранения длины сообщения
                var messageLength = new byte[4];
                //Буффер для хранения самого сообщения
                var buffer = new byte[4096];
                //Читаем 4 байта, представляющие длину сообщения
                await client.GetStream().ReadAsync(messageLength, 0, 4);

                //Преобразуем эти 4 байта в число
                var length = BitConverter.ToInt32(messageLength, 0);
                //Читаем все сообщение в спец буффер для сообщения
                //Читаем именно нужное нам колчество денег
                await client.GetStream().ReadAsync(buffer, 0, length);

                //Получаем из считанныз байт саму строку JSON
                //которую нам прислал клиент
                var jsonString = Encoding.UTF8.GetString(buffer, 0, length);
                //Разбираем строку и кладем все данные в JToken
                var token = JToken.Parse(jsonString);
                //Выводим сообщение  о том, что мы получили некое сообщение
                Console.WriteLine("Received message");
                //Уведомляем клиента о том, что пришло новое сообщение
                remoteClient.Notify(token);
            }
        }
Пример #50
0
        /// <summary>
        /// Configures the splash screen and initializes the main application form
        /// This runs once the splash screen is visible.
        /// </summary>
        protected override void OnCreateMainForm()
        {
            CommandLineArgs parameters = new CommandLineArgs(CommandLineArgs);

            if (parameters.Hide || !Environment.UserInteractive)
            {
                SplashScreen.SafeInvoke(
                    () => ((TVRenameSplash)SplashScreen).Visible = false, true);
            }

            // Update splash screen
            SplashScreen.SafeInvoke(
                () => ((TVRenameSplash)SplashScreen).UpdateStatus("Initializing"), true);

            // Update RegVersion to bring the WebBrowser up to speed
            RegistryHelper.UpdateBrowserEmulationVersion();

            TVDoc doc = LoadSettings(parameters);

            if (TVSettings.Instance.mode == TVSettings.BetaMode.BetaToo || TVSettings.Instance.ShareLogs)
            {
                SetupLogging();
            }

            // Show user interface
            UI ui = new UI(doc, (TVRenameSplash)SplashScreen, !parameters.Unattended && !parameters.Hide && Environment.UserInteractive);

            ui.Text = ui.Text + " " + Helpers.DisplayVersion;

            // Bind IPC actions to the form, this allows another instance to trigger form actions
            try
            {
                RemoteClient.Bind(ui);
            }
            catch (RemotingException ex)
            {
                Logger.Warn(
                    $"Could not create IPC Port: {ex.Message} : TV Rename will not be able to accept incoming commands");
            }

            MainForm = ui;
        }
Пример #51
0
        public static void PlayerPosition(RemoteClient client, MinecraftServer server, IPacket _packet)
        {
            var packet = (PlayerPositionPacket)_packet;

            client.Entity.FoodExhaustion += (float)client.Entity.Position.DistanceTo(
                new Vector3(packet.X, packet.Y, packet.Z));// *
            //(client.Entity.IsSprinting ? 0.1f : 0.01f); // TODO: Swimming

            if ((packet.Y - client.Entity.Position.Y) > 0)
            {
                client.Entity.PositiveDeltaY += (packet.Y - client.Entity.Position.Y);
            }
            else
            {
                client.Entity.PositiveDeltaY = 0;
            }

            client.Entity.Position = new Vector3(packet.X, packet.Y, packet.Z);
            client.UpdateChunksAsync();
        }
Пример #52
0
        public static void SyncError(RemoteClient Sender, Dictionary <String, Object> ErrorLog0, Dictionary <String, Object> ErrorLog1, Dictionary <String, Object> ErrorLog2)
        {
            string level = StormLib.Console.GetValue("Debugging_Level").Value;

            switch (level)
            {
            default:
            case "0":
                // Sender.SyncError(ErrorLog0);
                break;

            case "1":
                //  Sender.SyncError(ErrorLog1);
                break;

            case "2":
                //  Sender.SyncError(ErrorLog2);
                break;
            }
        }
Пример #53
0
    private void Server_OnClientDisconnected(RemoteClient client)
    {
        logLine("Client disconnected: " + client.RemoteEndpoint.ToString());

        clients--;
        NumClientsText.text = clients.ToString() + "/" + MaxClients.ToString();

        /*Destroy(players[client].gameObject);
         * players.Remove(client);
         * endpointsByClient[client].Reset();
         * endpointsByClient.Remove(client);
         */
        PLAYER_DISCONNECTED.Send(client);

        //if less than 1 player -> stop send position data to clients
        if (players.Count < 1)
        {
            StopCoroutine(updateSender());
        }
    }
Пример #54
0
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            //this.Code.ItemsSource = Encoding.GetEncodings().Select(m => m.DisplayName);
            var rdp = new RemoteClient(Protocol.SSH);

            if (this.Client != null)
            {
                this.SSH.DataContext   = this.Client;
                this.Password.Password = LibRDP.Utils.DecryptChaCha20(this.Client.RInfo.Password, Properties.Settings.Default.Nonce, Properties.Settings.Default.SHA256);
                this.Btn.Content       = "修改";
                this.Window.Header     = "修改" + Protocol.SSH + "桌面参数";
            }
            else
            {
                this.SSH.DataContext = rdp;
                this.Btn.Content     = "添加";

                this.Window.Header = "新建" + Protocol.SSH + "桌面";
            }
        }
Пример #55
0
        public override void HandlePacket(BinaryReader reader, int whoAmI)
        {
            var msgType = (MessageType)reader.ReadByte();

            switch (msgType)
            {
            case MessageType.AddLink:

                var transmitter = new Point16(reader.ReadInt16(), reader.ReadInt16());
                var receiver    = new Point16(reader.ReadInt16(), reader.ReadInt16());
                if (!WirelessUtils.AlreadyExists(transmitter, receiver))
                {
                    WirelessSystem.Links[transmitter] = receiver;
                    if (Main.netMode == NetmodeID.Server)                            //Server-side
                    {
                        SyncAddLink(transmitter, receiver, whoAmI);                  //Broadcast the change to other clients
                    }
                }
                break;

            case MessageType.RemoveLink:
                transmitter = new Point16(reader.ReadInt16(), reader.ReadInt16());
                WirelessSystem.Links.Remove(transmitter);

                if (Main.netMode == NetmodeID.Server)
                {
                    SyncRemoveLink(transmitter, whoAmI);
                }
                break;

            case MessageType.TripWire:
                receiver = new Point16(reader.ReadInt16(), reader.ReadInt16());
                ActivateReceiver(receiver);

                if (Main.netMode == NetmodeID.Server)
                {
                    RemoteClient.CheckSection(whoAmI, receiver.ToWorldCoordinates());
                }
                break;
            }
        }
Пример #56
0
        private static void RunTeleport(Player player, Vector2 pos, bool syncData = false, bool convertFromTiles = false)
        {
            bool postImmune      = player.immune;
            int  postImmunteTime = player.immuneTime;

            if (convertFromTiles)
            {
                pos = new Vector2(pos.X * 16 + 8 - player.width / 2, pos.Y * 16 - player.height);
            }

            LeaveDust(player);

            //Kill hooks
            player.grappling[0] = -1;
            player.grapCount    = 0;
            for (int index = 0; index < 1000; ++index)
            {
                if (Main.projectile[index].active && Main.projectile[index].owner == player.whoAmI && Main.projectile[index].aiStyle == 7)
                {
                    Main.projectile[index].Kill();
                }
            }

            player.Teleport(pos, 2, 0);
            player.velocity   = Vector2.Zero;
            player.immune     = postImmune;
            player.immuneTime = postImmunteTime;

            LeaveDust(player);

            if (Main.netMode != 2)
            {
                return;
            }

            if (syncData)
            {
                RemoteClient.CheckSection(player.whoAmI, player.position, 1);
                NetMessage.SendData(65, -1, -1, null, 0, (float)player.whoAmI, pos.X, pos.Y, 3, 0, 0);
            }
        }
Пример #57
0
 public static void LoginStart(RemoteClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (LoginStartPacket)_packet;
     if (server.Clients.Any(c => c.IsLoggedIn && c.Username == packet.Username))
         client.Disconnect("You're already on this server!");
     else
     {
         client.Username = packet.Username;
         if (server.Settings.OnlineMode)
             client.ServerId = CreateId();
         else
         {
             client.ServerId = CreateId();
             client.UUID = Guid.NewGuid().ToJavaUUID();
         }
         if (server.Settings.EnableEncryption)
            client.SendPacket(CreateEncryptionRequest(client, server));
         else
             server.LogInPlayer(client);
     }
 }
Пример #58
0
        public override void Send(RemoteClient RemoteClient, Messages.Message message)
        {
            ///Remote Client must be offline
            ///this ckeck must be in remoteclient.send

            Tasks.Enqueue(new Task(() =>
            {
                lock (Clients)
                {
                    message.Environment = this;
                    if (!Clients.Any(x => x.Id == RemoteClient.Id)) { ParentClient.Log(LogLevel.Error, "Не могу послать сообщение {0} узлу {1}. Похоже что он оффлайн", message, RemoteClient); return; }
                    var B = Clients.FirstOrDefault(x => x.Id == RemoteClient.Id).Environment;
                    if (B == null) throw new Exception("client not ready or offline");
                    var m = Message.Decode(message.Code(), B);
                    var remote = B.RemoteClients.First(x => x.Id == m.FromId);
                    B.EmitMessageRecived(remote, m);
                }
            }, string.Format("Message {0} to {1} sended", message.Type, RemoteClient.Id)
            ));
            m_signal.Set();
        }
Пример #59
0
        public SendQueue(RemoteClient client)
        {
            this.client = client;
            freeLargeBlocks = new int[maxLargeBlocks];
            freeSmallBlocks = new int[maxSmallBlocks];

            for (int i = 0; i < maxLargeBlocks; i++)
            {
                freeLargeBlocks[i] = 1;
            }

            for (int i = 0; i < maxSmallBlocks; i++)
            {
                freeSmallBlocks[i] = 1;
            }

            queuedLargeBlocks = new bool[maxLargeBlocks];
            queuedSmallBlocks = new bool[maxSmallBlocks];

            largeObjectHeap = new byte[maxLargeBlocks * kSendQueueLargeBlockSize];
            smallObjectHeap = new byte[maxSmallBlocks * kSendQueueSmallBlockSize];
        }
Пример #60
0
 public static void CreativeInventoryAction(RemoteClient client, MinecraftServer server, IPacket _packet)
 {
     var packet = (CreativeInventoryActionPacket)_packet;
     if (packet.SlotIndex == -1)
     {
         var entity = new ItemEntity(client.Entity.Position +
             new Vector3(0, client.Entity.Size.Height, 0), packet.Item);
         entity.Velocity = MathHelper.FowardVector(client.Entity.Yaw) * new Vector3(0.25);
         server.EntityManager.SpawnEntity(client.Entity.World, entity);
     }
     else if (packet.SlotIndex < client.Entity.Inventory.Length && packet.SlotIndex > 0)
     {
         client.Entity.Inventory[packet.SlotIndex] = packet.Item;
         if (packet.SlotIndex == client.Entity.SelectedSlot)
         {
             var clients = server.EntityManager.GetKnownClients(client.Entity);
             foreach (var _client in clients)
                 _client.SendPacket(new EntityEquipmentPacket(client.Entity.EntityId, EntityEquipmentPacket.EntityEquipmentSlot.HeldItem,
                                                              client.Entity.Inventory[packet.SlotIndex]));
         }
     }
 }