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

Add ARJ and ARJZ archive support with entry handling and decompression features

Browse Source
This commit is contained in:
Natalia Portillo
2026-04-15 14:41:41 +01:00
parent ff732946c0
commit 485e80463f
12 changed files with 1217 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
Aaru.Archives/Arj/Arj.cs Normal file
View File

@@ -0,0 +1,35 @@
using System;
using System.IO;
using System.Text;
using Aaru.CommonTypes.Interfaces;
namespace Aaru.Archives;
public sealed partial class Arj : IArchive
{
const string MODULE_NAME = "ARJ Archive Plugin";
Encoding _encoding;
ArchiveSupportedFeature _features;
Stream _stream;
#region IArchive Members
/// <inheritdoc />
public string Name => Localization.ARJ_Name;
/// <inheritdoc />
public Guid Id => new("7B2F4E8C-3A1D-4F6E-9C5B-8D0E2A7F1B3C");
/// <inheritdoc />
public string Author => Authors.NataliaPortillo;
/// <inheritdoc />
public bool Opened { get; private set; }
/// <inheritdoc />
public ArchiveSupportedFeature ArchiveFeatures => !Opened
? ArchiveSupportedFeature.SupportsCompression |
ArchiveSupportedFeature.SupportsFilenames |
ArchiveSupportedFeature.HasEntryTimestamp
: _features;
/// <inheritdoc />
public int NumberOfEntries => Opened ? _entries.Count : -1;
#endregion
}

39
Aaru.Archives/Arj/Consts.cs Normal file
View File

@@ -0,0 +1,39 @@
namespace Aaru.Archives;
public sealed partial class Arj
{
/// <summary>ARJ archive header signature (little-endian: 0x60, 0xEA)</summary>
const ushort HEADER_ID = 0xEA60;
/// <summary>Maximum basic header size in bytes</summary>
const int HEADER_SIZE_MAX = 2600;
/// <summary>Standard first header size (30 bytes of fixed fields)</summary>
const int FIRST_HDR_SIZE = 30;
/// <summary>Extended first header size with protection fields (34 bytes)</summary>
const int FIRST_HDR_SIZE_V = 34;
/// <summary>Minimum size for headers with access/creation timestamps</summary>
const int R9_HDR_SIZE = 46;
/// <summary>CRC32 mask for finalization (XOR with this for standard CRC32)</summary>
const uint CRC_MASK = 0xFFFFFFFF;
/// <summary>CRC32 polynomial (reversed, same as standard CRC-32/ISO)</summary>
const uint CRC_POLY = 0xEDB88320;
/// <summary>Extended header tag for OS/2 extended attributes</summary>
const byte EA_TAG = (byte)'E';
/// <summary>Extended header tag for UNIX special files</summary>
const byte UXSPECIAL_TAG = (byte)'U';
/// <summary>Extended header tag for owner info (string)</summary>
const byte OWNER_TAG = (byte)'O';
/// <summary>Extended header tag for owner info (numeric)</summary>
const byte OWNER_NUM_TAG = (byte)'o';
/// <summary>ARJZ minimum version that uses extended DEFLATE (deflatez)</summary>
const byte ARJZ_DEFLATEZ_VERSION = 55;
/// <summary>ARJZ minimum version that uses ArjzStream method 1</summary>
const byte ARJZ_METHOD1_VERSION = 51;
/// <summary>ARJZ minimum version that uses ArjzStream method 2</summary>
const byte ARJZ_METHOD2_VERSION = 52;
/// <summary>ARJZ minimum version that uses ArjzStream method 3</summary>
const byte ARJZ_METHOD3_VERSION = 53;
/// <summary>Minimum number of bytes needed to attempt identification</summary>
const int MIN_HEADER_SIZE = 10;
/// <summary>OS/2 FEA flag: critical EA</summary>
const byte FEA_NEEDEA = 0x80;
}

74
Aaru.Archives/Arj/Enums.cs Normal file
View File

@@ -0,0 +1,74 @@
using System;
namespace Aaru.Archives;
public sealed partial class Arj
{
#region Method enum
enum Method : byte
{
/// <summary>Uncompressed (stored)</summary>
Stored = 0,
/// <summary>Compressed with method 1 (most compression, LZH)</summary>
Method1 = 1,
/// <summary>Compressed with method 2 (medium compression, LZH)</summary>
Method2 = 2,
/// <summary>Compressed with method 3 (fast compression, LZH)</summary>
Method3 = 3,
/// <summary>Compressed with method 4 (fastest, Golomb-Rice)</summary>
Fastest = 4
}
#endregion
#region HostOs enum
enum HostOs : byte
{
MsDos = 0,
Primos = 1,
Unix = 2,
Amiga = 3,
MacOs = 4,
Os2 = 5,
AppleGs = 6,
AtariSt = 7,
Next = 8,
Vax = 9,
Win95 = 10,
WinNt = 11
}
#endregion
#region FileType enum
enum FileType : byte
{
Binary = 0,
Text = 1,
Comment = 2,
Directory = 3,
VolumeLabel = 4,
Chapter = 5,
UnixSpecial = 6
}
#endregion
#region ArjFlags enum
[Flags]
enum ArjFlags : byte
{
None = 0x00,
Garbled = 0x01,
Volume = 0x04,
ExtFile = 0x08,
PathSym = 0x10,
Backup = 0x20
}
#endregion
}

214
Aaru.Archives/Arj/Files.cs Normal file
View File

