Esempio n. 1
0
        /// <summary>
        /// 读取包头
        /// </summary>
        /// <param name="header"></param>
        /// <returns></returns>
        void HandleReadHeader(PacketStream ps, object obj)
        {
            UInt16 thisTag = 0;

            lock (_recvTagGuard)
            {
                thisTag = _recvTag;
            }


            PacketHeader header = PacketSerializer.ReadHeader(ps, thisTag);

            if (header.Valid)
            {
                var size = (Int32)(header.TotalSize - PacketHeader.HeaderSize);

                // 还有包体
                if (size > 0)
                {
                    ReadPacket(new PacketStream(size, HandleReadBody, header));
                }
                else
                {
                    PostPacket(header, null);

                    // 包体没有, 继续读下一个包
                    ReadHeader();
                }
            }
            else
            {
                PostError(SessionEvent.RecvError, new Exception("packet crack"));
                Close();
            }
        }
Esempio n. 2
0
        public void ProcessReceive(SocketAsyncEventArgs e)
        {
            Session.Session session = (Session.Session)e.UserToken;
            if (session == null)
            {
                return;
            }

            if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
            {
                IPacket packet = PacketSerializer.Deserialize(e.MemoryBuffer.ToArray(), e.BytesTransferred);
                session.DoAsync(() =>
                {
                    session.OnReceive(packet);
                });

                bool willRaiseEvent = session.Socket.ReceiveAsync(e);
                if (willRaiseEvent == false)
                {
                    ProcessReceive(e);
                }
            }
            else
            {
                session.DoAsync(() =>
                {
                    SessionManager.Disconnect(session);
                });
            }
        }
Esempio n. 3
0
 public int GetSize()
 {
     return(ChannelID.GetSize() +
            ParentID.GetSize() +
            Name.GetSize() +
            PacketSerializer.GetObjectSize(type));
 }
Esempio n. 4
0
        protected NetworkerServerBase(ServerConfiguration configuration,
                                      INetworkerLogger logger,
                                      IList <INetworkerPacketHandlerModule> modules,
                                      IContainerIoc container)
        {
            this.configuration           = configuration;
            this.Logger                  = logger;
            this.container               = container;
            this.Connections             = new List <TcpConnection>();
            this.packetSerializer        = new PacketSerializer();
            this.packetDeserializer      = new PacketDeserializer();
            this.packetHandlers          = new Dictionary <string, Type>();
            this.packetHandlerSingletons = new Dictionary <string, IServerPacketHandler>();

            foreach (var module in modules)
            {
                this.RegisterTypesFromModule(module);
            }

            this.container.RegisterSingleton <ITcpConnectionsProvider>(
                new TcpConnectionsProvider(this.Connections));
            this.container.RegisterSingleton(logger);

            this.RegisterPacketHandler <PingRequestPacket, PingRequestPacketHandler>();
        }
Esempio n. 5
0
        public void Deserialize_Valid_ReturnsValidXml()
        {
            PacketSerializer serializer = PacketSerializer.Create("application/xml");

            Payment etalon = new Payment {
                OrderId = "1", AmountKop = 100, CardHolderName = "POVYSHEV NIKOLAY", CardNumber = "9999000088881111", CVV = "100", ExpiryMonth = 12, ExpiryYear = 2017
            };

            const string xml = "<?xml version=\"1.0\" encoding=\"utf-8\"?><packet version=\"v1\"><Payment order_id=\"1\" card_number=\"9999000088881111\" expiry_month=\"12\" expiry_year=\"2017\" cvv=\"100\" cardholder_name=\"POVYSHEV NIKOLAY\" amount_kop=\"100\" /></packet>";


            Payment payment = null;

            using (MemoryStream stream = new MemoryStream())
            {
                stream.Write(Encoding.UTF8.GetBytes(xml), 0, xml.Length);
                stream.Position = 0;
                payment         = serializer.Deserialize <Payment>(stream).Content;
            }

            Assert.Equal(etalon.OrderId, payment.OrderId);
            Assert.Equal(etalon.AmountKop, payment.AmountKop);
            Assert.Equal(etalon.CardHolderName, payment.CardHolderName);
            Assert.Equal(etalon.CardNumber, payment.CardNumber);
            Assert.Equal(etalon.CVV, payment.CVV);
            Assert.Equal(etalon.ExpiryMonth, payment.ExpiryMonth);
            Assert.Equal(etalon.ExpiryYear, payment.ExpiryYear);
        }
        public virtual bool Send(BasePacket packet)
        {
            if (!Listening)
            {
                return(false);
            }

            try
            {
                var packetDeserialized = PacketSerializer.Serialize(packet);
                var stream             = TcpClient.GetStream();
                // first we write the size of the packet so we know how much to read later
                Int32 packetSize      = (Int32)packetDeserialized.Length;
                var   packetSizeBytes = BitConverter.GetBytes(packetSize);
                stream.Write(packetSizeBytes, 0, packetSizeBytes.Length);
                stream.Write(packetDeserialized, 0, packetDeserialized.Length);

                if (packet.GetType() != typeof(PingPacket)) // f*****g spam...
                {
                    Log.Debug("Sent Packet " + packet.GetType().Name);
                }
            }
            catch (Exception e)
            {
                if (Listening)
                {
                    Listening = false;
                    DisconnectClient();
                }
            }
            return(Listening);
        }
