aaru-dps/Aaru
1
0
Fork 0
mirror of https://github.com/aaru-dps/Aaru.git synced 2026-07-08 18:16:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

[LIF] Add support for analyze command

Browse Source
This commit is contained in:
Natalia Portillo
2026-04-10 23:13:29 +01:00
parent d87a64eda3
commit 31e726bcb4
1 changed files with 177 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

177
Aaru.Filesystems/LIF/Analyze.cs Normal file
View File

@@ -0,0 +1,177 @@
// /***************************************************************************
// Aaru Data Preservation Suite
// ----------------------------------------------------------------------------
//
// Filename : Analyze.cs
// Author(s) : Natalia Portillo <claunia@claunia.com>
//
// Component : HP Logical Interchange Format plugin.
//
// --[ License ] --------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2026 Natalia Portillo
// ****************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Aaru.CommonTypes;
using Aaru.CommonTypes.Enums;
using Aaru.CommonTypes.Structs;
using Aaru.Helpers;
namespace Aaru.Filesystems;
// Information from http://www.hp9845.net/9845/projects/hpdir/#lif_filesystem
/// <inheritdoc />
public sealed partial class LIF
{
#region IReadOnlyFilesystem Members
/// <inheritdoc />
public ErrorNumber GetFilesWithAffectedSectors(IEnumerable<(ulong Start, ulong End)> sectorExtents,
out List<FileSectorInfo> files,
InitProgressHandler initProgress = null,
UpdateProgressHandler updateProgress = null,
PulseProgressHandler pulseProgress = null,
EndProgressHandler endProgress = null)
{
files = [];
if(!_mounted) return ErrorNumber.AccessDenied;
if(sectorExtents is null) return ErrorNumber.InvalidArgument;
List<(ulong Start, ulong End)> normalizedExtents = NormalizeAnalyzeExtents(sectorExtents);
if(normalizedExtents.Count == 0 || _rootDirectoryCache is null || _rootDirectoryCache.Count == 0)
return ErrorNumber.NoError;
try
{
initProgress?.Invoke();
pulseProgress?.Invoke("/");
DirectoryEntry[] orderedEntries = _rootDirectoryCache
.OrderBy(static entry =>
StringHandlers.CToString(entry.fileName, Encoding.ASCII)
.TrimEnd(),
StringComparer.CurrentCultureIgnoreCase)
.ToArray();
long maximum = orderedEntries.Length > 0 ? orderedEntries.Length : 1;
for(var i = 0; i < orderedEntries.Length; i++)
{
string entryName = StringHandlers.CToString(orderedEntries[i].fileName, _encoding).TrimEnd();
if(string.IsNullOrWhiteSpace(entryName)) continue;
string entryPath = "/" + entryName;
updateProgress?.Invoke(entryPath, i + 1, maximum);
AddOverlappingFile(entryPath, orderedEntries[i], normalizedExtents, files);
}
return ErrorNumber.NoError;
}
finally
{
endProgress?.Invoke();
}
}
#endregion
void AddOverlappingFile(string path, DirectoryEntry entry, IReadOnlyList<(ulong Start, ulong End)> sectorExtents,
List<FileSectorInfo> files)
{
if(entry.fileLength == 0) return;
List<(ulong Start, ulong End)> overlaps = FindOverlappingExtents(entry.fileStart,
entry.fileLength,
sectorExtents);
if(overlaps.Count == 0) return;
files.Add(new FileSectorInfo
{
Path = path,
Inode = entry.fileStart,
AffectedSectors = overlaps
});
}
List<(ulong Start, ulong End)> FindOverlappingExtents(uint startSector, uint lengthInSectors,
IReadOnlyList<(ulong Start, ulong End)> sectorExtents)
{
List<(ulong Start, ulong End)> overlaps = [];
if(lengthInSectors == 0) return overlaps;
ulong absoluteStartSector = _partition.Start + startSector;
ulong absoluteEndSector = absoluteStartSector + lengthInSectors - 1;
AddExtentOverlaps(absoluteStartSector, absoluteEndSector, sectorExtents, overlaps);
return NormalizeAnalyzeExtents(overlaps);
}
static void AddExtentOverlaps(ulong startSector, ulong endSector,
IReadOnlyList<(ulong Start, ulong End)> sectorExtents,
List<(ulong Start, ulong End)> overlaps)
{
foreach((ulong Start, ulong End) requestedExtent in sectorExtents)
{
if(requestedExtent.End < startSector || requestedExtent.Start > endSector) continue;
overlaps.Add((Math.Max(startSector, requestedExtent.Start), Math.Min(endSector, requestedExtent.End)));
}
}
static List<(ulong Start, ulong End)> NormalizeAnalyzeExtents(IEnumerable<(ulong Start, ulong End)> extents)
{
var orderedExtents = extents.Where(static extent => extent.End >= extent.Start)
.OrderBy(static extent => extent.Start)
.ThenBy(static extent => extent.End)
.ToList();
List<(ulong Start, ulong End)> normalizedExtents = [];
if(orderedExtents.Count == 0) return normalizedExtents;
(ulong Start, ulong End) currentExtent = orderedExtents[0];
for(var i = 1; i < orderedExtents.Count; i++)
{
if(orderedExtents[i].Start <= currentExtent.End + 1)
{
currentExtent.End = Math.Max(currentExtent.End, orderedExtents[i].End);
continue;
}
normalizedExtents.Add(currentExtent);
currentExtent = orderedExtents[i];
}
normalizedExtents.Add(currentExtent);
return normalizedExtents;
}
}