@@ -0,0 +1,214 @@
using System;
using System.IO;
using Aaru.CommonTypes.Enums;
using Aaru.CommonTypes.Interfaces;
using Aaru.CommonTypes.Structs;
using Aaru.Compression;
using Aaru.Filters;
using Aaru.Helpers.IO;
using FileAttributes = Aaru.CommonTypes.Structs.FileAttributes;
namespace Aaru.Archives;
public sealed partial class Arj
{
#region IArchive Members
/// <inheritdoc />
public ErrorNumber GetFilename(int entryNumber, out string fileName)
{
fileName = null;
if(!Opened) return ErrorNumber.NotOpened;
if(entryNumber < 0 || entryNumber >= _entries.Count) return ErrorNumber.OutOfRange;
fileName = _entries[entryNumber].Filename ?? "";
return ErrorNumber.NoError;
}
/// <inheritdoc />
public ErrorNumber GetEntryNumber(string fileName, bool caseInsensitiveMatch, out int entryNumber)
{
entryNumber = -1;
if(!Opened) return ErrorNumber.NotOpened;
StringComparison comparison = caseInsensitiveMatch
? StringComparison.CurrentCultureIgnoreCase
: StringComparison.CurrentCulture;
for(int i = 0, count = _entries.Count; i < count; i++)
{
GetFilename(i, out string name);
if(name is null) continue;
if(!name.Equals(fileName, comparison)) continue;
entryNumber = i;
return ErrorNumber.NoError;
}
return ErrorNumber.NoSuchFile;
}
/// <inheritdoc />
public ErrorNumber GetCompressedSize(int entryNumber, out long length)
{
length = -1;
if(!Opened) return ErrorNumber.NotOpened;
if(entryNumber < 0 || entryNumber >= _entries.Count) return ErrorNumber.OutOfRange;
length = _entries[entryNumber].CompressedSize;
return ErrorNumber.NoError;
}
/// <inheritdoc />
public ErrorNumber GetUncompressedSize(int entryNumber, out long length)
{
length = -1;
if(!Opened) return ErrorNumber.NotOpened;
if(entryNumber < 0 || entryNumber >= _entries.Count) return ErrorNumber.OutOfRange;
length = _entries[entryNumber].UncompressedSize;
return ErrorNumber.NoError;
}
/// <inheritdoc />
public ErrorNumber Stat(int entryNumber, out FileEntryInfo stat)
{
stat = null;
if(!Opened) return ErrorNumber.NotOpened;
if(entryNumber < 0 || entryNumber >= _entries.Count) return ErrorNumber.OutOfRange;
Entry entry = _entries[entryNumber];
stat = new FileEntryInfo
{
Attributes = entry.IsDirectory ? FileAttributes.Directory : FileAttributes.File,
Blocks = entry.UncompressedSize / 512,
BlockSize = 512,
Length = entry.UncompressedSize,
LastWriteTime = entry.LastWriteTime,
LastWriteTimeUtc = entry.LastWriteTime.ToUniversalTime()
};
if(entry.UncompressedSize % 512 != 0) stat.Blocks++;
if(entry.CreationTime != default(DateTime))
{
stat.CreationTime = entry.CreationTime;
stat.CreationTimeUtc = entry.CreationTime.ToUniversalTime();
}
if(entry.LastAccessTime != default(DateTime))
{
stat.AccessTime = entry.LastAccessTime;
stat.AccessTimeUtc = entry.LastAccessTime.ToUniversalTime();
}
// Unix file permissions for Unix hosts
if(entry.HostOs is HostOs.Unix or HostOs.Next) stat.Mode = entry.FileMode;
return ErrorNumber.NoError;
}
/// <inheritdoc />
public ErrorNumber GetEntry(int entryNumber, out IFilter filter)
{
filter = null;
if(!Opened) return ErrorNumber.NotOpened;
if(entryNumber < 0 || entryNumber >= _entries.Count) return ErrorNumber.OutOfRange;
Entry entry = _entries[entryNumber];
if(entry.IsDirectory) return ErrorNumber.InvalidArgument;
// Encrypted files are not supported
if((entry.ArjFlags & (byte)ArjFlags.Garbled) != 0) return ErrorNumber.NotSupported;
Stream stream;
if(entry.UncompressedSize == 0)
stream = new MemoryStream([]);
else
{
stream = new OffsetStream(new NonClosableStream(_stream),
entry.DataOffset,
entry.DataOffset + entry.CompressedSize);
switch(entry.ArjxNbr)
{
// ARJZ dispatch based on arj_x_nbr
case ARJZ_METHOD1_VERSION:
stream = new ArjzStream(stream, entry.UncompressedSize, 1);
break;
case ARJZ_METHOD2_VERSION:
stream = new ArjzStream(stream, entry.UncompressedSize, 2);
break;
case ARJZ_METHOD3_VERSION:
stream = new ArjzStream(stream, entry.UncompressedSize, 3);
break;
case ARJZ_DEFLATEZ_VERSION:
stream = new ArjzStream(stream, entry.UncompressedSize, 5);
break;
default:
// Standard ARJ dispatch based on method
switch(entry.Method)
{
case Method.Stored:
// No decompression needed
break;
case Method.Method1:
stream = new ArjStream(stream, entry.UncompressedSize, 1);
break;
case Method.Method2:
stream = new ArjStream(stream, entry.UncompressedSize, 2);
break;
case Method.Method3:
stream = new ArjStream(stream, entry.UncompressedSize, 3);
break;
case Method.Fastest:
stream = new ArjStream(stream, entry.UncompressedSize, 4);
break;
default:
return ErrorNumber.NotSupported;
}
break;
}
}
filter = new ZZZNoFilter();
ErrorNumber errno = filter.Open(stream);
if(errno == ErrorNumber.NoError) return ErrorNumber.NoError;
stream.Close();
return errno;
}
#endregion
}

123
Aaru.Archives/Arj/Info.cs Normal file
View File