Esempio n. 7
0
        private static async Task <GatewayRef> StartListen(ActorSystem system, ChannelType channelType, IPEndPoint listenEndPoint)
        {
            var serializer = PacketSerializer.CreatePacketSerializer();

            var initiator = new GatewayInitiator
            {
                ListenEndPoint      = listenEndPoint,
                GatewayLogger       = LogManager.GetLogger($"Gateway({channelType})"),
                CreateChannelLogger = (ep, _) => LogManager.GetLogger($"Channel({ep}"),
                ConnectionSettings  = new TcpConnectionSettings {
                    PacketSerializer = serializer
                },
                PacketSerializer    = serializer,
                CreateInitialActors = (context, connection) => new[]
                {
                    Tuple.Create(
                        context.ActorOf(Props.Create(() =>
                                                     new UserActor(context.Self.Cast <ActorBoundChannelRef>(), CreateUserId()))),
                        new TaggedType[] { typeof(IUser) },
                        ActorBindingFlags.StopThenCloseChannel)
                }
            };

            var gateway = (channelType == ChannelType.Tcp)
                ? system.ActorOf(Props.Create(() => new TcpGateway(initiator)), "TcpGateway").Cast <GatewayRef>()
                : system.ActorOf(Props.Create(() => new UdpGateway(initiator)), "UdpGateway").Cast <GatewayRef>();

            await gateway.Start();

            return(gateway);
        }
Esempio n. 8
0
        static void Main(string[] args)
        {
            // memory for the packet
            MemoryStream memory = new MemoryStream();

            // create a packet
            Packet packet = new Packet(PacketType.Message, Encoding.UTF8.GetBytes("hello, server"));

            // serialize the packet to the memorystream
            PacketSerializer serializer = new PacketSerializer();

            serializer.Serialize(memory, packet);

            // save a copy
            File.WriteAllBytes("TestPacket.bin", memory.ToArray());

            // reset the position of the stream
            memory.Seek(0L, SeekOrigin.Begin);

            // deserialize the packet
            Packet deserialized = serializer.Deserialize(memory);

            // print the packet data
            Console.WriteLine(Encoding.UTF8.GetString(deserialized.Data, 0, (int)deserialized.Length));
            Console.ReadLine();
        }
Esempio n. 9
0
        public virtual bool Send(BasePacket packet)
        {
            try
            {
                var packetDeserialized = PacketSerializer.Serialize(packet);
                var stream             = TcpClient.GetStream();
                // first we write the size of the packet so we know how much to read later
                Int32 packetSize      = (Int32)packetDeserialized.Length;
                var   packetSizeBytes = BitConverter.GetBytes(packetSize);
                stream.Write(packetSizeBytes, 0, packetSizeBytes.Length);
                stream.Write(packetDeserialized, 0, packetDeserialized.Length);

                if (packet.GetType() != typeof(PingPacket)) // f*****g spam...
                {
                    Log.Debug("Sent Packet " + packet.GetType().Name);
                }
            }
            catch (Exception e)
            {
                Log.Error("Error sending packet " + e.Message);
                Log.Error(System.Environment.StackTrace);
                Listening = false;
            }
            return(Listening);
        }
        public void Teststtt()
        {
            var messageFactory  = new MessageFactory(typeof(EnvelopeSerializer_Event), typeof(EnvelopeSerializer_Child_Event));
            var identityFactory = new IdentityFactory(typeof(EnvelopeSerializer_Id));

            var serializer = new ProtobufSerializer();

            serializer.RegisterMessages(messageFactory.MessageDefinitions);
            serializer.RegisterIdentities(identityFactory.IdentityDefinitions);

            var message1 = new EnvelopeSerializer_Event()
            {
                Rate  = 0.7,
                Title = "Muahaha!"
            };

            var packetSerializer = new PacketSerializer(serializer, messageFactory.TagToTypeResolver);

            var packet = new PacketBuilder(messageFactory.TypeToTagResolver, packetSerializer)
                         .AddMessage(message1)
                         .Build();

            var bytes = packet.Serialize();

            var back = new Packet(packetSerializer, bytes);

            var evnt = (EnvelopeSerializer_Event)back.Envelopes.First().Message;

            Assert.That(evnt.Rate, Is.EqualTo(message1.Rate));
            Assert.That(evnt.Title, Is.EqualTo(message1.Title));
        }
Esempio n. 11
0
        public GameProxy(ServerInfo info, ObjectPool <SocketAsyncEventArgs> pool,
                         PacketSerializer serializer, int backlog, int maxClients, TimeSpan timeout)
        {
            if (backlog < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(backlog));
            }

            if (maxClients < 1)
            {
                throw new ArgumentOutOfRangeException(nameof(maxClients));
            }

            Info          = info ?? throw new ArgumentNullException(nameof(info));
            ArgsPool      = pool ?? throw new ArgumentNullException(nameof(pool));
            Serializer    = serializer ?? throw new ArgumentNullException(nameof(serializer));
            Backlog       = backlog;
            MaxClients    = maxClients;
            Timeout       = timeout;
            _serverSocket = new Socket(info.ProxyEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp)
            {
                ExclusiveAddressUse = true,
                NoDelay             = true,
            };
        }
