void HandleDisconnect(Session session, DisconnectPacket p) { if (session.State == SessionState.Disconnected) { log.Info($"already disconnected: id={session.ID}"); return; } // 연결 종료는 소켓이 끊어질떄도 있고 // 유저가 직접 종료시키는 경우도 있다 // disconnect를 여러번 호출해도 꺠지지 않도록 하자 // 연결 끊은것을 연결 종료 패킷처럼 다루면 // 상위 레이어에서의 처리가 간단해진다 if (session.WorldID != null) { var leave = new WorldLeavePacket(); var codec = new PacketCodec(); var bytes = codec.Encode(leave); var pair = new ReceivedPacket <WorldLeavePacket>(session, bytes); HandleWorldLeave(session, pair); } log.Info($"disconnect: id={session.ID}"); var disconnect = new DisconnectPacket(); session.SendLazy(disconnect); // 연결 끊어도 된다는 표시 해두기. 언제 끊어도 상관 없어야한다 NetworkStack.Session.CloseSessionActive(session); }
/// <summary> /// Adds the packet. /// </summary> /// <param name="packet">The packet.</param> /// <returns>true; if the message is completed, otherwise false</returns> public bool AddPacket(Packet packet) { ReceivedPacket p = new ReceivedPacket(packet, BlockCount); foreach (var smaller in SelectSubsets(p.Blocks.Count, newLeaves, p.Blocks)) if (smaller.Blocks.IsProperSubsetOf(p.Blocks)) p.Xor(smaller); if (p.Blocks.Count == 1) { newLeaves.Clear(); newLeaves.Enqueue(p); while (newLeaves.Count > 0) { var next = newLeaves.Dequeue(); if (next.Blocks.Count == 1) SubtractNewLeaf(next, newLeaves); } } AddToList(p); return IsComplete; }
public void AuthenicateUserAsync(FastFoodUser user, Action <bool> completed) { this.SendPacket(new AuthenicateUserOutgoingPacket(user), (c) => { if (c) { ReceivedPacket delegate_ = null; delegate_ = delegate(IncomingPacket packet) { AuthenicateUserResponseIncomingPacket auth = packet as AuthenicateUserResponseIncomingPacket; if (auth?.Result ?? false) { user.SetSessionToken(auth.SessionToken); completed?.Invoke(true); } else { completed?.Invoke(false); } this.UnregisterPacketListenerUnsafe(delegate_); }; this.RegisterPacketListenerUnsafe(delegate_); } else { completed?.Invoke(false); } }); }
public AnvizDevice(TcpClient socket) { DeviceStream = new AnvizStream(socket); DeviceStream.ReceivedPacket += (s, e) => { switch (e.ResponseCode) { case 0x7F: DevicePing?.Invoke(this, null); break; case 0xDF: ReceivedRecord?.Invoke(this, new Record(e.DATA, 0)); break; default: ReceivedPacket?.Invoke(this, e); break; } }; DeviceStream.DeviceError += (s, e) => { DeviceError?.Invoke(this, e); }; }
private void OnReceiveSecondary(IAsyncResult ar) { int size = 0; try { size = secondarySocket.EndReceive(ar); } catch (ObjectDisposedException) { // Stop receiving return; } var newPacket = PCapPacket.CreateFromBytes(secondaryByteData, size); newPacket.PacketNumber = packetNumber++; var diff = DateTime.UtcNow - start; newPacket.TimeStampSeconds = (uint)diff.TotalSeconds; newPacket.TimeStampMicroseconds = (uint)((diff.TotalSeconds - (uint)diff.TotalSeconds) * 1000000); ReceivedPacket?.Invoke(this, newPacket); // Receive again try { secondarySocket.BeginReceive(secondaryByteData, 0, secondaryByteData.Length, SocketFlags.None, new AsyncCallback(OnReceiveSecondary), null); } catch (ObjectDisposedException) { // Stop receiving return; } }
private void ReceivingLoop() { EndPoint Endp = null; while (!Disconnected) { mData = new byte[1020]; Debug.Log("Dang doi!"); int _byteCount = mSocket.ReceiveFrom(mData, ref Endp); if (_byteCount > 0) { InputMemoryBitStream input = new InputMemoryBitStream(mData, _byteCount * 8); System.Random rand = new System.Random(); int nextInt = rand.Next(0, 100); // Mô phỏng mất gói tin if (nextInt >= mSimulatedDropPacket) { // Mô phỏng độ trễ float receivedTime = CurrentTime + mSimulatedLatency; ReceivedPacket packet = new ReceivedPacket(ref input, Endp, receivedTime); // tránh tranh chấp dữ liệu lock (mPacketQueue) { mPacketQueue.Enqueue(packet); } } } } Debug.Log("Disconnected!"); }
private async void ReceiverThreadFunc() { while (DeviceSocket.Connected && !CancellationTokenSource.IsCancellationRequested) { Response response = null; try { response = await Response.FromStream(DeviceStream, CancellationTokenSource.Token); } catch (Exception ex) { DeviceError?.Invoke(this, ex); } if (response == null) { DeviceSocket.Close(); taskEmitter.TrySetResult(null); break; } if (response.ResponseCode == 0x7F) { await new PongCommand(response.DeviceID).Send(DeviceStream); ReceivedPacket?.Invoke(this, response); } else if (response.ResponseCode == ResponseCode) { ResponseCode = 0; taskEmitter.TrySetResult(response); } else { ReceivedPacket?.Invoke(this, response); } } }
private void ReceiveFromCallback(IAsyncResult ar) { try { EndPoint endp = (EndPoint)(new IPEndPoint(IPAddress.Any, 0)); int _byteCount = mSocket.EndReceiveFrom(ar, ref endp); if (_byteCount > 0 && endp != null) { InputMemoryBitStream input = new InputMemoryBitStream(mData, _byteCount * 8); System.Random rand = new System.Random(); int nextInt = rand.Next(0, 100); if (nextInt >= mSimulatedDropPacket) { // Mô phỏng độ trễ float receivedTime = CurrentTime + mSimulatedLatency; ReceivedPacket packet = new ReceivedPacket(ref input, endp, receivedTime); // tránh tranh chấp dữ liệu lock (mPacketQueue) { mPacketQueue.Enqueue(packet); } } } StartReceivingPacket_nonblocking(); } catch (ObjectDisposedException ex) { Debug.Log("end receive"); return; } }
private async void Listen() { while (await _inStream.MoveNext()) { var packet = _inStream.Current; // Invoke the event on the main thread UnityMainThreadDispatcher.Instance() .Enqueue(() => { switch (packet.TypeCase) { case Packet.TypeOneofCase.Authentication: _token = packet.Authentication.ClientToken; // Record.Log($"Received auth {_token}"); break; case Packet.TypeOneofCase.CreatePlayer: Record.Log($"Received create player {packet.CreatePlayer}"); break; } // Record.Log($"Received {packet}"); ReceivedPacket?.Invoke(packet); }); } }
protected void OnReceivedPacket(T packet) { if (ReceivedPacket != null) { PacketEventArgs <T> packetEventArgs = new PacketEventArgs <T>(packet); ReceivedPacket.Invoke(this, packetEventArgs); } }
public override bool Receive(ref ReceivedPacket packet) { if (Recvs.Count > 0) { packet = Recvs[0]; Recvs.RemoveAt(0); return(true); } return(false); }
void HandleWorldLeave(Session session, ReceivedPacket <WorldLeavePacket> received) { if (session.UserID < 0) { return; } var p = received.Packet; var worlds = InstanceWorldManager.Instance; var world = worlds.Get(session.WorldID); world.EnqueueRecv(session, received.Data); }
void EnqueueWorldPacket <TPacket>(ReceivedPacket <TPacket> packet) where TPacket : IPacket, new() { if (packet.Session.UserID < 0) { return; } var worlds = InstanceWorldManager.Instance; var world = worlds.Get(packet.Session.WorldID); world.EnqueueRecv(packet.Session, packet.Data); }
public static IReadOnlyList <ICommand> ParseToCommands(ProtocolVersion version, IEnumerable <byte[]> payloads) { var result = new List <ICommand>(); foreach (byte[] payload in payloads) { foreach (ParsedCommandSpec rawCmd in ReceivedPacket.ParseCommands(payload)) { result.AddIfNotNull(CommandParser.Parse(version, rawCmd)); } } return(result); }
public static ReceivedPacket WaitOnReceive(SockBase sock) { var receivedPacket = new ReceivedPacket(); for (int i = 0; i < 1000; ++i) { if (sock.Receive(ref receivedPacket)) { return(receivedPacket); } Thread.Sleep(1); } return(receivedPacket); }
public void SecondLevelParsing() { //SP900018[MECM(95,211,185,189,1,4,9,0,0,64,0,3,14,169,244,125,230,174,0,1,116,236,190,125,218,223,0,1,255,175,160,43,2,28,0,41,2,43,138,2,39,38,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] Parser.ReceivedPacket packet = new ReceivedPacket { Data = "95,211,185,189,1,4,9,0,0,64,0,3,14,169,244,125,230,174,0,1,116,236,190,125,218,223,0,1,255,175,160,43,2,28,0,41,2,43,138,2,39,38,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0", ProtocolHeader = "MECM", ReceivedOn = DateTime.UtcNow, TerminalId = "SP111111" }; var pkt = ParsingManager.SecondLevelParser(packet); var str = JsonConvert.SerializeObject(pkt, Formatting.Indented); }
public AnvizDevice(TcpClient socket) { DeviceStream = new AnvizStream(socket); DeviceStream.ReceivedPacket += (s, e) => { if (e.ResponseCode == 0x7F) { DevicePing?.Invoke(this, null); } else { ReceivedPacket?.Invoke(this, e); } }; }
private void SendToListener(ReceivedPacket receivedPacket) { try { if (Context != null) { Context.TransferText(receivedPacket.ToString()); } ParsingManager.SecondLevelParser(receivedPacket); } catch (Exception ex) { LoggingManager.Log(ex); } }
private static List <List <ParsedCommandSpec> > ParseCommands(string filename) { var res = new List <List <ParsedCommandSpec> >(); using (var reader = new StreamReader(filename)) { string line; while ((line = reader.ReadLine()) != null) { var commands = ReceivedPacket.ParseCommands(line.HexToByteArray()); res.Add(commands.ToList()); } } return(res); }
public bool Handle(Client client, string packet) { if (_queuePackets) { var receivedPacket = new ReceivedPacket { Client = client, Packet = packet }; _packets.Enqueue(receivedPacket); } else { return(HandlePacket(client, packet)); } return(true); }
private void ConnectAsyncResult(IAsyncResult ar) { Action <ConnectionResult> completed = (Action <ConnectionResult>)ar.AsyncState; try { this.Socket.EndConnect(ar); this.SendPacket(new RequestServerVersionOutgoingPacket(), (c) => { if (c) { ReceivedPacket delegate_ = null; delegate_ = delegate(IncomingPacket packet) { ServerVersionIncomingPacket serverVersion = packet as ServerVersionIncomingPacket; if (serverVersion?.MagicMatches ?? false) { completed?.Invoke(ConnectionResult.Connected); } else { completed?.Invoke(ConnectionResult.NotAPIServer); } this.UnregisterPacketListenerUnsafe(delegate_); }; this.RegisterPacketListenerUnsafe(delegate_); } else { completed?.Invoke(ConnectionResult.FailedToVerify); } }); this.StartListening(); } catch { completed?.Invoke(ConnectionResult.ConnectionFailed); } }
public static Dictionary <string, ICGRC> GetConfiguration(ReceivedPacket packet) { Dictionary <string, ICGRC> list = new Dictionary <string, ICGRC>(); GTGeneralSettings cgrc00 = new GTGeneralSettings(packet.TerminalId); GTSimAndServerSettings cgrc01 = new GTSimAndServerSettings(packet.TerminalId); GTPollingAndGprsSettings cgrc02 = new GTPollingAndGprsSettings(packet.TerminalId); list.Add(nameof(GTGeneralSettings), cgrc00); list.Add(nameof(GTSimAndServerSettings), cgrc01); list.Add(nameof(GTPollingAndGprsSettings), cgrc02); //string raw = "SP333444<CGRC(ID(00,17/01/2021,07:51:07)N(+923333451191,+923468220229,+923333404763,,,,,,,,SR117R00BL01R00,13-Jan-16,16:27:21,+923,internet,,,+923,internet,,,333444,+923333451191,67.23.248.114,30004,SPMX00DT,SPMX01DT,,,,,,,1,15,2,4,30,9600,15,2)L(1000101101000000000001000000000000))\r>"; string[] strArray = SplitPacket(packet.Data); cgrc00.Parse(strArray); cgrc01.Parse(strArray); cgrc02.Parse(strArray); return(list); }
private bool ParseEnhancedBlock(ProtocolVersion version, EnhancedPacketBlock block) { byte[] data = block.Data; // Perform some basic checks, to ensure data looks like it could be ATEM if (data[23] != 17) { throw new ArgumentOutOfRangeException("Found packet that appears to not be UDP"); } if ((data[36] << 8) + data[37] != 9910 && (data[34] << 8) + data[35] != 9910) { throw new ArgumentOutOfRangeException("Found packet that has wrong UDP port"); } data = data.Skip(42).ToArray(); var packet = new ReceivedPacket(data); if (!packet.CommandCode.HasFlag(ReceivedPacket.CommandCodeFlags.AckRequest)) { return(false); } bool failed = false; foreach (ParsedCommandSpec cmd in packet.Commands) { try { // Try and parse, just to ensure it was successful CommandParser.ParseUnsafe(version, cmd); } catch (Exception e) { output.WriteLine(e.ToString()); failed = true; } } // TODO - parse any macros that were downloaded return(failed); }
private void ProcessQueuedPackets() { lock (mPacketQueue) { while (mPacketQueue.Count != 0) { ReceivedPacket packet = mPacketQueue.Peek(); if (Time.time > packet.GetReceivedTime()) { InputMemoryBitStream input = packet.GetInputMemoryStream(); ProcessPacket(ref input, packet.GetFromAddressEndpoint()); mPacketQueue.Dequeue(); } else { break; } } } }
private void HandlePacket(ReceivedPacket packet) { if (this.InvokeRequired) { this.Invoke(new MethodInvoker(() => HandlePacket(packet))); return; } string outputFilename = OutputFileTextBox.Text; switch (packet.command) { case 0x00: LogToFile(outputFilename, "Packet type 0: " + packet.payload[0].ToString() + " " + packet.payload[1].ToString()); break; case 0x10: // Parse read data packet break; } }
/// <summary> /// Processes the packet stream. /// </summary> /// <returns>Task.</returns> private async Task ProcessPacketStream() { try { while (IsConnected && (OutgoingPackets.Count != 0 || TcpClient.Available != 0)) { while (IsConnected && TcpClient.Available != 0) { ReceivedPacket?.Invoke(this, new PacketEventArgs { Packet = await Packet.ReadFromStreamAsync(TcpClientStream) }); IncomingPacketReceieved = true; } if (!IsConnected || !CanSendPacket || OutgoingPackets.Count == 0) { continue; } await OutgoingPackets.Dequeue().WriteToStreamAsync(TcpClientStream); OutgoingPacketCooldown.Restart(); IncomingPacketReceieved = false; //// We've successfully sent or recieved data so the keepalive can be pushed back. Keepalive.Reset(); } } catch { // Lost connection with the server // No handling is necessary here as the TCPClient will set Connected to false. ServerConnectionDropped?.Invoke(this, new ServerConnectionEventArgs { Message = "Connection to the server has been lost.", Status = ServerConnectionStatusEnum.Disconnected, Timestamp = DateTime.Now }); } }
/// <summary> /// Цикл чтения пакетов из соединения /// </summary> /// <returns></returns> public async Task ReadAsync() { try { while (true) { short bodyLength = await ReadBodyLengthAsync(); byte[] body = new byte[bodyLength]; await ReadBodyAsync(body, bodyLength); var packet = new Packet(1, body); ReceivedPacket?.Invoke(packet); } } catch (Exception ex) { logger.Error($"Ошибка при чтении пакета: {ex.Message}"); //TODO: Тут надо новерно закрывать соединение } }
public void AuthenicatePrivateAPIAsync(string key, string signature, Action <bool> completed) { this.SendPacket(new RequestPrivateAPIAccessOutgoingPacket(key, signature), (c) => { if (c) { ReceivedPacket delegate_ = null; delegate_ = delegate(IncomingPacket packet) { completed?.Invoke((packet as PrivateAPIAuthenicationResponseIncomingPacket)?.Result ?? false); this.UnregisterPacketListenerUnsafe(delegate_); }; this.RegisterPacketListenerUnsafe(delegate_); } else { completed?.Invoke(false); } }); }
private async void ReceiverThreadFunc() { while (!CancellationTokenSource.IsCancellationRequested) { var response = await Response.FromStream(DeviceStream, CancellationTokenSource.Token); if (response == null) { DeviceSocket.Close(); taskEmitter.TrySetResult(null); break; } else if (response.ResponseCode == ResponseCode) { ResponseCode = 0; taskEmitter.TrySetResult(response); } else { ReceivedPacket?.Invoke(this, response); } } }
private byte[] CompileMessage(ReceivedPacket origPacket, byte[] payload) { byte opcode = (byte)origPacket.CommandCode; byte len1 = (byte)((ReceivedPacket.HeaderLength + payload.Length) / 256 | opcode << 3); // opcode 0x08 + length byte len2 = (byte)((ReceivedPacket.HeaderLength + payload.Length) % 256); byte[] buffer = { len1, len2, // Opcode & Length (byte)(origPacket.SessionId / 256), (byte)(origPacket.SessionId % 256), // session id 0x00, 0x00, // ACKed Pkt Id 0x00, 0x00, // Unknown 0x00, 0x00, // unknown2 (byte)(origPacket.PacketId / 256), (byte)(origPacket.PacketId % 256), // pkt id }; // If no payload, dont append it if (payload.Length == 0) { return(buffer); } return(buffer.Concat(payload).ToArray()); }
private void StartLogWriter() { var thread = new Thread(() => { while (true) { if (!_logQueue.TryDequeue(out LogItem item)) { Thread.Sleep(5); continue; } var packet = new ReceivedPacket(item.Payload); if (packet.CommandCode.HasFlag(ReceivedPacket.CommandCodeFlags.AckRequest) && !packet.CommandCode.HasFlag(ReceivedPacket.CommandCodeFlags.Handshake)) { string dirStr = item.IsSend ? "Send" : "Recv"; // Handle this further foreach (var rawCmd in packet.Commands) { var cmd = CommandParser.Parse(Version, rawCmd); if (cmd != null) { Log.InfoFormat("{0} {1} {2} ({3})", dirStr, rawCmd.Name, JsonConvert.SerializeObject(cmd), BitConverter.ToString(rawCmd.Body)); } else { Log.InfoFormat("{0} unknown {1} {2}", dirStr, rawCmd.Name, BitConverter.ToString(rawCmd.Body)); } } } } }); thread.Start(); }
private void AddToList(ReceivedPacket packet) { if (packet.Blocks.Count == 0) return; HashSet<ReceivedPacket> l; if (!packets.TryGetValue(packet.Blocks.Count, out l)) packets.Add(packet.Blocks.Count, l = new HashSet<ReceivedPacket>()); l.Add(packet); }
public void Xor(ReceivedPacket p) { if (Equals(p)) throw new Exception(); Xor(p.Data); foreach (var r in p.Blocks) if (!Blocks.Remove(r)) Blocks.Add(r); GenerateHash(); }
private void SubtractNewLeaf(ReceivedPacket leaf, Queue<ReceivedPacket> output) { var supersets = new HashSet<ReceivedPacket>(packets.SelectMany(a => a.Value).Where(a => a.Blocks.IsProperSupersetOf(leaf.Blocks))); foreach (var superset in supersets) { RemoveFromList(superset); superset.Xor(leaf); AddToList(superset); if (superset.Blocks.Count == 1) output.Enqueue(superset); } }
private bool RemoveFromList(ReceivedPacket packet) { HashSet<ReceivedPacket> l; if (packets.TryGetValue(packet.Blocks.Count, out l)) return l.Remove(packet); return false; }