@@ -0,0 +1,123 @@
using System;
using System.IO;
using System.Text;
using Aaru.CommonTypes.Interfaces;
namespace Aaru.Archives;
public sealed partial class Arj
{
/// <summary>Precomputed CRC32 lookup table (polynomial 0xEDB88320).</summary>
static readonly uint[] _crcTable = BuildCrcTable();
static uint[] BuildCrcTable()
{
var table = new uint[256];
for(uint i = 0; i < 256; i++)
{
uint r = i;
for(var j = 0; j < 8; j++) r = (r & 1) != 0 ? r >> 1 ^ CRC_POLY : r >> 1;
table[i] = r;
}
return table;
}
/// <summary>Compute CRC32 over a byte span.</summary>
static uint ComputeCrc(uint crc, ReadOnlySpan<byte> data)
{
foreach(byte b in data) crc = _crcTable[(byte)(crc ^ b)] ^ crc >> 8;
return crc;
}
/// <summary>Convert MS-DOS FAT timestamp to DateTime.</summary>
static DateTime DosToDateTime(uint dosDateTime)
{
int second = (int)(dosDateTime & 0x1F) * 2;
var minute = (int)(dosDateTime >> 5 & 0x3F);
var hour = (int)(dosDateTime >> 11 & 0x1F);
var day = (int)(dosDateTime >> 16 & 0x1F);
var month = (int)(dosDateTime >> 21 & 0x0F);
int year = (int)(dosDateTime >> 25 & 0x7F) + 1980;
if(day < 1) day = 1;
if(month < 1) month = 1;
if(month > 12) month = 12;
int maxDay = DateTime.DaysInMonth(year, month);
if(day > maxDay) day = maxDay;
if(hour > 23) hour = 23;
if(minute > 59) minute = 59;
if(second > 59) second = 59;
return new DateTime(year, month, day, hour, minute, second);
}
/// <summary>Convert a Unix timestamp to DateTime.</summary>
static DateTime UnixToDateTime(uint unixTime) =>
unixTime == 0 ? default(DateTime) : DateTimeOffset.FromUnixTimeSeconds(unixTime).DateTime;
/// <summary>Convert a timestamp value to DateTime based on host OS.</summary>
static DateTime TimestampToDateTime(uint raw, HostOs hostOs) =>
hostOs is HostOs.Unix or HostOs.Next ? UnixToDateTime(raw) : DosToDateTime(raw);
#region IArchive Members
/// <inheritdoc />
public bool Identify(IFilter filter)
{
if(filter.DataForkLength < MIN_HEADER_SIZE) return false;
Stream stream = filter.GetDataForkStream();
stream.Position = 0;
var header = new byte[MIN_HEADER_SIZE];
stream.ReadExactly(header, 0, header.Length);
// Check header signature (little-endian: 0x60, 0xEA)
var headerSignature = BitConverter.ToUInt16(header, 0);
if(headerSignature != HEADER_ID) return false;
// Read basic header size
var basicHdrSize = BitConverter.ToUInt16(header, 2);
if(basicHdrSize is 0 or > HEADER_SIZE_MAX) return false;
// Read the full header for CRC validation
if(filter.DataForkLength < 4 + basicHdrSize + 4) return false;
stream.Position = 4;
var hdrData = new byte[basicHdrSize];
stream.ReadExactly(hdrData, 0, basicHdrSize);
var crcBytes = new byte[4];
stream.ReadExactly(crcBytes, 0, 4);
var storedCrc = BitConverter.ToUInt32(crcBytes, 0);
// Compute and verify CRC32
uint computedCrc = ComputeCrc(CRC_MASK, hdrData) ^ CRC_MASK;
return computedCrc == storedCrc;
}
/// <inheritdoc />
public void GetInformation(IFilter filter, Encoding encoding, out string information)
{
information = "";
if(!Identify(filter)) return;
var sb = new StringBuilder();
sb.AppendLine(Localization.ARJ_archive);
information = sb.ToString();
}
#endregion
}

405
Aaru.Archives/Arj/Open.cs Normal file
View File