Esempio n. 12
0
        /// <summary>
        /// Sendet ein object an den Server.
        /// </summary>
        /// <param name="bytes"></param>
        public bool SendPacket(object data)
        {
            // Wenn der Client nicht verbunden ist kann nichts gesendet werden.
            if (!tcpClient.Connected)
            {
                return(false);
            }

            try
            {
                // Stream holen und Asynchron das Paket in den Stream schreiben (neuer Thread).
                NetworkStream networkStream = tcpClient.GetStream();
                var           d             = PacketSerializer.Serialize(data);
                networkStream.BeginWrite(d, 0, d.Length, SendCallback, null);
                return(true);
            }
            catch (Exception ex)
            {
                if (ex.InnerException is SocketException)
                {
                    return(false);
                }
                throw new Exception("Fehler beim Senden des Paketes.", ex);
            }
        }
Esempio n. 13
0
        internal override Task SendAsync(Packet packet)
        {
            try
            {
                if (!IsAvailable)
                {
                    return(Task.CompletedTask);
                }

                var buffer = PacketSerializer.Serialize(packet, Key, Type == GSLiveType.Command);
                _client?.SendAsync(buffer, null);
            }
            catch (Exception e)
            {
                if (e is OperationCanceledException || e is ObjectDisposedException ||
                    e is ArgumentOutOfRangeException)
                {
                    return(Task.CompletedTask);
                }

                e.LogException <GsWebSocketClient>(
                    Type == GSLiveType.TurnBased ? DebugLocation.TurnBased : DebugLocation.Command,
                    "SendAsync");

                OnClosed(new ErrorArg {
                    Error = e.ToString()
                });
            }

            return(Task.CompletedTask);
        }
        internal override async Task SendAsync(Packet packet)
        {
            try
            {
                if (!IsAvailable)
                {
                    return;
                }

                var buffer = PacketSerializer.Serialize(packet, Key, Type == GSLiveType.Command);
                if (_clientStream != null)
                {
                    await _clientStream.WriteAsync(buffer, 0, buffer.Length, OperationCancellationToken.Token);

                    await _clientStream.FlushAsync(OperationCancellationToken.Token);
                }
            }
            catch (Exception e)
            {
                if (!(e is OperationCanceledException || e is ObjectDisposedException ||
                      e is ArgumentOutOfRangeException))
                {
                    e.LogException <GsTcpClient>(
                        Type == GSLiveType.TurnBased ? DebugLocation.TurnBased : DebugLocation.Command, "SendAsync");

                    OnClosed(new ErrorArg {
                        Error = e.ToString()
                    });
                }
            }
        }
Esempio n. 15
0
        public bool RawSend(UInt32 msgID, byte[] payload)
        {
            if (_socket == null || !_socket.Connected || payload == null)
            {
                return(false);
            }

            var header = new PacketHeader();

            header.Tag       = GenSendTag();
            header.MsgID     = msgID;
            header.TotalSize = (UInt16)(PacketHeader.HeaderSize + payload.Length);

            var ps = PacketSerializer.WriteFull(header, payload);

            try
            {
                if (_socket != null && _socket.Connected)
                {
                    SendStream(ps);
                }
            }
            catch (Exception ex)
            {
                PostError(SessionEvent.SendError, ex);
                return(false);
            }

            return(true);
        }
Esempio n. 16
0
        public async Task ClientSettings()
        {
            var locale       = "locale";
            var viewDistance = sbyte.MaxValue;
            var chatMode     = int.MaxValue;
            var chatColors   = true;
            var skinParts    = byte.MaxValue;
            var mainHand     = int.MaxValue;

            using var stream = new MinecraftStream();
            await stream.WriteStringAsync(locale);

            await stream.WriteByteAsync(viewDistance);

            await stream.WriteIntAsync(chatMode);

            await stream.WriteBooleanAsync(chatColors);

            await stream.WriteUnsignedByteAsync(skinParts);

            await stream.WriteIntAsync(mainHand);

            stream.Position = 0;

            var packet = PacketSerializer.FastDeserialize <ClientSettings>(stream);

            Assert.Equal(locale, packet.Locale);
            Assert.Equal(viewDistance, packet.ViewDistance);
            Assert.Equal(chatMode, packet.ChatMode);
            Assert.Equal(chatColors, packet.ChatColors);
            Assert.Equal(skinParts, packet.SkinParts);
            Assert.Equal(mainHand, packet.MainHand);
        }
Esempio n. 17
0
        public async Task Handshake()
        {
            var version       = ProtocolVersion.v1_13_2;
            var serverAddress = "serverAddress";
            var serverPort    = ushort.MaxValue;
            var nextState     = ClientState.Status;

            using var stream = new MinecraftStream();
            await stream.WriteVarIntAsync(version);

            await stream.WriteStringAsync(serverAddress);

            await stream.WriteUnsignedShortAsync(serverPort);

            await stream.WriteVarIntAsync(nextState);

            stream.Position = 0;

            var packet = PacketSerializer.FastDeserialize <Handshake>(stream);

            Assert.Equal(version, packet.Version);
            Assert.Equal(serverAddress, packet.ServerAddress);
            Assert.Equal(serverPort, packet.ServerPort);
            Assert.Equal(nextState, packet.NextState);
        }
