public static ReaderParameters GetReaderParameters(this IScanContext context) { var provide = context.Options.Find <IProvideReaderParameters>(); if (provide == null) { provide = new ProvideReaderParameters(); context.Options.Add(provide); } var parameters = provide.ReaderParameters; if (parameters == null) { parameters = new ReaderParameters(); provide.ReaderParameters = parameters; } if (parameters.AssemblyResolver == null) { parameters.AssemblyResolver = new DefaultAssemblyResolver(); } return(parameters); }
public override IEnumerable <T> Scan(IScanContext context) { var items = GetParentItemsOrEmpty(context); var results = items.Select(MapItem); return(results); }
public override IEnumerable <T> Scan(IScanContext context) { var items = GetParentItemsOrEmpty(context); var results = items.Distinct(Comparer); return(results); }
/// <summary> /// Helper function for child scanner implementations that will always /// returns a valid non-null collection of items from the parent <see cref="IScanner{TIn}"/>. /// </summary> /// <param name="context">An <see cref="IScanContext"/> that provides scanning options at runtime.</param> /// <returns>An <see cref="IEnumerable{T}"/> that contains the items provided by the <see cref="Parent"/> scanner.</returns> protected virtual IEnumerable <TIn> GetParentItemsOrEmpty(IScanContext context) { var parent = Parent ?? context.Factory.Empty <TIn>(); var items = parent.Scan(context) ?? Enumerable.Empty <TIn>(); return(items); }
public override IEnumerable <TOut> Scan(IScanContext context) { var items = GetParentItemsOrEmpty(context); var results = items.SelectMany(item => _transform(context, item)); return(results); }
public static IEnumerable <Assembly> LoadAssembly(IScanContext context, AssemblyName assemblyName) { if (assemblyName == null) { return(Enumerable.Empty <Assembly>()); } try { var assembly = Assembly.Load(assemblyName); return(new[] { assembly }); } catch (BadImageFormatException) { // skip on error } catch (FileNotFoundException) { // skip on error } catch (FileLoadException) { // skip on error } catch (Exception exception) { var ignore = context.Options.FindAll <ITransformIgnoreException>(); if (!ignore.Any(_ => _.IgnoreException("LoadAssembly", exception))) { throw; } } return(Enumerable.Empty <Assembly>()); }
public Mpeg2SystemCarver(IMpeg2SystemReader reader, IResultParser <IMpeg2SystemReader> systemHeaderParser, IScanContext scanContext) { _reader = reader; _systemHeaderParser = systemHeaderParser; _scanContext = scanContext; _state = reader.State; _minHeaderCount = (uint)Mpeg2SystemDetector.Configurable[Mpeg2SystemDetector.ConfigurationKey.MinSystemHeaderCount]; }
public Mpeg2VideoCarver(IMpeg2VideoReader reader, IResultParser <IMpeg2VideoReader> videoHeaderParser, IScanContext scanContext) { _reader = reader; _videoHeaderParser = videoHeaderParser; _scanContext = scanContext; _state = reader.State; _minHeaderCount = (uint)Mpeg2VideoDetector.Configurable[Mpeg2VideoDetector.ConfigurationKey.MinVideoHeaderCount]; }
public override IEnumerable <T> Scan(IScanContext context) { var items = GetParentItemsOrEmpty(context); var result = items .Where(item => _includeList.Any(predicate => predicate(context, item))) .Where(item => !_excludeList.Any(predicate => predicate(context, item))); return(result); }
public static TypeDefinition ResolveTypeDefinition(this IScanContext context, Type type) { var cache = context.Options.Find <TypeDefinitionCache>(); if (cache == null) { cache = new TypeDefinitionCache(); context.Options.Add(cache); } return(cache.ResolveTypeDefinition(context, type)); }
/// <summary> /// Gets the data for the given <paramref name="codecStream"/> and /// reports progress to the given <paramref name="progressReporter"/>. /// This rescans the parent (container) of the codecStream to determine /// the data of codecStream. /// </summary> /// <param name="codecStream">the codec stream to retrieve the data for</param> /// <param name="progressReporter">the progress reporter</param> /// <param name="dataReaderPool">The shared pool of file data readers</param> /// <returns>the root node of the results</returns> public IDataPacket GetData(ICodecStream codecStream, IProgressReporter progressReporter, IDataReaderPool dataReaderPool) { IDataPacket data; if (_dataCache.TryGetValue(codecStream, out data)) { return(new RescannedCodecStream(codecStream, data)); } IDataBlock containerStreamDataBlock = codecStream.DataBlock; using (IDataReader dataReader = new ProgressDataReader(new FragmentedDataReader(containerStreamDataBlock, dataReaderPool), progressReporter)) { IDetector containerDetector = containerStreamDataBlock.Detectors.FirstOrDefault(); IScanContext scanContext = _createScanContext(containerStreamDataBlock.InputFile.Project); scanContext.Detectors = new[] { containerDetector }; IDataBlockBuilder containerStreamDataBlockBuilder = _createDataBlockBuilder(); containerStreamDataBlockBuilder.Detectors = scanContext.Detectors; containerStreamDataBlockBuilder.InputFile = containerStreamDataBlock.InputFile; IDataBlock newContainerStream = containerDetector.DetectData(dataReader, containerStreamDataBlockBuilder, scanContext); // Check cancellation request if (progressReporter.CancellationPending) { return(null); } // Check results / container stream if (newContainerStream == null) { RetrievedDetectableIsDifferentThanTheOneRetrievedDuringTheInitialScan(); return(null); } data = newContainerStream.CodecStreams.Where(c => c.StreamNumber == codecStream.StreamNumber).FirstOrDefault(); if ((data == null) || (data.Length < codecStream.EndOffset)) { RetrievedDetectableIsDifferentThanTheOneRetrievedDuringTheInitialScan(); return(null); } data = data.GetSubPacket(codecStream.StartOffset, codecStream.Length); } CacheData(codecStream, data); return(new RescannedCodecStream(codecStream, data)); }
private bool GetNextDataBlock(IInputFile file, IDataReader dataReader, IScanContext scanContext, out IDataBlock volBlock, out IDataBlockBuilder volBuilder) { IDataBlock volBlockAttempt = null; IDataBlockBuilder volBlockAttemptBuilder = null; while (volBlockAttempt == null && dataReader.State == DataReaderState.Ready) { volBlockAttemptBuilder = CreateBuilder(file); scanContext.Detectors = new[] { _detector }; volBlockAttempt = _detector.DetectData(dataReader, volBlockAttemptBuilder, scanContext); } volBlock = volBlockAttempt; volBuilder = volBlockAttemptBuilder; return(volBlock != null); }
public static IEnumerable <AssemblyDefinition> ReadAssembly(IScanContext context, FileInfo fileInfo) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (fileInfo == null) { throw new ArgumentNullException(nameof(fileInfo)); } var path = fileInfo.FullName; var assembly = ReadAssembly(context, path); return(assembly); }
public override IEnumerable <T> Scan(IScanContext context) { var cache = _cache; if (cache != null) { return(cache); } var items = GetParentItemsOrEmpty(context); cache = items.ToArray(); _cache = cache; return(cache); }
public H264ResultTreeBuilder(BitStreamDataReader dataReader, IH264Reader reader, IH264State state, IScanContext scanContext, NalUnitStreamParser nalUnitStreamParser, ByteStreamParser byteStreamParser) { _falseHitReduction = (bool)H264Detector.Configurable[H264Detector.ConfigurationKey.FalseHitReduction]; _dataReader = dataReader; _reader = reader; _state = state; _scanContext = scanContext; _nalUnitStreamParser = nalUnitStreamParser; _byteStreamParser = byteStreamParser; Configurable <H264Detector.ConfigurationKey> configurable = H264Detector.Configurable; _maxGapBetweenPpsAndSlice = (uint)configurable[H264Detector.ConfigurationKey.MaxGapBetweenPpsAndSlice]; _maxGapBetweenPpsAndSps = (uint)configurable[H264Detector.ConfigurationKey.MaxGapBetweenPpsAndSps]; _maxGapBetweenNalUnits = (uint)configurable[H264Detector.ConfigurationKey.MaxGapBetweenNalUnits]; }
public TypeDefinition ResolveTypeDefinition(IScanContext context, Type type) { var token = new MetadataToken((uint)type.MetadataToken); var typeDefinition = _cache[token] as TypeDefinition; if (typeDefinition == null) { var parameters = context.GetReaderParameters(); var assembly = AssemblyDefinition.ReadAssembly(type.Assembly.Location, parameters); var typeReference = assembly.MainModule.GetTypes().Single(_ => _.MetadataToken == token); typeDefinition = typeReference.Resolve(); _cache[token] = typeDefinition; } return(typeDefinition); }
public static IEnumerable <AssemblyDefinition> ReadAssembly(IScanContext context, AssemblyNameReference assemblyName) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (assemblyName == null) { throw new ArgumentNullException(nameof(assemblyName)); } var parameters = context.GetReaderParameters(); var resolver = parameters.AssemblyResolver ?? new DefaultAssemblyResolver(); var assembly = resolver.Resolve(assemblyName, parameters); return(new[] { assembly }); }
public ReaderState(IActiveState activeState, IResultNodeCallback resultNodeCallback, IResultNode rootResultNode, IResultMetadata resultMetadata, IScanContext scanContext, Creator <IResultNodeBuilder> createResultNodeBuilder, Creator <IResultNodeState, IState, IResultNodeBuilder> createResultNodeReaderState) { _activeState = activeState; _resultNodeCallback = resultNodeCallback; _rootResultNode = rootResultNode; _resultMetadata = resultMetadata; _scanContext = scanContext; _createResultNodeBuilder = createResultNodeBuilder; _createResultNodeReaderState = createResultNodeReaderState; _scanContext.Results = rootResultNode; Valid = true; _activeState.ChangeState(this); }
public static IEnumerable <FileInfo> EnumerateFiles(IScanContext context, string directory, string pattern, SearchOption option) { if (String.IsNullOrEmpty(directory)) { return(Enumerable.Empty <FileInfo>()); } if (String.IsNullOrEmpty(pattern)) { return(Enumerable.Empty <FileInfo>()); } try { var info = new DirectoryInfo(directory); return(!info.Exists ? Enumerable.Empty <FileInfo>() : info.EnumerateFiles(pattern, option)); } catch (UnauthorizedAccessException) { // skip on error } catch (DirectoryNotFoundException) { // skip on error } catch (SecurityException) { // skip on error } catch (IOException) { // skip on error } catch (Exception exception) { var ignore = context.Options.FindAll <ITransformIgnoreException>(); if (!ignore.Any(_ => _.IgnoreException("EnumerateFiles", exception))) { throw; } } return(Enumerable.Empty <FileInfo>()); }
public void TestConstructorDefaultFormat() { using (IDataReader dataReader = new MockDataReader(new byte[DataFileLength], _inputFile)) { IDetector detector = new UnknownFormatDetector(); IScanContext scanContext = TestFramework.CreateScanContext(_project); scanContext.Detectors = new[] { detector }; IDataBlockBuilder builder = TestFramework.CreateDataBlockBuilder(); builder.Detectors = scanContext.Detectors; builder.InputFile = _inputFile; IDataBlock dataBlock = detector.DetectData(dataReader, builder, scanContext); Assert.IsNotNull(dataBlock); IResultNode results = scanContext.Results; Assert.IsNotNull(results); Assert.GreaterOrEqual(results.Children.Count, 1); Assert.AreEqual(0, results.Children[0].Attributes.Count); } }
public static IEnumerable <AssemblyDefinition> ReadAssembly(IScanContext context, string path) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (path == null) { throw new ArgumentNullException(nameof(path)); } try { var parameters = context.GetReaderParameters(); var assembly = AssemblyDefinition.ReadAssembly(path, parameters); return(new[] { assembly }); } catch (BadImageFormatException) { // skip on error } catch (DirectoryNotFoundException) { // skip on error } catch (FileNotFoundException) { // skip on error } catch (FileLoadException) { // skip on error } catch (Exception exception) { var ignore = context.Options.FindAll <ITransformIgnoreException>(); if (!ignore.Any(_ => _.IgnoreException("ReadAssembly", exception))) { throw; } } return(Enumerable.Empty <AssemblyDefinition>()); }
/// <summary> /// You do not need a project file for this kind of scan /// </summary> /// <param name="byteStream"></param> public DataBlockVerification Scan(byte[] byteStream) { IScanContext scanContext = TestFramework.CreateScanContext(_project); IDataBlock dataBlock = ScanDataBlock(byteStream, scanContext); Assert.IsNotNull(dataBlock); // Data block detected, perform a rescan for the results IScanContext rescanContext = TestFramework.CreateScanContext(_project); rescanContext.Detectors = dataBlock.Detectors; var detectedByteStream = new byte[dataBlock.Length]; Array.Copy(byteStream, dataBlock.StartOffset, detectedByteStream, 0, detectedByteStream.Length); ScanDataBlock(detectedByteStream, rescanContext); Assert.IsNotNull(rescanContext.Results); return(new DataBlockVerification(dataBlock, rescanContext.Results, "using " + _videoDetector.Name + " detected datablock within memory buffer of size " + byteStream.Length + "." + TestFramework.GetDescriptionText(rescanContext.Results))); }
private IDataBlock ScanDataBlock(byte[] byteStream, IScanContext scanContext) { scanContext.Detectors = new[] { _videoDetector }; IDataBlockBuilder builder = TestFramework.CreateDataBlockBuilder(); builder.Detectors = scanContext.Detectors; var inputFile = _mockRepository.StrictMock <IInputFile>(); With.Mocks(_mockRepository).Expecting(delegate { SetupResult.For(inputFile.Name).Return("<ByteArrayDataReader>"); SetupResult.For(inputFile.Length).Return(byteStream.Length); }); builder.InputFile = inputFile; var mockDataReader = new MockDataReader(byteStream, inputFile); IDataBlock dataBlock = _videoDetector.DetectData(mockDataReader, builder, scanContext); Assert.IsNotNull(dataBlock); return(dataBlock); }
private void BuildReferenceHeaders(IScanContext context, IDataBlockBuilder dataBlockBuilder) { var referenceHeaders = new Dictionary <IDataPacket, IPictureState>(); foreach (IReferenceHeader header in ReferenceHeaders) { IInputFile headerFile = context.CreateReferenceHeaderFile(header); using (var reader = headerFile.CreateDataReader()) { var headerDataBlock = _carver.Carve(new BitStreamDataReader(reader), dataBlockBuilder, context); if (headerDataBlock != null) { referenceHeaders[headerFile.CreateDataPacket()] = context.ReferenceHeader as IPictureState; } } } // Set reference header and reset other state context.ReferenceHeader = referenceHeaders; context.Results = null; context.IsFragmented = false; }
public static IEnumerable <AssemblyDefinition> ReadAssembly(IScanContext context, AssemblyName assemblyName) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (assemblyName == null) { throw new ArgumentNullException(nameof(assemblyName)); } var path = assemblyName.CodeBase; if (!String.IsNullOrEmpty(path) && File.Exists(path)) { return(ReadAssembly(context, path)); } var assemblyNameDefinition = assemblyName.GetAssemblyNameDefinition(); var assembly = ReadAssembly(context, assemblyNameDefinition); return(assembly); }
public void TestDetectData() { using (IDataReader dataReader = new MockDataReader(new byte[DataFileLength], _inputFile)) { IScanContext scanContext = TestFramework.CreateScanContext(_project); scanContext.Detectors = new[] { _detector }; IDataBlockBuilder builder = TestFramework.CreateDataBlockBuilder(); builder.Detectors = scanContext.Detectors; builder.InputFile = _inputFile; IDataBlock dataBlock = _detector.DetectData(dataReader, builder, scanContext); Assert.IsNotNull(dataBlock, "Unknown format detector (DetectData not null)"); IResultNode results = scanContext.Results; Assert.IsNotNull(results, "Unknown format detector (Results not null)"); Assert.AreEqual(_detector, dataBlock.Detectors.First(), "Detector of data block"); Assert.AreEqual(1, results.Children.Count, "One child 'Data'"); IResultNode data = results.Children[0]; Assert.IsEmpty((ICollection)data.Children, "Data has no children"); Assert.AreEqual(0, data.StartOffset, ""); Assert.AreEqual(DataFileLength, data.Length, ""); Assert.IsFalse(data.IsFragmented(), "Single fragment"); Assert.AreEqual(_inputFile, data.InputFile, "Input file"); Assert.IsFalse(dataBlock.IsFullFile, "Does not produce full files"); } }
public static IEnumerable <AssemblyName> GetAssemblyName(IScanContext context, FileInfo fileInfo) { if (fileInfo == null || !fileInfo.Exists) { return(Enumerable.Empty <AssemblyName>()); } try { var path = fileInfo.FullName; var assemblyName = AssemblyName.GetAssemblyName(path); return(new[] { assemblyName }); } catch (BadImageFormatException) { // skip on error } catch (FileNotFoundException) { // skip on error } catch (FileLoadException) { // skip on error } catch (Exception exception) { var ignore = context.Options.FindAll <ITransformIgnoreException>(); if (!ignore.Any(_ => _.IgnoreException("GetAssemblyName", exception))) { throw; } } return(Enumerable.Empty <AssemblyName>()); }
/// <summary>Detects the next data block.</summary> /// <param name="dataReader">the data to scan</param> /// <param name="dataBlockBuilder">the builder for creating the data block</param> /// <returns>the data block that was detected; <c>null</c> for none</returns> public void DetectNextDataBlock(IDataReader dataReader, IDataBlockBuilder dataBlockBuilder) { IInputFile inputFile = dataReader.GetDataPacket(Position, 1).InputFile; IScanContext scanContext = _createScanContext(inputFile.Project); scanContext.Detectors = new[] { /*?*/ Detector }; dataBlockBuilder.InputFile = inputFile; dataBlockBuilder.PreviousFragment = LastDataBlock; dataBlockBuilder.Detectors = scanContext.Detectors; LastDataBlock = Detector.DetectData(dataReader, dataBlockBuilder, scanContext); Position = ((LastDataBlock == null) || _dataScanner.AllowOverlap) ? dataReader.Position : LastDataBlock.EndOffset; if (!_dataScanner.AllowOverlap && (LastDataBlock != null)) { if (OverlapsWithLargerDataBlock()) { DiscardLastDataBlock(); } else { DiscardOverlappingDataBlocks(); } } }
public override IEnumerable <T> Scan(IScanContext context) { return(GetParentItemsOrEmpty(context)); }
public override IEnumerable <T> Scan(IScanContext context) { return(Enumerable.Empty <T>()); }