/// <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(); } }
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); }); } }
public int GetSize() { return(ChannelID.GetSize() + ParentID.GetSize() + Name.GetSize() + PacketSerializer.GetObjectSize(type)); }
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>(); }
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); }
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); }
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(); }
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)); }
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, }; }
/// <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); } }
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() }); } } }
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); }
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); }
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); }
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); }
/// <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; } }
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); }
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); }
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(); }
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); }
public void Send <T>(T packet) where T : NetworkerPacketBase { var serializer = new PacketSerializer(); this.socket.SendTo(serializer.Serialize(packet), this.socket.RemoteEndPoint); }
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); }
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); }
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]); }
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; } }