Esempio n. 18
0
        public async Task PlayerPositionLook()
        {
            var pitch      = new Angle(byte.MaxValue - 1);
            var yaw        = new Angle(byte.MaxValue);
            var position   = new Position(1.0, 2.0, 3.0);
            var flags      = PositionFlags.X | PositionFlags.Y_ROT;
            var teleportId = int.MaxValue;

            using var stream = new MinecraftStream();
            await stream.WriteAsync(DataType.Position, null, position);

            await stream.WriteFloatAsync(yaw.Degrees);

            await stream.WriteFloatAsync(pitch.Degrees);

            await stream.WriteUnsignedByteAsync((byte)flags);

            await stream.WriteVarIntAsync(teleportId);

            stream.Position = 0;

            var packet = PacketSerializer.FastDeserialize <ClientPlayerPositionLook>(stream);

            Assert.Equal(position.X, packet.Position.X);
            Assert.Equal(position.Y, packet.Position.Y);
            Assert.Equal(position.Z, packet.Position.Z);
            Assert.Equal(yaw.Degrees, packet.Pitch);
            Assert.Equal(pitch.Degrees, packet.Yaw);
            Assert.Equal(flags, packet.Flags);
            Assert.Equal(teleportId, packet.TeleportId);
        }
Esempio n. 19
0
        /// <summary>
        /// creates a wrapper around the core Session, which is able to convert the packet data used
        /// in the battlefield 3 protocol into normal bytes
        /// </summary>
        /// <param name="session"></param>
        /// <param name="server"> </param>
        public PacketSession(IRconSession session, Battlefield3Server server)
        {
            Session = session;
            Server = server;
            PacketSerializer = new PacketSerializer();
            PacketSequence = new PacketSequence();
            EventsSent = new List<Packet>();

            // create the hash value for validating crypted password
            HashValue = Guid.NewGuid().ToString().Replace("-", string.Empty);

            this.CommandHandlersList = new CommandHandlersList();
            this.CommandHandlersList.Add(new MapListCommandHandlers());
            this.CommandHandlersList.Add(new BanListCommandHandlers());
            this.CommandHandlersList.Add(new VarsCommandHandlers());
            this.CommandHandlersList.Add(new ReservedSlotsListCommandHandlers());
            this.CommandHandlersList.Add(new AdminCommandHandlers());
            this.CommandHandlersList.Add(new NotAuthenticatedCommandHandlers(server.ServiceLocator));

            this.ClientCommandReceived += CommandHandlersList.OnCommandReceived;
            this.ServerEventResponseReceived += OnServerEventResponseReceived;

            if (session != null)
            {
                Session.DataReceived += OnDataReceived;
                Session.DataSent += OnDataSent;
                Session.Closed += SessionOnClosed;
            }
        }
Esempio n. 20
0
        public void SerializeDeserialize()
        {
            const int Count = 255;

            var packets  = new List <IPacket>();
            var contents = new List <string>();

            for (int i = 0; i < Count; i++)
            {
                contents.Add("STR: " + i.ToString());
            }

            for (int i = 0; i < Count / 2; i++)
            {
                packets.Add(new PingPacket(contents[i]));
            }
            for (int i = Count / 2; i < Count; i++)
            {
                packets.Add(new AuthenticationPacket(contents[i], contents[i]));
            }

            var bytes = PacketSerializer.Serialize(packets.ToArray());

            packets = PacketSerializer.Deserialize(bytes).ToList();

            for (int i = 0; i < Count / 2; i++)
            {
                Assert.AreEqual(contents[i], ((PingPacket)packets[i]).contents);
            }
            for (int i = Count / 2; i < Count; i++)
            {
                Assert.AreEqual(contents[i], ((AuthenticationPacket)packets[i]).time);
            }
        }
        private async Task Sending()
        {
            try
            {
                IsSendingQueue = true;

                lock (SendTempQueueLock)
                {
                    SendQueue.InsertRange(0, SendTempQueue);
                    SendTempQueue.Clear();
                }

                await SendAsync(PacketSerializer.Serialize(SendQueue, Key, Type == GSLiveType.Command));
            }
            catch (Exception e)
            {
                e.LogException <GsTcpClient>(
                    Type == GSLiveType.TurnBased ? DebugLocation.TurnBased : DebugLocation.Command,
                    "Sending");

                lock (SendTempQueueLock)
                {
                    SendTempQueue.InsertRange(0, SendQueue);
                }
            }
            finally
            {
                IsSendingQueue = false;
                SendQueue.Clear();
            }
        }
        private static GatewayRef StartGateway(ActorSystem system, ChannelType type, int port)
        {
            var serializer = PacketSerializer.CreatePacketSerializer();

            var initiator = new GatewayInitiator
            {
                ListenEndPoint      = new IPEndPoint(IPAddress.Any, port),
                GatewayLogger       = LogManager.GetLogger("Gateway"),
                CreateChannelLogger = (ep, _) => LogManager.GetLogger($"Channel({ep}"),
                ConnectionSettings  = new TcpConnectionSettings {
                    PacketSerializer = serializer
                },
                PacketSerializer    = serializer,
                CreateInitialActors = (context, connection) => new[]
                {
                    Tuple.Create(context.ActorOf(Props.Create(() => new EntryActor(context.Self.Cast <ActorBoundChannelRef>()))),
                                 new TaggedType[] { typeof(IEntry) },
                                 (ActorBindingFlags)0)
                }
            };

            var gateway = (type == ChannelType.Tcp)
                ? system.ActorOf(Props.Create(() => new TcpGateway(initiator))).Cast <GatewayRef>()
                : system.ActorOf(Props.Create(() => new UdpGateway(initiator))).Cast <GatewayRef>();

            gateway.Start().Wait();
            return(gateway);
        }