@@ -0,0 +1,405 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Aaru.CommonTypes.Enums;
using Aaru.CommonTypes.Interfaces;
using Aaru.Compression;
using Aaru.Logging;
namespace Aaru.Archives;
public sealed partial class Arj
{
List<Entry> _entries;
/// <summary>
/// Reads an ARJ header block (signature + size + data + CRC + extended headers). Returns false if end of archive
/// or invalid header.
/// </summary>
bool ReadHeader(out byte[] headerData, out List<ExtHeaderBlock> extHeaders)
{
headerData = null;
extHeaders = null;
if(_stream.Position + 4 > _stream.Length) return false;
// Read 2-byte signature
var sigBytes = new byte[2];
_stream.ReadExactly(sigBytes, 0, 2);
var sig = BitConverter.ToUInt16(sigBytes, 0);
if(sig != HEADER_ID) return false;
// Read 2-byte basic header size
var sizeBytes = new byte[2];
_stream.ReadExactly(sizeBytes, 0, 2);
var basicHdrSize = BitConverter.ToUInt16(sizeBytes, 0);
// Size of 0 means end of archive
if(basicHdrSize == 0) return false;
if(basicHdrSize > HEADER_SIZE_MAX) return false;
// Read header data
if(_stream.Position + basicHdrSize + 4 > _stream.Length) return false;
headerData = new byte[basicHdrSize];
_stream.ReadExactly(headerData, 0, basicHdrSize);
// Read and verify CRC32
var crcBytes = new byte[4];
_stream.ReadExactly(crcBytes, 0, 4);
var storedCrc = BitConverter.ToUInt32(crcBytes, 0);
uint computedCrc = ComputeCrc(CRC_MASK, headerData) ^ CRC_MASK;
if(storedCrc != computedCrc)
{
AaruLogging.Debug(MODULE_NAME,
"[red]Header CRC mismatch: stored=0x{0:X8}, computed=0x{1:X8}[/]",
storedCrc,
computedCrc);
return false;
}
// Read extended headers
extHeaders = [];
while(_stream.Position + 2 <= _stream.Length)
{
var extSizeBytes = new byte[2];
_stream.ReadExactly(extSizeBytes, 0, 2);
var extSize = BitConverter.ToUInt16(extSizeBytes, 0);
if(extSize == 0) break;
if(_stream.Position + extSize + 4 > _stream.Length) break;
var extData = new byte[extSize];
_stream.ReadExactly(extData, 0, extSize);
// Read extended header CRC
var extCrcBytes = new byte[4];
_stream.ReadExactly(extCrcBytes, 0, 4);
var extStoredCrc = BitConverter.ToUInt32(extCrcBytes, 0);
uint extComputedCrc = ComputeCrc(CRC_MASK, extData) ^ CRC_MASK;
if(extStoredCrc != extComputedCrc)
{
AaruLogging.Debug(MODULE_NAME, "[red]Extended header CRC mismatch[/]");
continue;
}
// First byte is the tag, second byte is the continuation flag
if(extData.Length >= 2)
{
byte tag = extData[0];
byte continuation = extData[1];
var data = new byte[extData.Length - 2];
if(data.Length > 0) Array.Copy(extData, 2, data, 0, data.Length);
// Find existing block with same tag and append, or create new
var appended = false;
for(var i = 0; i < extHeaders.Count; i++)
{
if(extHeaders[i].Tag != tag) continue;
// Append data to existing block
var combined = new byte[extHeaders[i].Data.Length + data.Length];
Array.Copy(extHeaders[i].Data, 0, combined, 0, extHeaders[i].Data.Length);
Array.Copy(data, 0, combined, extHeaders[i].Data.Length, data.Length);
extHeaders[i] = new ExtHeaderBlock
{
Tag = tag,
Data = combined
};
appended = true;
break;
}
if(!appended)
extHeaders.Add(new ExtHeaderBlock
{
Tag = tag,
Data = data
});
}
}
return true;
}
/// <summary>Decompress an EA extended header block.</summary>
static byte[] DecompressEaBlock(byte[] rawEaData)
{
if(rawEaData is null || rawEaData.Length < 4) return null;
byte eaMethod = rawEaData[0];
int eaOrigLen = rawEaData[1] | rawEaData[2] << 8;
// Bytes 3-6 would be CRC, but we skip validation here
int compDataOffset = eaMethod == 0 ? 3 : 7;
if(compDataOffset > rawEaData.Length) return null;
int compDataLen = rawEaData.Length - compDataOffset;
if(eaMethod == 0)
{
// Stored EA data
var result = new byte[compDataLen];
Array.Copy(rawEaData, compDataOffset, result, 0, compDataLen);
return result;
}
if(eaMethod > 4 || eaOrigLen <= 0) return null;
try
{
var compStream = new MemoryStream(rawEaData, compDataOffset, compDataLen);
var arjStream = new ArjStream(compStream, eaOrigLen, eaMethod);
var decompressed = new byte[eaOrigLen];
var totalRead = 0;
while(totalRead < eaOrigLen)
{
int bytesRead = arjStream.Read(decompressed, totalRead, eaOrigLen - totalRead);
if(bytesRead <= 0) break;
totalRead += bytesRead;
}
return decompressed;
}
catch
{
return null;
}
}
/// <summary>Extract a null-terminated string from a byte array at the given offset.</summary>
static string ExtractNullTerminatedString(byte[] data, int offset, Encoding encoding)
{
if(offset >= data.Length) return "";
int end = Array.IndexOf(data, (byte)0, offset);
if(end < 0) end = data.Length;
int length = end - offset;
return length <= 0 ? "" : encoding.GetString(data, offset, length);
}
/// <summary>Get the length including the null terminator of a null-terminated string.</summary>
static int GetNullTerminatedLength(byte[] data, int offset)
{
if(offset >= data.Length) return 0;
int end = Array.IndexOf(data, (byte)0, offset);
if(end < 0) return data.Length - offset;
return end - offset;
}
/// <summary>Normalize path separators to forward slash.</summary>
static string NormalizePath(string path) => path?.Replace('\\', '/');
struct ExtHeaderBlock
{
public byte Tag;
public byte[] Data;
}
#region IArchive Members
/// <inheritdoc />
public ErrorNumber Open(IFilter filter, Encoding encoding)
{
if(filter.DataForkLength < MIN_HEADER_SIZE) return ErrorNumber.InvalidArgument;
_stream = filter.GetDataForkStream();
_stream.Position = 0;
_encoding = encoding ?? Encoding.GetEncoding(437);
_entries = [];
_features = ArchiveSupportedFeature.SupportsFilenames | ArchiveSupportedFeature.HasEntryTimestamp;
// Read and skip the main archive header
if(!ReadHeader(out _, out _))
{
AaruLogging.Debug(MODULE_NAME, "[red]Invalid main archive header[/]");
return ErrorNumber.InvalidArgument;
}
// Read file entry headers
while(_stream.Position < _stream.Length)
{
long entryStart = _stream.Position;
if(!ReadHeader(out byte[] headerData, out List<ExtHeaderBlock> extHeaders)) break;
if(headerData is null || headerData.Length < FIRST_HDR_SIZE) break;
// Parse fixed header fields
var pos = 0;
byte firstHdrSize = headerData[pos++];
byte arjNbr = headerData[pos++];
byte arjxNbr = headerData[pos++];
byte hostOs = headerData[pos++];
byte arjFlags = headerData[pos++];
byte method = headerData[pos++];
byte fileType = headerData[pos++];
byte pwdModifier = headerData[pos++];
var timestamp = BitConverter.ToUInt32(headerData, pos);
pos += 4;
var compSize = BitConverter.ToUInt32(headerData, pos);
pos += 4;
var origSize = BitConverter.ToUInt32(headerData, pos);
pos += 4;
var fileCrc = BitConverter.ToUInt32(headerData, pos);
pos += 4;
var entryPos = BitConverter.ToUInt16(headerData, pos);
pos += 2;
var fileMode = BitConverter.ToUInt16(headerData, pos);
pos += 2;
byte extFlags = 0;
byte chapterNumber = 0;
uint accessTime = 0;
uint creationTime = 0;
if(firstHdrSize >= FIRST_HDR_SIZE)
{
extFlags = headerData[pos++];
chapterNumber = headerData[pos++];
}
if(firstHdrSize >= FIRST_HDR_SIZE_V)
{
pos++; // prot_blocks
pos++; // arjprot_id
pos += 2; // reserved
}
if(firstHdrSize >= R9_HDR_SIZE)
{
pos += 4; // resume_position
accessTime = BitConverter.ToUInt32(headerData, pos);
pos += 4;
creationTime = BitConverter.ToUInt32(headerData, pos);
pos += 4;
pos += 4; // reserved
}
// Extract filename (null-terminated at offset firstHdrSize)
string filename = ExtractNullTerminatedString(headerData, firstHdrSize, _encoding);
// Extract comment (null-terminated after filename)
int commentOffset = firstHdrSize + GetNullTerminatedLength(headerData, firstHdrSize) + 1;
string comment = null;
if(commentOffset < headerData.Length)
{
string commentStr = ExtractNullTerminatedString(headerData, commentOffset, _encoding);
if(!string.IsNullOrEmpty(commentStr)) comment = commentStr;
}
AaruLogging.Debug(MODULE_NAME, "[navy]filename[/] = [green]\"{0}\"[/]", filename);
AaruLogging.Debug(MODULE_NAME, "[navy]method[/] = [teal]{0}[/]", method);
AaruLogging.Debug(MODULE_NAME, "[navy]compSize[/] = [teal]{0}[/]", compSize);
AaruLogging.Debug(MODULE_NAME, "[navy]origSize[/] = [teal]{0}[/]", origSize);
AaruLogging.Debug(MODULE_NAME, "[navy]hostOs[/] = [teal]{0}[/]", (HostOs)hostOs);
AaruLogging.Debug(MODULE_NAME, "[navy]fileType[/] = [teal]{0}[/]", (FileType)fileType);
AaruLogging.Debug(MODULE_NAME, "[navy]arjFlags[/] = [teal]0x{0:X2}[/]", arjFlags);
AaruLogging.Debug(MODULE_NAME, "[navy]arjxNbr[/] = [teal]{0}[/]", arjxNbr);
// Process extended attributes from extended headers
byte[] eaData = null;
if(extHeaders is { Count: > 0 })
{
foreach(ExtHeaderBlock eh in extHeaders)
{
if(eh.Tag != EA_TAG || eh.Data is null || eh.Data.Length < 4) continue;
eaData = DecompressEaBlock(eh.Data);
}
}
HostOs parsedHostOs = hostOs <= 11 ? (HostOs)hostOs : HostOs.MsDos;
var entry = new Entry
{
Method = method <= 4 ? (Method)method : Method.Stored,
Filename = NormalizePath(filename),
CompressedSize = compSize,
UncompressedSize = origSize,
DataOffset = _stream.Position,
LastWriteTime = TimestampToDateTime(timestamp, parsedHostOs),
HostOs = parsedHostOs,
FileCrc = fileCrc,
FileMode = fileMode,
ArjFlags = arjFlags,
ArjxNbr = arjxNbr,
Comment = comment,
ExtendedAttributes = eaData,
IsDirectory = (FileType)fileType == FileType.Directory
};
if(accessTime != 0) entry.LastAccessTime = TimestampToDateTime(accessTime, parsedHostOs);
if(creationTime != 0) entry.CreationTime = TimestampToDateTime(creationTime, parsedHostOs);
// Update features
if(entry.Method != Method.Stored && entry.CompressedSize > 0)
_features |= ArchiveSupportedFeature.SupportsCompression;
if(entry.IsDirectory)
{
_features |= ArchiveSupportedFeature.HasExplicitDirectories |
ArchiveSupportedFeature.SupportsSubdirectories;
}
if(entry.Comment is not null || entry.ExtendedAttributes is not null)
_features |= ArchiveSupportedFeature.SupportsXAttrs;
if(entry.Filename.Contains('/')) _features |= ArchiveSupportedFeature.SupportsSubdirectories;
_entries.Add(entry);
// Skip past compressed data
_stream.Position = entry.DataOffset + entry.CompressedSize;
}
Opened = true;
return ErrorNumber.NoError;
}
/// <inheritdoc />
public void Close()
{
if(!Opened) return;
_stream?.Close();
_entries?.Clear();
_stream = null;
Opened = false;
}
#endregion
}

