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);
}
public override void PacketReceived(IDataPacket packet, IChannel sender)
{
if (packet is SystemInformationInitPacket)
{
SendPacket(new SystemInformationPacket());
}
}
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 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));
}
}
}
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)
{
}