Esempio n. 23
0
        public override async Task Start()
        {
            // create UserTableContainer

            _userContainer = _context.System.ActorOf(
                Props.Create(() => new DistributedActorTableContainer <long>(
                                 "User", _context.ClusterActorDiscovery, typeof(UserActorFactory), new object[] { _context }, InterfacedPoisonPill.Instance)),
                "UserTableContainer");

            // create gateway for users to connect to

            if (_listenEndPoint.Port != 0)
            {
                var serializer = PacketSerializer.CreatePacketSerializer();

                var name      = "UserGateway";
                var initiator = new GatewayInitiator
                {
                    ListenEndPoint      = _listenEndPoint,
                    ConnectEndPoint     = _connectEndPoint,
                    TokenRequired       = true,
                    GatewayLogger       = LogManager.GetLogger(name),
                    CreateChannelLogger = (ep, _) => LogManager.GetLogger($"Channel({ep}"),
                    ConnectionSettings  = new TcpConnectionSettings {
                        PacketSerializer = serializer
                    },
                    PacketSerializer = serializer,
                };

                _gateway = (_channelType == ChannelType.Tcp)
                    ? _context.System.ActorOf(Props.Create(() => new TcpGateway(initiator)), name).Cast <GatewayRef>()
                    : _context.System.ActorOf(Props.Create(() => new UdpGateway(initiator)), name).Cast <GatewayRef>();
                await _gateway.Start();
            }
        }
        private async Task <GatewayRef> StartListen(ActorSystem system, ChannelType type, int port)
        {
            var serializer = PacketSerializer.CreatePacketSerializer();

            var name      = $"Gateway({type})";
            var initiator = new GatewayInitiator
            {
                ListenEndPoint      = new IPEndPoint(IPAddress.Any, port),
                GatewayLogger       = LogManager.GetLogger(name),
                CreateChannelLogger = (ep, _) => LogManager.GetLogger($"Channel({ep}"),
                ConnectionSettings  = new TcpConnectionSettings {
                    PacketSerializer = serializer
                },
                PacketSerializer    = serializer,
                CreateInitialActors = (context, connection) => new[]
                {
                    Tuple.Create(
                        context.ActorOf(Props.Create(() =>
                                                     new Greeter(context.Self.Cast <ActorBoundChannelRef>(), GatewayInitiator.GetRemoteEndPoint(connection)))),
                        new TaggedType[] { typeof(IGreeter) },
                        (ActorBindingFlags)0)
                }
            };

            var gateway = (type == ChannelType.Tcp)
                ? system.ActorOf(Props.Create(() => new TcpGateway(initiator)), name).Cast <GatewayRef>()
                : system.ActorOf(Props.Create(() => new UdpGateway(initiator)), name).Cast <GatewayRef>();
            await gateway.Start();

            return(gateway);
        }
Esempio n. 25
0
        public override async Task Start()
        {
            var serializer = PacketSerializer.CreatePacketSerializer();

            var name      = "UserLoginGateway";
            var initiator = new GatewayInitiator
            {
                ListenEndPoint      = _listenEndPoint,
                GatewayLogger       = LogManager.GetLogger(name),
                CreateChannelLogger = (ep, _) => LogManager.GetLogger($"Channel({ep}"),
                ConnectionSettings  = new TcpConnectionSettings {
                    PacketSerializer = serializer
                },
                PacketSerializer    = serializer,
                CreateInitialActors = (context, connection) => new[]
                {
                    Tuple.Create(
                        context.ActorOf(Props.Create(() =>
                                                     new UserLoginActor(_context, context.Self.Cast <ActorBoundChannelRef>(), GatewayInitiator.GetRemoteEndPoint(connection)))),
                        new TaggedType[] { typeof(IUserLogin) },
                        ActorBindingFlags.CloseThenStop | ActorBindingFlags.StopThenCloseChannel)
                }
            };

            _gateway = (_channelType == ChannelType.Tcp)
                ? _context.System.ActorOf(Props.Create(() => new TcpGateway(initiator)), name).Cast <GatewayRef>()
                : _context.System.ActorOf(Props.Create(() => new UdpGateway(initiator)), name).Cast <GatewayRef>();
            await _gateway.Start();
        }
Esempio n. 26
0
        protected override PacketObject OnReadPacket()
        {
            var packet = (PacketObject)null;

            do
            {
                /* ブロック読み込み */
                while ((block_reader_ == null) || (block_reader_.PeekChar() < 0))
                {
                    /* ブロックが読み込めなかった場合は終了 */
                    if (!LoadCompressBlock(reader_main_))
                    {
                        return(null);
                    }
                }

                /* 1パケット読込 */
                try {
                    var size = (UInt32)0;

                    size |= (uint)((uint)block_reader_.ReadByte() << 24);
                    size |= (uint)((uint)block_reader_.ReadByte() << 16);
                    size |= (uint)((uint)block_reader_.ReadByte() << 8);
                    size |= (uint)((uint)block_reader_.ReadByte() << 0);

                    packet = PacketSerializer.Deserialize(block_reader_.ReadBytes((int)size));
                } catch {
                    /* 読込が失敗した場合は繰り返す */
                }
            } while (packet == null);

            return(packet);
        }
Esempio n. 27
0
        public void Send <T>(T packet)
            where T : NetworkerPacketBase
        {
            var serializer = new PacketSerializer();

            this.socket.SendTo(serializer.Serialize(packet), this.socket.RemoteEndPoint);
        }