30
Aaru.Archives/Arj/Structs.cs Normal file
View File

@@ -0,0 +1,30 @@
using System;
namespace Aaru.Archives;
public sealed partial class Arj
{
#region Nested type: Entry
struct Entry
{
public Method Method;
public string Filename;
public long CompressedSize;
public long UncompressedSize;
public long DataOffset;
public DateTime LastWriteTime;
public DateTime CreationTime;
public DateTime LastAccessTime;
public HostOs HostOs;
public uint FileCrc;
public ushort FileMode;
public byte ArjFlags;
public byte ArjxNbr;
public string Comment;
public byte[] ExtendedAttributes;
public bool IsDirectory;
}
#endregion
}

142
Aaru.Archives/Arj/Xattrs.cs Normal file
View File

@@ -0,0 +1,142 @@
using System;
using System.Collections.Generic;
using System.Text;
using Aaru.CommonTypes.Enums;
namespace Aaru.Archives;
public sealed partial class Arj
{
/// <summary>
/// Parse OS/2 FEA records from a decompressed EA block and return the EA names. Block format: count(2 LE) +
/// records of fEA(1) + nameLen(1) + valueLen(2 LE) + name(nameLen) + value(valueLen).
/// </summary>
static List<string> ParseEaNames(byte[] eaBlock)
{
var names = new List<string>();
if(eaBlock is null || eaBlock.Length < 2) return names;
var offset = 0;
var count = BitConverter.ToUInt16(eaBlock, offset);
offset += 2;
for(var i = 0; i < count && offset + 4 <= eaBlock.Length; i++)
{
byte fEa = eaBlock[offset++];
byte nameLen = eaBlock[offset++];
var valLen = BitConverter.ToUInt16(eaBlock, offset);
offset += 2;
if(offset + nameLen + valLen > eaBlock.Length) break;
string name = Encoding.ASCII.GetString(eaBlock, offset, nameLen);
offset += nameLen;
offset += valLen;
if(!string.IsNullOrEmpty(name)) names.Add(name);
}
return names;
}
/// <summary>Find an OS/2 FEA record by name and return its raw value bytes.</summary>
static byte[] FindEaValue(byte[] eaBlock, string eaName)
{
if(eaBlock is null || eaBlock.Length < 2) return null;
var offset = 0;
var count = BitConverter.ToUInt16(eaBlock, offset);
offset += 2;
for(var i = 0; i < count && offset + 4 <= eaBlock.Length; i++)
{
byte fEa = eaBlock[offset++];
byte nameLen = eaBlock[offset++];
var valLen = BitConverter.ToUInt16(eaBlock, offset);
offset += 2;
if(offset + nameLen + valLen > eaBlock.Length) return null;
string name = Encoding.ASCII.GetString(eaBlock, offset, nameLen);
offset += nameLen;
if(name == eaName)
{
var value = new byte[valLen];
Array.Copy(eaBlock, offset, value, 0, valLen);
return value;
}
offset += valLen;
}
return null;
}
#region IArchive Members
/// <inheritdoc />
public ErrorNumber ListXAttr(int entryNumber, out List<string> xattrs)
{
xattrs = null;
if(!Opened) return ErrorNumber.NotOpened;
if(entryNumber < 0 || entryNumber >= _entries.Count) return ErrorNumber.OutOfRange;
xattrs = [];
Entry entry = _entries[entryNumber];
if(entry.Comment is not null) xattrs.Add("comment");
// Parse OS/2 extended attribute names from the decompressed EA block
if(entry.ExtendedAttributes is { Length: >= 2 })
{
List<string> eaNames = ParseEaNames(entry.ExtendedAttributes);
xattrs.AddRange(eaNames);
}
return ErrorNumber.NoError;
}
/// <inheritdoc />
public ErrorNumber GetXattr(int entryNumber, string xattr, ref byte[] buffer)
{
buffer = null;
if(!Opened) return ErrorNumber.NotOpened;
if(entryNumber < 0 || entryNumber >= _entries.Count) return ErrorNumber.OutOfRange;
Entry entry = _entries[entryNumber];
if(xattr == "comment")
{
if(entry.Comment is null) return ErrorNumber.NoSuchExtendedAttribute;
buffer = Encoding.UTF8.GetBytes(entry.Comment);
return ErrorNumber.NoError;
}
// Look up OS/2 extended attribute by name
if(entry.ExtendedAttributes is { Length: >= 2 })
{
byte[] value = FindEaValue(entry.ExtendedAttributes, xattr);
if(value is not null)
{
buffer = value;
return ErrorNumber.NoError;
}
}
return ErrorNumber.NoSuchExtendedAttribute;
}
#endregion
}

