public BafPacket(PacketId id, byte[] data, PacketSource source = PacketSource.Server) { Id = id; Data = data; Source = source; IdValue = (ushort)id; }
public Packet(PacketSource _source, byte[] _data, DateTime _time) { data = _data; source = _source; gotTime = _time; RecalculatePreview(); }
public bool sendTimingReq(int dst, PacketSource destiny) { var pkt = buildTracerRequest(dst, destiny); pkt.linkDelay = Config.linkdelay_insp_to_tracetetcher; return(sendTimingReq(destiny, ref pkt)); }
public PonykartPacket(byte[] creator) { // Incoming packe Contents = GetContents(creator); Timestamp = GetTimestamp(creator); _Type = GetPType(creator); Source = PacketSource.Remote; }
public void OnPacketEventData(ref PacketEventData pEventData, PacketSource packetSource) { if (packetSource == PacketSource.File) { return; } var sessionId = pEventData.Header.SessionUID; if (pEventData.EventStringCode == "SSTA") { if (_files.TryGetValue(sessionId, out var stream)) { Logger.Warn( $"Received session start for SessionId {sessionId} that already exists in active session list, will overwrite"); stream.Dispose(); _files.Remove(sessionId); } var path = Path.Combine(_saveLocation, $"{_filePrefix}_{sessionId}.f1s.gz"); try { if (!Directory.Exists(_saveLocation)) { Directory.CreateDirectory(_saveLocation); } var fileStream = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.Read); var gzipStream = new GZipStream(fileStream, CompressionLevel.Optimal); _files[sessionId] = gzipStream; _ignoredSessions.Remove(sessionId); stream = gzipStream; Logger.Info($"Created save file for session {sessionId} at {path}"); } catch (Exception ex) { Logger.Error($"Exception while creating a save file for session {sessionId} at {path}", ex); } WritePacket(sessionId, ref pEventData, packetSource); } else if (pEventData.EventStringCode == "SEND") { if (_files.TryGetValue(sessionId, out var stream)) { WritePacket(sessionId, ref pEventData, packetSource); Logger.Info($"Closing save file for session {sessionId}"); stream.Dispose(); _files.Remove(sessionId); } else { Logger.Warn($"Received session end for session {sessionId}, but no file is opened for saving"); } } }
/// <summary> /// Binds the packet. /// </summary> /// <param name="encryptedData">The encrypted data.</param> /// <param name="interceptedDate">The intercepted date.</param> /// <param name="connection">The connection.</param> /// <param name="source">The source.</param> /// <param name="cripto">The cripto.</param> /// <returns></returns> public static Packet BindPacket(byte[] encryptedData, DateTime interceptedDate, ConnectionProvider connection, PacketSource source) { return new Packet { EncryptedData = encryptedData, ConnectionSource = connection, InterceptedDate = interceptedDate, PacketSource = source, }; }
public void OnPacketEventData(ref PacketEventData pEventData, PacketSource packetSource) { if (pEventData.EventStringCode == "SSTA") { _sessionLastTimes[pEventData.Header.SessionUID] = 0.0f; } else { _sessionLastTimes.Remove(pEventData.Header.SessionUID); } }
private void RegisterScanner( string packetName, string tutorial, PacketSource source, Func <IpcPacket, string[], bool> del, string[] paramPrompts = null) { bool Fn(IpcPacket a, string[] b, Comment c) => del(a, b); RegisterScanner(packetName, tutorial, source, Fn, paramPrompts); }
public void OnPacketEventData(ref PacketEventData pEventData, PacketSource source) { var sc = pEventData.EventStringCode; Event sessionEvent = sc switch { "SSTA" => (Event) new SessionStart(pEventData.Header.SessionUID, DateTime.Now, pEventData.Header.SessionTime), "SEND" => (Event) new SessionEnd(pEventData.Header.SessionUID, DateTime.Now, pEventData.Header.SessionTime), _ => throw new InvalidOperationException($"Invalid session type {sc}") }; _newPacketRead?.Invoke(this, sessionEvent); }
public BafPacket(ushort id, byte[] data, PacketSource source = PacketSource.Server) { IdValue = id; Data = data; Source = source; if (Enum.IsDefined(typeof(PacketId), id)) { Id = (PacketId)id; } else { Id = PacketId.Unknown; } }
public override bool sendFunctionalReq(PacketSource destiny, ref Packet pkt) { switch (destiny) { case PacketSource.TraceFetcher: DEBUG.Assert(pkt.isRequest() && pkt.isRead()); pkt.ts_departure = GlobalTimer.tick; ins_port._masterPort.recvFunctionalReq(pkt); return(true); default: return(false); } }
public Packet buildTracerRequest(int dst, PacketSource destiny) { switch (destiny) { case PacketSource.TraceFetcher: Packet pkt = new Packet(CMD.ReadReq); pkt.source = PacketSource.Insp; pkt.BuildData(dst); return(pkt); default: return(null); } }
private void Delay(ulong sessionId, float sessionTime, PacketSource packetSource) { if (packetSource != PacketSource.File || !_delayScale.Enabled) { return; } var lastSessionTime = _sessionLastTimes[sessionId]; var diff = sessionTime - lastSessionTime; var scaledDiff = diff * _delayScale; Thread.Sleep(TimeSpan.FromSeconds(scaledDiff)); _sessionLastTimes[sessionId] = sessionTime; }
/// <summary> /// Adds a scanner to the scanner registry. /// </summary> /// <param name="packetName">The name (Sapphire-style) of the packet.</param> /// <param name="tutorial">How the packet's conditions are created.</param> /// <param name="source">Whether the packet originates on the client or the server.</param> /// <param name="del">A boolean function that returns true if a packet matches the contained heuristics.</param> /// <param name="paramPrompts">An array of requests for auxiliary data that will be passed into the detection delegate.</param> private void RegisterScanner( string packetName, string tutorial, PacketSource source, Func <IpcPacket, string[], Comment, bool> del, string[] paramPrompts = null) { this.scanners.Add(new Scanner { PacketName = packetName, Tutorial = tutorial, ScanDelegate = del, Comment = new Comment(), ParameterPrompts = paramPrompts ?? new string[] { }, PacketSource = source, }); }
private PacketModel GetPacketModel(PacketSource source, Server server, Client client, Packet packet) { var packetModel = new PacketModel { Client = client, Server = server, ID = new Random().Next(999, 9999), EndPoint = (packet.UdpPacket) ? packet.EndPoint : client.EndPoint, Bytes = packet.Buffer, Length = packet.Buffer.Length, Type = (packet.UdpPacket) ? PacketType.UDP : PacketType.TCP, Source = source }; packetModel.TypeHelp = string.Format ("{0}, {1}", packetModel.Type, packetModel.Source); return(packetModel); }
private void WritePacket <T>(ulong sessionId, ref T packet, PacketSource source) where T : struct { if (source == PacketSource.File) { return; } if (_files.TryGetValue(sessionId, out var stream)) { var readOnlySpan = MemoryMarshal.CreateReadOnlySpan(ref packet, 1); var onlySpan = MemoryMarshal.AsBytes(readOnlySpan); stream.Write(onlySpan); } else if (!_ignoredSessions.Contains(sessionId)) { Logger.Warn($"Ignoring this and further messages for session {sessionId} until session start event comes through and save file is created"); _ignoredSessions.Add(sessionId); } }
internal async void StartListenData(CancellationToken cancellationToken, PacketSource source, bool isListener) { _cancellationToken = cancellationToken; _source = source; _isListener = isListener; while (Connected && !cancellationToken.IsCancellationRequested) { if (!_socket.IsBound) { break; } _socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(ReadCallback), null); try { if (_isListener) { if (!await _waiterData.WaitAsync(TimeSpan.FromSeconds(60), cancellationToken)) { await Send(Ping.Default); if (!await _waiterData.WaitAsync(TimeSpan.FromSeconds(5), cancellationToken)) { await Disconnect(); } } } else { await _waiterData.WaitAsync(Timeout.Infinite, cancellationToken); } } catch (OperationCanceledException) { break; } } }
public void OnPacketSessionData(ref PacketSessionData pSessionData, PacketSource _) { var timestamp = DateTime.Now; var sessionId = pSessionData.Header.SessionUID; var sessionTime = pSessionData.Header.SessionTime; var weather = new WeatherInfo( (Weather)pSessionData.Weather, pSessionData.TrackTemperature, pSessionData.AirTemperature, sessionId, timestamp, sessionTime); _newPacketRead?.Invoke(this, weather); var trackInfo = new TrackInfo( (Track)pSessionData.TrackId, pSessionData.TrackLength, sessionId, timestamp, sessionTime); _newPacketRead?.Invoke(this, trackInfo); var sessionPause = pSessionData.GamePaused != 0 ? (Event) new SessionPause(sessionId, timestamp, sessionTime) : (Event) new SessionResume(sessionId, timestamp, sessionTime); _newPacketRead?.Invoke(this, sessionPause); var sessionDuration = new SessionDuration(TimeSpan.FromSeconds(pSessionData.SessionDuration), sessionId, timestamp, sessionTime); _newPacketRead?.Invoke(this, sessionDuration); var sessionTimeLeft = new SessionTimeLeft(TimeSpan.FromSeconds(pSessionData.SessionTimeLeft), sessionId, timestamp, sessionTime); _newPacketRead?.Invoke(this, sessionTimeLeft); }
public static Packet Read(Stream ms) { //Read the 14 bytes of header. //[0-3] Data length //[4-12] Timestamp ticks //[13-14] Source byte[] buf = new byte[4]; ms.Read(buf, 0, 4); if (BitConverter.IsLittleEndian == false) { Array.Reverse(buf); } int length = BitConverter.ToInt32(buf, 0); buf = new byte[8]; ms.Read(buf, 0, 8); if (BitConverter.IsLittleEndian == false) { Array.Reverse(buf); } DateTime dt = new DateTime(BitConverter.ToInt64(buf, 0)); buf = new byte[2]; ms.Read(buf, 0, 2); if (BitConverter.IsLittleEndian == false) { Array.Reverse(buf); } PacketSource src = (PacketSource)BitConverter.ToInt16(buf, 0); //Read in actual data. buf = new byte[length]; ms.Read(buf, 0, length); //Create packet. return(new Packet(src, buf, dt)); }
internal PacketResult Handle(PacketSource source, Session session, Packet packet) { switch (source) { case PacketSource.Certificator: if (_certificatorHandler.ContainsKey(packet.Opcode)) { return(_certificatorHandler[packet.Opcode].Invoke(session, packet)); } break; case PacketSource.Module: if (_moduleHandler.ContainsKey(packet.Opcode)) { return(_moduleHandler[packet.Opcode].Invoke(session, packet)); } break; } //if (StaticLogger.Instance.IsTraceEnabled) // StaticLogger.Instance.Warn("[{7}][{0:X4}][{1} bytes]{2}{3}{4}{5}{6}", packet.Opcode, packet.Length, packet.Encrypted ? "[Encrypted]" : "", packet.Massive ? "[Massive]" : "", Environment.NewLine, packet.GetBytes().HexDump(), Environment.NewLine, source); return(PacketResult.None); }
/// <summary> /// Initialize All Events and Initial Values of Object. /// </summary> protected void Initialize() { state = ConnectionState.Disconnected; packetsToSave = PacketSource.Unknow; Xtea = new NativeCryptoManager(CryptoType.Xtea, this); RSA = new NativeCryptoManager(CryptoType.RSA, this); IPLocal = new IPAddress(new byte[] { 127, 0, 0, 1 }); OnBeforeConnect += Connection_OnBeforeConnect; OnConnect += Connection_OnConnect; OnAfterConnect += Connection_OnAfterConnect; OnBeforeDisconnect += Connection_OnBeforeDisconnect; OnDisconnect += Connection_OnDisconnect; OnAfterDisconnect += Connection_OnAfterDisconnect; }
/// <summary> /// Fire a changed packet event. /// </summary> internal void FireChangedPacket(byte[] data, PacketSource source) { lock (this) { if (PacketChanged != null) { var packets = PacketBuilder.GetPackets(data, this, source); foreach (var packet in packets) { PacketChanged(this, new PacketEventArgs(packet, source)); } } } }
public ulong sendAtomic(PacketSource source, ref Packet pkt) { Debug.Fail(String.Format("{0} was not expecting a sendAtomic request\n", name())); return(0); }
public void OnPacketCarTelemetryData(ref PacketCarTelemetryData pTelemetry, PacketSource packetSource) { WritePacket(pTelemetry.Header.SessionUID, ref pTelemetry, packetSource); }
private void PacketSource_ReceivedPacket(PacketSource<WaxPacket> sender, PacketEventArgs<WaxPacket> e) { // If a correctly parsed packet... if (e.Packet != null && e.Packet is WaxPacket) { WaxPacket packet = (WaxPacket)e.Packet; //Console.WriteLine("[" + packet.Timestamp + "]"); //Console.WriteLine(packet.ToString()); lock (SyncRoot) { if (!waxDevices.ContainsKey(packet.DeviceId)) { // Create new device waxDevices.Add(packet.DeviceId, new WaxDevice(packet.DeviceId, packet.Timestamp)); OnNewDevice(new ManagerEventArgs(waxDevices[packet.DeviceId])); } WaxDevice waxDevice = waxDevices[packet.DeviceId]; waxDevice.AddSamples(packet.Samples); // Forward packet to all destinations foreach (PacketDest<WaxPacket> dest in packetDests) { dest.SendPacket(packet); } if (packet != null) { DebugString = packet.ToString(); } } OnReceivedPacket(new ManagerEventArgs(waxDevices[packet.DeviceId], packet)); } }
public void AddPacketSource(PacketSource<WaxPacket> source) { packetSources.Add(source); source.ReceivedPacket += PacketSource_ReceivedPacket; }
/// <summary> /// Initializes a new instance of the <see cref="PacketEventArgs"/> class. /// </summary> /// <param name="packet">The packet.</param> /// <param name="source">The source.</param> public PacketEventArgs(Packet packet, PacketSource source) { Packet = packet; Source = source; }
/// <summary> /// Fires the changed packet. /// </summary> /// <param name="data">The data.</param> /// <param name="source">The source.</param> internal void FireChangedPacket(byte[] data, PacketSource source) { if (PacketChanged != null) { var packets = PacketBuilder.GetPackets(data, this, source); packets.ForEach(pk => PacketChanged(this, new PacketEventArgs(pk, source))); } }
public void OnPacketSessionData(ref PacketSessionData pSessionData, PacketSource packetSource) { WritePacket(pSessionData.Header.SessionUID, ref pSessionData, packetSource); }
public void OnPacketParticipantsData(ref PacketParticipantsData pParticipants, PacketSource packetSource) { WritePacket(pParticipants.Header.SessionUID, ref pParticipants, packetSource); }
public void OnPacketMotionData(ref PacketMotionData pMotion, PacketSource packetSource) { WritePacket(pMotion.Header.SessionUID, ref pMotion, packetSource); }
public void OnPacketCarSetupData(ref PacketCarSetupData pCarSetup, PacketSource packetSource) { WritePacket(pCarSetup.Header.SessionUID, ref pCarSetup, packetSource); }
public PonykartPacket(Commands type, string contents, Connection c, bool isVolatile) { // Outgoing Contents = System.Text.ASCIIEncoding.ASCII.GetBytes(contents); Timestamp = System.DateTime.Now.Ticks; _Type = (Int32)type; Owner = c; Source = PacketSource.Local; Volatile = isVolatile; }
public PonykartPacket(Commands type, byte[] contents, Connection c, bool isVolatile) { // Outgoing Contents = contents; Timestamp = System.DateTime.Now.Ticks; _Type = (Int32)type; Owner = c; Source = PacketSource.Local; Volatile = isVolatile; }
public virtual bool sendTimingResq(PacketSource source, ref Packet pkt) { throw new NotImplementedException(); }
public bool sendTimingSnoopResp(PacketSource source, ref Packet pkt) { Debug.Fail(String.Format("{0} was not expecting a sendTimingSnoopResp request\n", name())); return(false); }
public void sendFunctionalSnoopReq(PacketSource source, ref Packet pkt) { Debug.Fail(String.Format("{0} was not expecting a sendFunctionalSnoopReq request\n", name())); }
public void RemovePacketSource(PacketSource<WaxPacket> source) { source.ReceivedPacket -= PacketSource_ReceivedPacket; packetSources.Remove(source); }
public bool sendFunctionalResq(PacketSource source, ref Packet pkt) { Debug.Fail(String.Format("{0} was not expecting a sendFunctionalResq request\n", name())); return(false); }
public void OnPacketLapData(ref PacketLapData pLap, PacketSource packetSource) { WritePacket(pLap.Header.SessionUID, ref pLap, packetSource); }
public void OnPacketCarStatusData(ref PacketCarStatusData pCarStatus, PacketSource packetSource) { WritePacket(pCarStatus.Header.SessionUID, ref pCarStatus, packetSource); }