Esempio n. 28
0
        public async Task PlayerBlockPlacement()
        {
            var location = new Position(1.0, 2.0, 3.0);
            var face     = BlockFace.Top;
            var hand     = int.MaxValue;
            var cursorX  = float.MaxValue;
            var cursorY  = float.MaxValue;
            var cursorZ  = float.MaxValue;

            using var stream = new MinecraftStream();
            await stream.WritePositionAsync(location);

            await stream.WriteVarIntAsync(face);

            await stream.WriteIntAsync(hand);

            await stream.WriteFloatAsync(cursorX);

            await stream.WriteFloatAsync(cursorY);

            await stream.WriteFloatAsync(cursorZ);

            stream.Position = 0;

            var packet = PacketSerializer.FastDeserialize <PlayerBlockPlacement>(stream);

            Assert.Equal(location.X, packet.Location.X);
            Assert.Equal(location.Y, packet.Location.Y);
            Assert.Equal(location.Z, packet.Location.Z);
            Assert.Equal((Hand)hand, packet.Hand);
            Assert.Equal(cursorX, packet.CursorX);
            Assert.Equal(cursorY, packet.CursorY);
            Assert.Equal(cursorZ, packet.CursorZ);
        }
Esempio n. 29
0
        private void BeginReceiveCallback(IAsyncResult results)
        {
            var state = (AuthenticationState)results.AsyncState;

            // Timeout, socket has been closed.
            if (state.client.Client == null)
            {
                return;
            }

            var packet = (AuthenticationPacket)PacketSerializer.Deserialize(state.buffer)[0];
            var auth   = state.auth;

            if (packet.version == auth.version &&
                packet.time == auth.time &&
                !string.IsNullOrEmpty(packet.response) &&
                Guid.Parse(packet.guid) == state.guid)
            {
                AuthenticationSuccess?.Invoke(state.client, packet);
            }
            else
            {
                AuthenticationFailed?.Invoke(state.client);
            }
        }
        internal override void Send(Packet packet)
        {
            Task.Factory.StartNew(() =>
            {
                try
                {
                    var buffer = PacketSerializer.Serialize(packet, Key, Type == GSLiveType.Command);

                    if (_clientStream == null)
                    {
                        return;
                    }

                    _clientStream.Write(buffer, 0, buffer.Length);
                    _clientStream.Flush();
                }
                catch (Exception e)
                {
                    if (!(e is OperationCanceledException || e is ObjectDisposedException ||
                          e is ArgumentOutOfRangeException))
                    {
                        e.LogException <GsTcpClient>(
                            Type == GSLiveType.TurnBased ? DebugLocation.TurnBased : DebugLocation.Command,
                            "Send");

                        OnClosed(new ErrorArg {
                            Error = e.ToString()
                        });
                    }
                }
            }, OperationCancellationToken.Token);
        }
Esempio n. 31
0
        public void Send <T>(T packet, NetworkerProtocol protocol = NetworkerProtocol.Tcp)
            where T : NetworkerPacketBase
        {
            var serializer       = new PacketSerializer();
            var serialisedPacket = serializer.Serialize(packet);

            if (protocol == NetworkerProtocol.Tcp)
            {
                if (!this.clientConfiguration.UseTcp)
                {
                    throw new Exception("Cannot send TCP when TCP not enabled.");
                }

                this._tcpSocket.Send(serialisedPacket);
            }
            else if (protocol == NetworkerProtocol.Udp)
            {
                if (!this.clientConfiguration.UseUdp)
                {
                    throw new Exception("Cannot send UDP when UDP not enabled.");
                }

                this._udpClient.SendAsync(serialisedPacket,
                                          serialisedPacket.Length,
                                          this.clientConfiguration.Ip,
                                          this.clientConfiguration.UdpPortRemote);
            }
        }
 public void LoginPlainTextHandlesPasswordNotSet()
 {
     var packet = new Packet(PacketOrigin.Client, false, 1, new List<string> { "login.plainText" });
     byte[] bytes = new PacketSerializer().Serialize(packet);
     Socket.Send(bytes);
     var receivedPacket = ReceivePacket();
     Assert.AreEqual("PasswordNotSet", receivedPacket.Words[0]);
 }
 public void LoginPlainHashedHandlesIncorrectPasswordHash()
 {
     var packet = new Packet(PacketOrigin.Client, false, 1, new List<string> {"login.hashed", "test123"});
     byte[] bytes = new PacketSerializer().Serialize(packet);
     Socket.Send(bytes);
     Packet receivedPacket = ReceivePacket();
     Assert.AreEqual(1, receivedPacket.Words.Count);
     Assert.AreEqual("InvalidPasswordHash", receivedPacket.Words[0]);
 }
 public void LoginPlainHashedHandlesReceivingHashValue()
 {
     var packet = new Packet(PacketOrigin.Client, false, 1, new List<string> {"login.hashed"});
     byte[] bytes = new PacketSerializer().Serialize(packet);
     Socket.Send(bytes);
     Packet receivedPacket = ReceivePacket();
     Assert.AreEqual(2, receivedPacket.Words.Count);
     Assert.AreEqual("OK", receivedPacket.Words[0]);
     Assert.AreEqual(Session.HashValue, receivedPacket.Words[1]);
 }
 public void LoginPlainHashedHandlesCorrectPasswordHash()
 {
     string correctPasswordHash = PasswordHashService.GeneratePasswordHash(HexConverterService.HashToByteArray(Session.HashValue), ServerInstance.Password);
     var packet = new Packet(PacketOrigin.Client, false, 1,
                             new List<string> {"login.hashed", correctPasswordHash});
     byte[] bytes = new PacketSerializer().Serialize(packet);
     Socket.Send(bytes);
     Packet receivedPacket = ReceivePacket();
     Assert.AreEqual(1, receivedPacket.Words.Count);
     Assert.AreEqual("OK", receivedPacket.Words[0]);
 }