270
Aaru.Archives/Localization/Localization.Designer.cs generated
View File

@@ -9,21 +9,21 @@
namespace Aaru.Archives {
using System;
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[System.Diagnostics.DebuggerNonUserCodeAttribute()]
[System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Localization {
private static System.Resources.ResourceManager resourceMan;
private static System.Globalization.CultureInfo resourceCulture;
[System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Localization() {
}
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
internal static System.Resources.ResourceManager ResourceManager {
get {
@@ -34,7 +34,7 @@ namespace Aaru.Archives {
return resourceMan;
}
}
[System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
internal static System.Globalization.CultureInfo Culture {
get {
@@ -44,737 +44,749 @@ namespace Aaru.Archives {
resourceCulture = value;
}
}
internal static string Symbian_Name {
get {
return ResourceManager.GetString("Symbian_Name", resourceCulture);
}
}
internal static string Symbian_Installation_File {
get {
return ResourceManager.GetString("Symbian_Installation_File", resourceCulture);
}
}
internal static string Symbian_9_1_or_later {
get {
return ResourceManager.GetString("Symbian_9_1_or_later", resourceCulture);
}
}
internal static string Application_ID_0 {
get {
return ResourceManager.GetString("Application_ID_0", resourceCulture);
}
}
internal static string UIDs_checksum_0 {
get {
return ResourceManager.GetString("UIDs_checksum_0", resourceCulture);
}
}
internal static string Symbian_3_or_later {
get {
return ResourceManager.GetString("Symbian_3_or_later", resourceCulture);
}
}
internal static string Symbian_6_or_later {
get {
return ResourceManager.GetString("Symbian_6_or_later", resourceCulture);
}
}
internal static string Unknown_EPOC_magic_0 {
get {
return ResourceManager.GetString("Unknown_EPOC_magic_0", resourceCulture);
}
}
internal static string CRC16_of_header_0 {
get {
return ResourceManager.GetString("CRC16_of_header_0", resourceCulture);
}
}
internal static string SIS_contains_an_application {
get {
return ResourceManager.GetString("SIS_contains_an_application", resourceCulture);
}
}
internal static string File_contains_0_languages {
get {
return ResourceManager.GetString("File_contains_0_languages", resourceCulture);
}
}
internal static string File_contains_0_files_pointer_1 {
get {
return ResourceManager.GetString("File_contains_0_files_pointer_1", resourceCulture);
}
}
internal static string File_contains_0_requisites {
get {
return ResourceManager.GetString("File_contains_0_requisites", resourceCulture);
}
}
internal static string Capabilities {
get {
return ResourceManager.GetString("Capabilities", resourceCulture);
}
}
internal static string Component_version_0_1 {
get {
return ResourceManager.GetString("Component_version_0_1", resourceCulture);
}
}
internal static string Component_name_for_language_with_code_0_1 {
get {
return ResourceManager.GetString("Component_name_for_language_with_code_0_1", resourceCulture);
}
}
internal static string Files_for_all_languages {
get {
return ResourceManager.GetString("Files_for_all_languages", resourceCulture);
}
}
internal static string Files_for_0_language {
get {
return ResourceManager.GetString("Files_for_0_language", resourceCulture);
}
}
internal static string Requisite_0 {
get {
return ResourceManager.GetString("Requisite_0", resourceCulture);
}
}
internal static string Required_UID_0_version_1_2 {
get {
return ResourceManager.GetString("Required_UID_0_version_1_2", resourceCulture);
}
}
internal static string Required_variant_0 {
get {
return ResourceManager.GetString("Required_variant_0", resourceCulture);
}
}
internal static string Requisite_for_language_0_1 {
get {
return ResourceManager.GetString("Requisite_for_language_0_1", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_1st_Edition {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_1st_Edition", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_1st_Edition_Feature_Pack_1 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_1st_Edition_Feature_Pack_1", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_2nd_Edition {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_2nd_Edition", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_2nd_Edition_Feature_Pack_1 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_2nd_Edition_Feature_Pack_1", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_2nd_Edition_Feature_Pack_2 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_2nd_Edition_Feature_Pack_2", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_2nd_Edition_Feature_Pack_3 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_2nd_Edition_Feature_Pack_3", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_3rd_Edition {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_3rd_Edition", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_3rd_Edition_Feature_Pack_1 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_3rd_Edition_Feature_Pack_1", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_3rd_Edition_Feature_Pack_2 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_3rd_Edition_Feature_Pack_2", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_5th_Edition {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_5th_Edition", resourceCulture);
}
}
internal static string SIS_Platform_UID_Symbian_3 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Symbian_3", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_Belle {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_Belle", resourceCulture);
}
}
internal static string SIS_Platform_UID_0 {
get {
return ResourceManager.GetString("SIS_Platform_UID_0", resourceCulture);
}
}
internal static string Archive_options_0 {
get {
return ResourceManager.GetString("Archive_options_0", resourceCulture);
}
}
internal static string SIS_Platform_UID_UIQ_21 {
get {
return ResourceManager.GetString("SIS_Platform_UID_UIQ_21", resourceCulture);
}
}
internal static string SIS_Platform_UID_UIQ_30 {
get {
return ResourceManager.GetString("SIS_Platform_UID_UIQ_30", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_7650 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_7650", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_v1_0 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_v1_0", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_3650 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_3650", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_6600 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_6600", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_6630 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_6630", resourceCulture);
}
}
internal static string SIS_Platform_UID_SonyEricsson_P80x {
get {
return ResourceManager.GetString("SIS_Platform_UID_SonyEricsson_P80x", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_60_v1_1 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_60_v1_1", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_N_Gage {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_N_Gage", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_9500 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_9500", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_9300 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_9300", resourceCulture);
}
}
internal static string SIS_Platform_UID_Series_80_2nd_edition {
get {
return ResourceManager.GetString("SIS_Platform_UID_Series_80_2nd_edition", resourceCulture);
}
}
internal static string SIS_Platform_UID_Siemens_SX1 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Siemens_SX1", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_6260 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_6260", resourceCulture);
}
}
internal static string SIS_Platform_UID_SonyEricsson_P90x {
get {
return ResourceManager.GetString("SIS_Platform_UID_SonyEricsson_P90x", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_7710_Series_90 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_7710_Series_90", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_7610 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_7610", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_6670 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_6670", resourceCulture);
}
}
internal static string SIS_Platform_UID_UIQ_20 {
get {
return ResourceManager.GetString("SIS_Platform_UID_UIQ_20", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_3230 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_3230", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_N90 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_N90", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_N70 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_N70", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_6680 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_6680", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_6620 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_6620", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_6682 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_6682", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_6681 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_6681", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_3250 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_3250", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_N80 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_N80", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_N92 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_N92", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_N73 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_N73", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_N91 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_N91", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_N71 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_N71", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_E60 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_E60", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_E70 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_E70", resourceCulture);
}
}
internal static string SIS_Platform_UID_Nokia_E61 {
get {
return ResourceManager.GetString("SIS_Platform_UID_Nokia_E61", resourceCulture);
}
}
internal static string Option_0 {
get {
return ResourceManager.GetString("Option_0", resourceCulture);
}
}
internal static string Name_for_language_0_1 {
get {
return ResourceManager.GetString("Name_for_language_0_1", resourceCulture);
}
}
internal static string This_file_format_is_not_yet_implemented {
get {
return ResourceManager.GetString("This_file_format_is_not_yet_implemented", resourceCulture);
}
}
internal static string Found_component_name_for_language_0_at_1_with_a_length_of_2_bytes {
get {
return ResourceManager.GetString("Found_component_name_for_language_0_at_1_with_a_length_of_2_bytes", resourceCulture);
}
}
internal static string Conditions {
get {
return ResourceManager.GetString("Conditions", resourceCulture);
}
}
internal static string Console_package {
get {
return ResourceManager.GetString("Console_package", resourceCulture);
}
}
internal static string Live_package {
get {
return ResourceManager.GetString("Live_package", resourceCulture);
}
}
internal static string Microsoft_package {
get {
return ResourceManager.GetString("Microsoft_package", resourceCulture);
}
}
internal static string Certificate_owner_console_ID_0_1_2_3_4 {
get {
return ResourceManager.GetString("Certificate_owner_console_ID_0_1_2_3_4", resourceCulture);
}
}
internal static string Certificate_owner_console_part_number_0 {
get {
return ResourceManager.GetString("Certificate_owner_console_part_number_0", resourceCulture);
}
}
internal static string Certificate_owner_console_type_0 {
get {
return ResourceManager.GetString("Certificate_owner_console_type_0", resourceCulture);
}
}
internal static string Certificate_date_of_generation_0 {
get {
return ResourceManager.GetString("Certificate_date_of_generation_0", resourceCulture);
}
}
internal static string Signatures_SHA1_0 {
get {
return ResourceManager.GetString("Signatures_SHA1_0", resourceCulture);
}
}
internal static string Header_size_0 {
get {
return ResourceManager.GetString("Header_size_0", resourceCulture);
}
}
internal static string Content_type_0 {
get {
return ResourceManager.GetString("Content_type_0", resourceCulture);
}
}
internal static string Content_size_0 {
get {
return ResourceManager.GetString("Content_size_0", resourceCulture);
}
}
internal static string Title_ID_0 {
get {
return ResourceManager.GetString("Title_ID_0", resourceCulture);
}
}
internal static string Media_ID_0 {
get {
return ResourceManager.GetString("Media_ID_0", resourceCulture);
}
}
internal static string Publisher_name_0 {
get {
return ResourceManager.GetString("Publisher_name_0", resourceCulture);
}
}
internal static string Title_name_0 {
get {
return ResourceManager.GetString("Title_name_0", resourceCulture);
}
}
internal static string Metadata_version_0 {
get {
return ResourceManager.GetString("Metadata_version_0", resourceCulture);
}
}
internal static string Version_0 {
get {
return ResourceManager.GetString("Version_0", resourceCulture);
}
}
internal static string Base_version_0 {
get {
return ResourceManager.GetString("Base_version_0", resourceCulture);
}
}
internal static string Descriptor_type_0 {
get {
return ResourceManager.GetString("Descriptor_type_0", resourceCulture);
}
}
internal static string Display_name_0 {
get {
return ResourceManager.GetString("Display_name_0", resourceCulture);
}
}
internal static string Display_description_0 {
get {
return ResourceManager.GetString("Display_description_0", resourceCulture);
}
}
internal static string Device_ID_0 {
get {
return ResourceManager.GetString("Device_ID_0", resourceCulture);
}
}
internal static string Console_ID_0 {
get {
return ResourceManager.GetString("Console_ID_0", resourceCulture);
}
}
internal static string Profile_ID_0 {
get {
return ResourceManager.GetString("Profile_ID_0", resourceCulture);
}
}
internal static string ARC_archive {
get {
return ResourceManager.GetString("ARC_archive", resourceCulture);
}
}
internal static string LHA_archive {
get {
return ResourceManager.GetString("LHA_archive", resourceCulture);
}
}
internal static string AMG_archive {
get {
return ResourceManager.GetString("AMG_archive", resourceCulture);
}
}
internal static string AMG_version_0_1 {
get {
return ResourceManager.GetString("AMG_version_0_1", resourceCulture);
}
}
internal static string Archive_contains_0_files_for_1_bytes {
get {
return ResourceManager.GetString("Archive_contains_0_files_for_1_bytes", resourceCulture);
}
}
internal static string Archive_comment {
get {
return ResourceManager.GetString("Archive_comment", resourceCulture);
}
}
internal static string HA_archive {
get {
return ResourceManager.GetString("HA_archive", resourceCulture);
}
}
internal static string Created_with_HA_version_0 {
get {
return ResourceManager.GetString("Created_with_HA_version_0", resourceCulture);
}
}
internal static string Archive_contains_0_files {
get {
return ResourceManager.GetString("Archive_contains_0_files", resourceCulture);
}
}
internal static string EwfArchive_Name {
get {
return ResourceManager.GetString("EwfArchive_Name", resourceCulture);
}
}
internal static string Ace_Name {
get {
return ResourceManager.GetString("Ace_Name", resourceCulture);
}
}
internal static string ACE_archive {
get {
return ResourceManager.GetString("ACE_archive", resourceCulture);
}
}
internal static string ACE_version_created_0_1 {
get {
return ResourceManager.GetString("ACE_version_created_0_1", resourceCulture);
}
}
internal static string ACE_version_needed_0_1 {
get {
return ResourceManager.GetString("ACE_version_needed_0_1", resourceCulture);
}
}
internal static string ACE_host_os_0 {
get {
return ResourceManager.GetString("ACE_host_os_0", resourceCulture);
}
}
internal static string ACE_solid_archive {
get {
return ResourceManager.GetString("ACE_solid_archive", resourceCulture);
}
}
internal static string ACE_multi_volume_archive {
get {
return ResourceManager.GetString("ACE_multi_volume_archive", resourceCulture);
}
}
internal static string ACE_locked_archive {
get {
return ResourceManager.GetString("ACE_locked_archive", resourceCulture);
}
}
internal static string ACE_sfx_archive {
get {
return ResourceManager.GetString("ACE_sfx_archive", resourceCulture);
}
}
internal static string ACE_has_recovery_record {
get {
return ResourceManager.GetString("ACE_has_recovery_record", resourceCulture);
}
}
internal static string ACE_volume_number_0 {
get {
return ResourceManager.GetString("ACE_volume_number_0", resourceCulture);
}
}
internal static string ARJ_archive {
get {
return ResourceManager.GetString("ARJ_archive", resourceCulture);
}
}
internal static string ARJ_Name {
get {
return ResourceManager.GetString("ARJ_Name", resourceCulture);
}
}
}
}

6
Aaru.Archives/Localization/Localization.es.resx
View File

@@ -381,4 +381,10 @@
<data name="ACE_volume_number_0" xml:space="preserve">
<value>[slateblue1]Número de volumen: [green]{0}[/][/]</value>
</data>
<data name="ARJ_archive" xml:space="preserve">
<value>[bold][blue]Archivo ARJ[/][/]</value>
</data>
<data name="ARJ_Name" xml:space="preserve">
<value>ARJ</value>
</data>
</root>

6
Aaru.Archives/Localization/Localization.resx
View File

@@ -389,4 +389,10 @@
<data name="ACE_volume_number_0" xml:space="preserve">
<value>[slateblue1]Volume number: [green]{0}[/][/]</value>
</data>
<data name="ARJ_archive" xml:space="preserve">
<value>[bold][blue]ARJ archive[/][/]</value>
</data>
<data name="ARJ_Name" xml:space="preserve">
<value>ARJ</value>
</data>
</root>

2
README.md
View File

@@ -161,6 +161,8 @@ Supported archives
* ACE (.ACE)
* ARC (.ARC)
* ARJ (.ARJ)
* ARJZ (.ARZ)
* Expert Witness Format (EWF)
* HA (.HA)
* LARC (.LZS)