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() }); } } }
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 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); }
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); } }
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); }
public void Serialize_Valid_ReturnsValidXml() { PacketSerializer serializer = PacketSerializer.Create("application/xml"); Payment payment = new Payment { OrderId = "1", AmountKop = 100, CardHolderName = "POVYSHEV NIKOLAY", CardNumber = "9999000088881111", CVV = "100", ExpiryMonth = 12, ExpiryYear = 2017 }; const string etalon = "<?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>"; string xml = null; using (MemoryStream stream = new MemoryStream()) using (StreamReader reader = new StreamReader(stream)) { serializer.Serialize(new Packet <Payment>(payment) { Version = "v1" }, stream); stream.Position = 0; xml = reader.ReadToEnd(); } Assert.Equal(etalon, xml); }
public void Send(IPacket packet) { if (!Connected) { return; } byte[] serializedPacket = null; using (MemoryStream stream = new MemoryStream()) { serializer.Serialize(stream, packet); serializedPacket = stream.ToArray(); stream.SetLength(0L); stream.WriteByte((byte)serializedPacket.Length); stream.WriteByte((byte)(serializedPacket.Length >> 8)); stream.WriteByte((byte)(serializedPacket.Length >> 16)); stream.WriteByte((byte)(serializedPacket.Length >> 24)); stream.Write(serializedPacket, 0, serializedPacket.Length); serializedPacket = stream.ToArray(); } socket.BeginSend(serializedPacket, 0, serializedPacket.Length, SocketFlags.None, EndSend, this); }
public void Send <T>(T packet) where T : NetworkerPacketBase { var serializer = new PacketSerializer(); this.socket.SendTo(serializer.Serialize(packet), this.socket.RemoteEndPoint); }
/// <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); } }
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(); }
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(); } }
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); }
static void SendPacket(WebSocket ws, PacketBase packet) { var json = PacketSerializer.Serialize(packet); Console.WriteLine(json); ws.Send(json); }
/// <summary> /// Sendet ein object an alle Clienten /// </summary> /// <param name="bytes"></param> public void SendPacket(object data) { // Sendet das Paket an jeden Clienten. foreach (Client c in clients) { SendPacket(c.Tcpclient, PacketSerializer.Serialize(data)); } }
private void Send(PacketBase packet) { Debug.Log("Send : " + packet); var json = PacketSerializer.Serialize(packet); ws.SendAsync(json, x => { }); }
public void Deserialize() { var pingPacket = new PingPacket("hello"); var bytes = PacketSerializer.Serialize(pingPacket); var packets = PacketSerializer.Deserialize(bytes); Assert.IsTrue(packets.Length == 1); Assert.AreEqual("hello", ((PingPacket)packets[0]).contents); }
public static void Broadcast <T>( this IEnumerable <Service <T> > sessions, PacketBase packet) { var json = Encoding.UTF8.GetString(PacketSerializer.Serialize(packet)); foreach (var session in sessions) { session.SendRawPacket(json); } }
public void SendPacket(object packet) { packetSerializer.Serialize(packet); for (int i = 0; i < packetSerializer.SegmentCount; i++) { int fullSegmentLength = packetSerializer.GetSerializedSegment(SendBuffer); SendData(fullSegmentLength); } packetSerializer.Clear(); }
public void Serialize() { var pingPacket = new PingPacket("hello"); var bytes = PacketSerializer.Serialize(pingPacket); var header = 4; var packets = 1; var packetSize = Marshal.SizeOf(pingPacket); Assert.AreEqual(header + packets + packetSize, bytes.Length); }
public void Send(IPacket packet) { if (IsConnected == false) { Debug.LogError("Please Connect First!!"); return; } // ClearBuffer(); byte[] sendBuffer = PacketSerializer.Serialize(packet); _networkStream.Write(sendBuffer, 0, sendBuffer.Length); Debug.Log("[Send] name: " + packet.GetPacketType()); }
protected virtual void SendPacket(PacketBase packet) { try { var json = PacketSerializer.Serialize(packet); SendRawPacket(json); } catch (Exception e) { Console.WriteLine(e); } }
public bool SendPacket(object packet) { if (_packetSerializer == null) { return(false); } _packetSerializer.Serialize(packet); for (int i = 0; i < _packetSerializer.SegmentCount; i++) { int fullSegmentLength = _packetSerializer.GetSerializedSegment(SendBuffer); SendData(fullSegmentLength); } _packetSerializer.Clear(); return(true); }
protected internal virtual void SendPacket(PacketBase packet) { try { if (packet.PacketId == 0) { packet.PacketId = Interlocked.Increment(ref LastPacketId); } var json = Encoding.UTF8.GetString(PacketSerializer.Serialize(packet)); SendRawPacket(json); } catch (Exception e) { Console.WriteLine(e); } }
public void TestLoginPacketSerialization() { LoginPacket loginPacket = new LoginPacket() { Login = "******", Password = "******" }; byte[] serialized = PacketSerializer.Serialize(loginPacket); object deserialized = PacketSerializer.Deserialize(serialized); Assert.That(deserialized is LoginPacket); LoginPacket deserializedLoginPacket = (LoginPacket)deserialized; Assert.AreEqual(deserializedLoginPacket.Login, loginPacket.Login); Assert.AreEqual(deserializedLoginPacket.Password, loginPacket.Password); }
public void Authenticate(TcpClient client) { var guid = Guid.NewGuid(); var packet = new AuthenticationPacket(Configuration.Version, DateTime.Now.ToString(), guid.ToString()); var buffer = PacketSerializer.Serialize(packet); client.Client.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, BeginSendCallback, new AuthenticationState() { client = client, buffer = new byte[4096], auth = packet, guid = guid }); }
public TResp SendRequest <TReq, TResp>(TReq content) where TReq : IPacketContent where TResp : IPacketContent { HttpWebRequest request = WebRequest.Create(endpoint) as HttpWebRequest; request.Method = "POST"; request.ContentType = contentType; request.Timeout = 3000; PacketSerializer serializer = PacketSerializer.Create(request.ContentType); try { using (MemoryStream stream = new MemoryStream()) { serializer.Serialize(new Packet <TReq>(content) { Version = "v1" }, stream); request.ContentLength = stream.Length; stream.Position = 0; stream.CopyTo(request.GetRequestStream()); } HttpWebResponse response = request.GetResponse() as HttpWebResponse; Stream responseStream = response.GetResponseStream(); Packet <TResp> responsePacket = serializer.Deserialize <TResp>(responseStream); return(responsePacket.Content); } catch (WebException ex) { throw new PacketTransportException("Ошибка соединения с сервером", ex); } }
// use this only inside the server to send to a client public void 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, its out header Int32 packetSize = (Int32)packetDeserialized.Length; var packetSizeBytes = BitConverter.GetBytes(packetSize); stream.Write(packetSizeBytes, 0, packetSizeBytes.Length); // then write the friggin packet stream.Write(packetDeserialized, 0, packetDeserialized.Length); // Debug.Log("Sent Packet " + packet.GetType().Name); } catch (Exception e) { // Call in main thread Debug.Log("SOCKET ERROR"); this.Stop(); } }
public bool Serialize(byte[] bytes, ref int position) { if (!ChannelID.Serialize(bytes, ref position)) { return(false); } if (!ParentID.Serialize(bytes, ref position)) { return(false); } if (!Name.Serialize(bytes, ref position)) { return(false); } if (!PacketSerializer.Serialize(type, bytes, ref position)) { return(false); } return(true); }
public void TestSerialize() { var serializer = new PacketSerializer(); var originalPayload = new SentMessagePayload { Id = Guid.NewGuid(), Text = "Hello There hi", ChannelId = Guid.NewGuid(), AuthorId = Guid.NewGuid(), PostedAt = DateTimeOffset.Now, }; var json = serializer.Serialize(originalPayload); var deserializedPayload = (SentMessagePayload)serializer.Deserialize(json); Assert.That(deserializedPayload.Id, Is.EqualTo(originalPayload.Id), "Id was incorrect"); Assert.That(deserializedPayload.Text, Is.EqualTo(originalPayload.Text), "Text was incorrect"); Assert.That(deserializedPayload.ChannelId, Is.EqualTo(originalPayload.ChannelId), "ChannelId was incorrect"); Assert.That(deserializedPayload.AuthorId, Is.EqualTo(originalPayload.AuthorId), "AuthorId was incorrect"); Assert.That(deserializedPayload.PostedAt, Is.EqualTo(originalPayload.PostedAt), "PostedAt was incorrect"); }