Esempio n. 36
0
        private static ClientWorker[] CreateRemoteClients(int count)
        {
            var serializer = new PacketSerializer(
                new PacketSerializerBase.Data(
                    new ProtoBufMessageSerializer(TypeModel.Create()),
                    new TypeAliasTable()));

            var communicators = new Communicator[count];
            for (int i = 0; i < count; i++)
            {
                var communicator = new Communicator(LogManager.GetLogger("Communicator"),
                                                    new IPEndPoint(IPAddress.Loopback, 8081),
                                                    _ =>
                                                    new TcpConnection(serializer, LogManager.GetLogger("Connection")));
                communicator.Start();
                communicators[i] = communicator;
            }

            for (int i = 0; i < 100; i++)
            {
                Thread.Sleep(10);

                var connectedCount = communicators.Count(c => c.State == Communicator.StateType.Connected);
                if (connectedCount == count)
                    break;

                var closedCount = communicators.Count(c => c.State == Communicator.StateType.Stopped);
                if (closedCount > 0)
                    throw new Exception("Connection closed!");
            }

            var clients = new ClientWorker[count];
            for (int i = 0; i < count; i++)
            {
                var requestWaiter = new SlimTaskRequestWaiter(communicators[i]);
                var server = new ServerRef(new SlimActorRef(1), requestWaiter, null);
                clients[i] = new ClientWorker(server);
            }
            return clients;
        }
        /// <summary>
        /// Receive callback
        /// </summary>
        /// <param name="client">client</param>
        /// <param name="receivedPacket">received packet</param>
        public void OnReceived(INetworkClient client, Packet receivedPacket)
        {
            ParallelPacket receivedParallelPacket = new ParallelPacket(receivedPacket);
            switch (receivedParallelPacket.GetPacketType())
            {
                case ParallelPacketType.DATA:
                    if (m_receiveType == ReceiveType.BURST)
                    {
                        if (CallBackObj != null)
                        {
//                             Task t = new Task(delegate()
//                             {
//                                 CallBackObj.OnReceived(this, receivedParallelPacket);
//                             });
//                             t.Start();
                            CallBackObj.OnReceived(this, receivedParallelPacket);
                        }
                    }
                    else if (m_receiveType == ReceiveType.SEQUENTIAL)
                    {
                        lock (m_receiveLock)
                        {
                            m_receivedQueue.Enqueue(receivedParallelPacket);
                            while (m_curReceivedPacketId == -1 || (!m_receivedQueue.IsEmpty() && m_curReceivedPacketId + 1 == m_receivedQueue.Peek().GetPacketID()))
                            {
                                ParallelPacket curPacket = m_receivedQueue.Dequeue();
                                m_curReceivedPacketId = curPacket.GetPacketID();
                                if (CallBackObj != null)
                                {
//                                     Task t = new Task(delegate()
//                                     {
//                                         CallBackObj.OnReceived(this, curPacket);
//                                     });
//                                     t.Start();
                                    m_callBackObj.OnReceived(this, curPacket);
                                }
                            }
                        }
                    }
                    break;
                case ParallelPacketType.IDENTITY_REQUEST:
                    PacketSerializer<IdentityResponse> serializer = new PacketSerializer<IdentityResponse>(new IdentityResponse(Guid));
                    ParallelPacket sendPacket=new ParallelPacket(getCurPacketSequence(),ParallelPacketType.IDENTITY_RESPONSE,serializer.GetPacketRaw());
                    client.Send(sendPacket.GetPacketRaw());
                    break;
                case ParallelPacketType.READY:
                    lock (m_sendLock)
                    {
                        m_pendingClientSet.Add(client);
                        if (m_pendingClientSet.Count > 0 && (m_errorPacketSet.Count > 0 || m_packetQueue.Count > 0))
                            m_sendReadyEvent.SetEvent();
                    }
                    break;
            }
        }
        /// <summary>
        /// Receive callback
        /// </summary>
        /// <param name="socket">client socket</param>
        /// <param name="receivedPacket">received packet</param>
        public void OnReceived(INetworkSocket socket, Packet receivedPacket)
        {
            ParallelPacket receivedParallelPacket = new ParallelPacket(receivedPacket);
            switch (receivedParallelPacket.GetPacketType())
            {
                case ParallelPacketType.IDENTITY_RESPONSE:
                    PacketSerializer<IdentityResponse> serializer = new PacketSerializer<IdentityResponse>(receivedParallelPacket.GetPacketRaw(),receivedParallelPacket.GetHeaderSize(),receivedParallelPacket.GetDataByteSize());

                    Guid guid = serializer.GetPacket().m_guid;
                    lock (m_listLock)
                    {
                        if (m_socketMap.ContainsKey(guid))
                        {
                            m_socketMap[guid].AddSocket(socket);
                        }
                        else
                        {
                            IParallelSocketCallback socketCallback = CallBackObj.OnAccept(this, socket.IPInfo);
                            if (socketCallback != null)
                            {
                                // Create new Parallel Socket
                                ParallelSocket parallelSocket = new ParallelSocket(guid,socket, this);
                                parallelSocket.CallBackObj = socketCallback;
                                parallelSocket.Start();
                                m_socketMap[guid] = parallelSocket;
                            }
                            else
                            {
                                // Rejected by server
                                socket.Disconnect();
                            }
                        }
                    }
                    break;
                default:
                    // Invalid protocol
                    socket.Disconnect();
                    break;
            }
        }
 /// <summary>
 /// Receive callback
 /// </summary>
 /// <param name="socket">client socket</param>
 /// <param name="receivedPacket">received packet</param>
 public void OnReceived(INetworkSocket socket, Packet receivedPacket)
 {
     ParallelPacket receivedParallelPacket = new ParallelPacket(receivedPacket);
     switch (receivedParallelPacket.PacketType)
     {
         case ParallelPacketType.IDENTITY_RESPONSE:
             PacketSerializer<IdentityResponse> serializer = new PacketSerializer<IdentityResponse>(receivedParallelPacket.PacketRaw,receivedParallelPacket.HeaderSize,receivedParallelPacket.DataByteSize);
             IdentityResponse response = serializer.ClonePacketObj();
             Guid guid = response.m_guid;
             int streamCount = response.m_streamCount;
             lock (m_listLock)
             {
                 if (m_socketMap.ContainsKey(guid))
                 {
                     m_socketMap[guid].AddSocket(socket);
                 }
                 else
                 {
                     if (CallBackObj == null)
                     {
                         socket.Disconnect();
                         return;
                     }
                     
                     if (Acceptor.OnAccept(this, socket.IPInfo, streamCount))
                     {
                         // Create new Parallel Socket
                         IParallelSocketCallback socketCallback = Acceptor.GetSocketCallback();
                         ParallelSocket parallelSocket = new ParallelSocket(guid,socket, this);
                         parallelSocket.CallBackObj = socketCallback;
                         parallelSocket.Start();
                         m_socketMap[guid] = parallelSocket;
                         OnParallelServerAccepted(this, parallelSocket);
                     }
                     else
                     {
                         // Rejected by server
                         socket.Disconnect();
                     }
                 }
             }
             break;
         default:
             // Invalid protocol
             socket.Disconnect();
             break;
     }
 }
        protected Packet ReceivePacket()
        {
            var received = new byte[1024];
            Packet receivedPacket = null;
            var sessionBuffer = new SessionBuffer(null, Socket, received);
            Socket.BeginReceive(sessionBuffer.Buffer, 0, sessionBuffer.Buffer.Length, SocketFlags.None,
                                (asyncResult) =>
                                    {
                                        var buffer =
                                            asyncResult.
                                                AsyncState as
                                            SessionBuffer;
                                        if (buffer == null) return;
                                        int bytesReceived = buffer.Socket.EndReceive(asyncResult);

                                        receivedPacket = new PacketSerializer().Deserialize(
                                            buffer.Buffer.Take(bytesReceived).
                                                ToArray()).FirstOrDefault();
                                    }, sessionBuffer);

            while (receivedPacket == null)
            {
                Thread.Sleep(10);
            }
            return receivedPacket;
        }
 /// <summary>
 /// Receive callback
 /// </summary>
 /// <param name="client">client</param>
 /// <param name="receivedPacket">received packet</param>
 public void OnReceived(INetworkClient client, Packet receivedPacket)
 {
     ParallelPacket receivedParallelPacket = new ParallelPacket(receivedPacket);
     switch (receivedParallelPacket.PacketType)
     {
         case ParallelPacketType.DATA:
             if (ReceiveType == ReceiveType.BURST)
             {
                 OnParallelClientReceived(this, receivedParallelPacket);
             }
             else if (m_receiveType == ReceiveType.SEQUENTIAL)
             {
                 lock (m_receiveLock)
                 {
                     m_receivedQueue.Enqueue(receivedParallelPacket);
                     while (!m_receivedQueue.IsEmpty() && m_curReceivedPacketId + 1 == m_receivedQueue.Peek().PacketID)
                     {
                         ParallelPacket curPacket = m_receivedQueue.Dequeue();
                         m_curReceivedPacketId = curPacket.PacketID;
                         if (m_curReceivedPacketId == long.MaxValue)
                         {
                             m_curReceivedPacketId = -1;
                         }
                         OnParallelClientReceived(this, curPacket);
                     }
                 }
             }
             break;
         case ParallelPacketType.IDENTITY_REQUEST:
             PacketSerializer<IdentityResponse> serializer = new PacketSerializer<IdentityResponse>(new IdentityResponse(Guid,MaxSocketCount));
             ParallelPacket sendPacket=new ParallelPacket(-1,ParallelPacketType.IDENTITY_RESPONSE,serializer.PacketRaw);
             client.Send(sendPacket.PacketRaw);
             break;
         case ParallelPacketType.READY:
             lock (m_sendLock)
             {
                 m_pendingClientSet.Add(client);
                 if (m_pendingClientSet.Count > 0 && (m_errorPacketSet.Count > 0 || m_packetQueue.Count > 0))
                     m_sendReadyEvent.SetEvent();
             }
             break;
     }
 }