public void GNUAsFile()
{
List<ITarHeader> list = new List<ITarHeader>();
var gnuFile = WriteToTempFile(gnuStream);
TarReader reader = new TarReader(gnuFile);
while (reader.MoveNext(true))
{
list.Add(reader.FileInfo);
Trace.WriteLine($"{reader.FileInfo.EntryType}: {reader.FileInfo.FileName}");
}
Assert.IsNotNull(list.FirstOrDefault(x => x.FileName == "hello/"));
Assert.IsNotNull(list.FirstOrDefault(x => x.FileName == "hello/world/"));
Assert.IsNotNull(list.FirstOrDefault(x => x.FileName == "hello/world/hello"));
}
public void Add_Empty_GlobalExtendedAttributes()
{
using MemoryStream archive = new MemoryStream();
using (TarWriter writer = new TarWriter(archive, leaveOpen: true))
{
PaxGlobalExtendedAttributesTarEntry gea = new PaxGlobalExtendedAttributesTarEntry(new Dictionary <string, string>());
writer.WriteEntry(gea);
}
archive.Seek(0, SeekOrigin.Begin);
using (TarReader reader = new TarReader(archive))
{
PaxGlobalExtendedAttributesTarEntry gea = reader.GetNextEntry() as PaxGlobalExtendedAttributesTarEntry;
Assert.NotNull(gea);
Assert.Equal(TarEntryFormat.Pax, gea.Format);
Assert.Equal(TarEntryType.GlobalExtendedAttributes, gea.EntryType);
Assert.Equal(0, gea.GlobalExtendedAttributes.Count);
Assert.Null(reader.GetNextEntry());
}
}
protected void Read_Archive_Folder_File_Utf8_Internal(TarEntryFormat format, TestTarFormat testFormat)
{
string testCaseName = "folder_file_utf8";
using MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName);
using TarReader reader = new TarReader(ms);
if (testFormat is TestTarFormat.pax_gea)
{
VerifyGlobalExtendedAttributes(reader);
}
TarEntry directory = reader.GetNextEntry();
VerifyDirectoryEntry(directory, format, "f\u00f6ld\u00ebr/"); //földër
TarEntry file = reader.GetNextEntry();
VerifyRegularFileEntry(file, format, "f\u00f6ld\u00ebr/\u00e1\u00f6\u00f1.txt", $"Hello {testCaseName}"); // földër/áöñ.txt
Assert.Null(reader.GetNextEntry());
}
public void Add_Directory(TarEntryFormat format, bool withContents)
{
using TempDirectory root = new TempDirectory();
string dirName = "dir";
string dirPath = Path.Join(root.Path, dirName);
Directory.CreateDirectory(dirPath);
if (withContents)
{
// Add a file inside the directory, we need to ensure the contents
// of the directory are ignored when using AddFile
File.Create(Path.Join(dirPath, "file.txt")).Dispose();
}
using MemoryStream archive = new MemoryStream();
using (TarWriter writer = new TarWriter(archive, format, leaveOpen: true))
{
writer.WriteEntry(fileName: dirPath, entryName: dirName);
}
archive.Seek(0, SeekOrigin.Begin);
using (TarReader reader = new TarReader(archive))
{
TarEntry entry = reader.GetNextEntry();
Assert.Equal(format, entry.Format);
Assert.NotNull(entry);
Assert.Equal(dirName, entry.Name);
Assert.Equal(TarEntryType.Directory, entry.EntryType);
Assert.Null(entry.DataStream);
VerifyPlatformSpecificMetadata(dirPath, entry);
Assert.Null(reader.GetNextEntry()); // If the dir had contents, they should've been excluded
}
}
public void BlockAlignmentPadding_DoesNotAffectNextEntries(int contentSize, bool copyData)
{
byte[] fileContents = new byte[contentSize];
Array.Fill <byte>(fileContents, 0x1);
using var archive = new MemoryStream();
using (var writer = new TarWriter(archive, leaveOpen: true))
{
var entry1 = new PaxTarEntry(TarEntryType.RegularFile, "file");
entry1.DataStream = new MemoryStream(fileContents);
writer.WriteEntry(entry1);
var entry2 = new PaxTarEntry(TarEntryType.RegularFile, "next-file");
writer.WriteEntry(entry2);
}
archive.Position = 0;
using var unseekable = new WrappedStream(archive, archive.CanRead, archive.CanWrite, canSeek: false);
using var reader = new TarReader(unseekable);
TarEntry e = reader.GetNextEntry(copyData);
Assert.Equal(contentSize, e.Length);
byte[] buffer = new byte[contentSize];
while (e.DataStream.Read(buffer) > 0)
{
;
}
AssertExtensions.SequenceEqual(fileContents, buffer);
e = reader.GetNextEntry(copyData);
Assert.Equal(0, e.Length);
e = reader.GetNextEntry(copyData);
Assert.Null(e);
}
protected async Task Read_Archive_File_LongSymbolicLink_Async_Internal(TarEntryFormat format, TestTarFormat testFormat)
{
string testCaseName = "file_longsymlink";
await using (MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName))
{
await using (TarReader reader = new TarReader(ms))
{
if (testFormat is TestTarFormat.pax_gea)
{
TarEntry entry = await reader.GetNextEntryAsync();
VerifyGlobalExtendedAttributes(entry);
}
TarEntry directory = await reader.GetNextEntryAsync();
VerifyDirectoryEntry(directory, format,
"000000000011111111112222222222333333333344444444445555555555666666666677777777778888888888999999999900000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555/");
TarEntry file = await reader.GetNextEntryAsync();
VerifyRegularFileEntry(file, format,
"000000000011111111112222222222333333333344444444445555555555666666666677777777778888888888999999999900000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555/00000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999000000000011111111112222222222333333333344444444445.txt",
$"Hello {testCaseName}");
TarEntry symbolicLink = await reader.GetNextEntryAsync();
VerifySymbolicLinkEntry(symbolicLink, format,
"link.txt",
"000000000011111111112222222222333333333344444444445555555555666666666677777777778888888888999999999900000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555/00000000001111111111222222222233333333334444444444555555555566666666667777777777888888888899999999990000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999000000000011111111112222222222333333333344444444445.txt");
Assert.Null(await reader.GetNextEntryAsync());
}
}
}
protected void Read_Archive_File_HardLink_Internal(TarEntryFormat format, TestTarFormat testFormat)
{
string testCaseName = "file_hardlink";
using MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName);
using TarReader reader = new TarReader(ms);
if (testFormat is TestTarFormat.pax_gea)
{
VerifyGlobalExtendedAttributes(reader);
}
TarEntry file = reader.GetNextEntry();
VerifyRegularFileEntry(file, format, "file.txt", $"Hello {testCaseName}");
TarEntry hardLink = reader.GetNextEntry();
// The 'tar' tool detects hardlinks as regular files and saves them as such in the archives, for all formats
VerifyRegularFileEntry(hardLink, format, "hardlink.txt", $"Hello {testCaseName}");
Assert.Null(reader.GetNextEntry());
}
public async Task ExtractEntriesWithSlashDotPrefix_Async()
{
using (TempDirectory root = new TempDirectory())
await using (MemoryStream archiveStream = GetStrangeTarMemoryStream("prefixDotSlashAndCurrentFolderEntry"))
await using (TarReader reader = new TarReader(archiveStream, leaveOpen: false))
{
string rootPath = Path.TrimEndingDirectorySeparator(root.Path);
TarEntry entry;
while ((entry = await reader.GetNextEntryAsync()) != null)
{
Assert.NotNull(entry);
Assert.StartsWith("./", entry.Name);
// Normalize the path (remove redundant segments), remove trailing separators
// this is so the first entry can be skipped if it's the same as the root directory
string entryPath = Path.TrimEndingDirectorySeparator(Path.GetFullPath(Path.Join(rootPath, entry.Name)));
if (entryPath != rootPath)
{
await entry.ExtractToFileAsync(entryPath, overwrite : true);
Assert.True(Path.Exists(entryPath), $"Entry was not extracted: {entryPath}");
}
}
}
}
public static IReader Open(Stream stream, Options options = 1)
{
stream.CheckNotNull("stream");
RewindableStream stream2 = new RewindableStream(stream);
stream2.StartRecording();
stream2.Rewind(false);
if (BZip2Stream.IsBZip2(stream2))
{
stream2.Rewind(false);
if (TarArchive.IsTarFile(new BZip2Stream(stream2, CompressionMode.Decompress, false, false)))
{
stream2.Rewind(true);
return(new TarReader(stream2, CompressionType.BZip2, options));
}
}
stream2.Rewind(false);
if (!TarArchive.IsTarFile(stream2))
{
throw new InvalidOperationException("Cannot determine compressed stream type.");
}
stream2.Rewind(true);
return(TarReader.Open(stream2, options));
}
public async Task WritePaxAttributes_Timestamps_AutomaticallyAdded_Async()
{
DateTimeOffset minimumTime = DateTimeOffset.UtcNow - TimeSpan.FromHours(1);
await using (MemoryStream archiveStream = new MemoryStream())
{
await using (TarWriter writer = new TarWriter(archiveStream, TarEntryFormat.Pax, leaveOpen: true))
{
PaxTarEntry regularFile = new PaxTarEntry(TarEntryType.RegularFile, InitialEntryName);
await writer.WriteEntryAsync(regularFile);
}
archiveStream.Position = 0;
await using (TarReader reader = new TarReader(archiveStream))
{
PaxTarEntry regularFile = await reader.GetNextEntryAsync() as PaxTarEntry;
AssertExtensions.GreaterThanOrEqualTo(regularFile.ExtendedAttributes.Count, 4);
VerifyExtendedAttributeTimestamp(regularFile, PaxEaMTime, minimumTime);
VerifyExtendedAttributeTimestamp(regularFile, PaxEaATime, minimumTime);
VerifyExtendedAttributeTimestamp(regularFile, PaxEaCTime, minimumTime);
}
}
}
public async Task Create_Works_Async()
{
var disk = new DeveloperDisk()
{
Image = new MemoryStream(Encoding.UTF8.GetBytes("Hello, world!")),
Signature = new byte[] { 1, 2, 3, 4 },
Version = new SystemVersion()
{
BuildID = new Guid("5abf1921-e3e3-4bfc-94c5-6c6805f23815"),
ProductBuildVersion = new AppleVersion(1, 'A', 1),
ProductCopyright = "Quamotion bv",
ProductName = "Kaponata",
ProductVersion = new Version(1, 0),
},
CreationTime = new DateTimeOffset(2000, 1, 1, 0, 0, 0, 0, TimeSpan.Zero),
};
var factory = new DeveloperDiskRegistryImageFactory();
(var manifest, var configStream, var layerStream) = await factory.CreateRegistryImageAsync(disk, default).ConfigureAwait(false);
Assert.NotNull(manifest);
Assert.NotNull(configStream);
Assert.Equal(0, configStream.Position);
Assert.NotEqual(0, configStream.Length);
Assert.NotNull(layerStream);
Assert.Equal(0, layerStream.Position);
Assert.NotEqual(0, layerStream.Length);
var config = await JsonSerializer.DeserializeAsync <Image>(configStream, default).ConfigureAwait(false);
// The RootFS is a Tar archive which contains the developer disk image, signature and a copy of the SystemVersion.plist file
var reader = new TarReader(layerStream);
(TarHeader? header, Stream entryStream) = await reader.ReadAsync(default).ConfigureAwait(false);
public void Add_PaxGlobalExtendedAttributes_NoEntries(bool withAttributes)
{
using MemoryStream archive = new MemoryStream();
Dictionary <string, string> globalExtendedAttributes = new Dictionary <string, string>();
if (withAttributes)
{
globalExtendedAttributes.Add("hello", "world");
}
using (TarWriter writer = new TarWriter(archive, globalExtendedAttributes, leaveOpen: true))
{
} // Dispose with no entries
archive.Seek(0, SeekOrigin.Begin);
using (TarReader reader = new TarReader(archive))
{
// Unknown until reading first entry
Assert.Equal(TarEntryFormat.Unknown, reader.Format);
Assert.Null(reader.GlobalExtendedAttributes);
Assert.Null(reader.GetNextEntry());
Assert.Equal(TarEntryFormat.Pax, reader.Format);
Assert.NotNull(reader.GlobalExtendedAttributes);
int expectedCount = withAttributes ? 1 : 0;
Assert.Equal(expectedCount, reader.GlobalExtendedAttributes.Count);
if (expectedCount > 0)
{
Assert.Equal("world", reader.GlobalExtendedAttributes["hello"]);
}
}
}
public void Read_Archive_File_SymbolicLink(TarFormat format, TestTarFormat testFormat)
{
string testCaseName = "file_symlink";
using MemoryStream ms = GetTarMemoryStream(CompressionMethod.Uncompressed, testFormat, testCaseName);
using TarReader reader = new TarReader(ms);
if (testFormat == TestTarFormat.pax_gea)
{
// The GEA are collected after reading the first entry, not on the constructor
Assert.Null(reader.GlobalExtendedAttributes);
}
// Format is determined after reading the first entry, not on the constructor
Assert.Equal(TarFormat.Unknown, reader.Format);
TarEntry file = reader.GetNextEntry();
Assert.Equal(format, reader.Format);
if (testFormat == TestTarFormat.pax_gea)
{
Assert.NotNull(reader.GlobalExtendedAttributes);
Assert.True(reader.GlobalExtendedAttributes.Any());
Assert.Contains(AssetPaxGeaKey, reader.GlobalExtendedAttributes);
Assert.Equal(AssetPaxGeaValue, reader.GlobalExtendedAttributes[AssetPaxGeaKey]);
}
Verify_Archive_RegularFile(file, format, reader.GlobalExtendedAttributes, "file.txt", $"Hello {testCaseName}");
TarEntry symbolicLink = reader.GetNextEntry();
Verify_Archive_SymbolicLink(symbolicLink, reader.GlobalExtendedAttributes, "link.txt", "file.txt");
Assert.Null(reader.GetNextEntry());
}
private static void Main(string[] args)
{
var parser = new ParameterParser <ConsoleParameters>();
var parameters = parser.Parse(args);
Console.WriteLine("SanteDB Secure Clinical Backup Extractor");
Console.WriteLine("Version {0}", Assembly.GetEntryAssembly().GetName().Version);
Console.WriteLine(Assembly.GetEntryAssembly().GetCustomAttribute <AssemblyCopyrightAttribute>().Copyright);
if (parameters.Help || args.Length == 0)
{
parser.WriteHelp(Console.Out);
}
else
{
using (var fs = File.OpenRead(parameters.Source))
{
// Validate header
byte[] header = new byte[MAGIC.Length];
fs.Read(header, 0, MAGIC.Length);
if (!header.SequenceEqual(MAGIC))
{
throw new InvalidOperationException("Backup file is invalid");
}
Stream inStream = fs;
try
{
// Encrypted?
if (fs.ReadByte() == 1)
{
// Read length of IV
byte[] ivLengthByte = new byte[4];
fs.Read(ivLengthByte, 0, 4);
var ivLength = BitConverter.ToInt32(ivLengthByte, 0);
// Read IV
byte[] iv = new byte[ivLength];
fs.Read(iv, 0, ivLength);
// Now Create crypto stream with password
var password = PasswordPrompt("Archive Password:"******"Extracting : {0}", tr.Entry.Key);
var destDir = Path.Combine(parameters.Destination, tr.Entry.Key.Replace('/', Path.DirectorySeparatorChar));
if (!Directory.Exists(Path.GetDirectoryName(destDir)))
{
Directory.CreateDirectory(Path.GetDirectoryName(destDir));
}
if (!tr.Entry.IsDirectory)
{
using (var s = tr.OpenEntryStream())
using (var ofs = File.Create(Path.Combine(parameters.Destination, tr.Entry.Key)))
s.CopyTo(ofs);
}
}
}
}
catch (Exception e)
{
Console.WriteLine("Could not extract backup: {0}", e);
}
}
}
}
// Constructor used when reading an existing archive.
internal PosixTarEntry(TarHeader header, TarReader readerOfOrigin)
: base(header, readerOfOrigin)
{
}
public async Task GarbageEntryChecksumZeroReturnNullAsync()
{
await using MemoryStream archiveStream = GetTarMemoryStream(CompressionMethod.Uncompressed, "golang_tar", "issue12435");
await using TarReader reader = new TarReader(archiveStream);
Assert.Null(await reader.GetNextEntryAsync());
}
[InlineData("writer-big")] // The size field contains an euro char
public async Task Throw_ArchivesWithRandomCharsAsync(string testCaseName)
{
await using MemoryStream archiveStream = GetTarMemoryStream(CompressionMethod.Uncompressed, "golang_tar", testCaseName);
await using TarReader reader = new TarReader(archiveStream);
await Assert.ThrowsAsync <FormatException>(async() => await reader.GetNextEntryAsync());
}
public async Task Throw_SingleExtendedAttributesEntryWithNoActualEntryAsync()
{
await using MemoryStream archiveStream = GetTarMemoryStream(CompressionMethod.Uncompressed, "golang_tar", "pax-path-hdr");
await using TarReader reader = new TarReader(archiveStream);
await Assert.ThrowsAsync <EndOfStreamException>(async() => await reader.GetNextEntryAsync());
}
/// <summary>
/// Opens a Reader for Non-seeking usage
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <returns></returns>
public static IReader Open(Stream stream, Options options = Options.KeepStreamsOpen)
{
stream.CheckNotNull("stream");
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
if (ZipArchive.IsZipFile(rewindableStream, null))
{
rewindableStream.Rewind(true);
return(ZipReader.Open(rewindableStream, null, options));
}
#if GZIP
rewindableStream.Rewind(false);
if (GZipArchive.IsGZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, CompressionType.GZip, options));
}
rewindableStream.Rewind(true);
return(GZipReader.Open(rewindableStream, options));
}
#endif
#if BZIP2
rewindableStream.Rewind(false);
if (BZip2Stream.IsBZip2(rewindableStream))
{
rewindableStream.Rewind(false);
BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, false);
#if TAR
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, CompressionType.BZip2, options));
}
#endif
}
#endif
#if TAR
rewindableStream.Rewind(false);
if (TarArchive.IsTarFile(rewindableStream))
{
rewindableStream.Rewind(true);
return(TarReader.Open(rewindableStream, options));
}
#endif
#if RAR
rewindableStream.Rewind(false);
if (RarArchive.IsRarFile(rewindableStream, options))
{
rewindableStream.Rewind(true);
return(RarReader.Open(rewindableStream, options));
}
#endif
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar");
}
public void VerifyIncludeBaseDirectory(bool includeBaseDirectory)
{
using TempDirectory source = new TempDirectory();
using TempDirectory destination = new TempDirectory();
UnixFileMode baseDirectoryMode = TestPermission1;
SetUnixFileMode(source.Path, baseDirectoryMode);
string fileName1 = "file1.txt";
string filePath1 = Path.Join(source.Path, fileName1);
File.Create(filePath1).Dispose();
UnixFileMode filename1Mode = TestPermission2;
SetUnixFileMode(filePath1, filename1Mode);
string subDirectoryName = "dir/"; // The trailing separator is preserved in the TarEntry.Name
string subDirectoryPath = Path.Join(source.Path, subDirectoryName);
Directory.CreateDirectory(subDirectoryPath);
UnixFileMode subDirectoryMode = TestPermission3;
SetUnixFileMode(subDirectoryPath, subDirectoryMode);
string fileName2 = "file2.txt";
string filePath2 = Path.Join(subDirectoryPath, fileName2);
File.Create(filePath2).Dispose();
UnixFileMode filename2Mode = TestPermission4;
SetUnixFileMode(filePath2, filename2Mode);
string destinationArchiveFileName = Path.Join(destination.Path, "output.tar");
TarFile.CreateFromDirectory(source.Path, destinationArchiveFileName, includeBaseDirectory);
using FileStream fileStream = File.OpenRead(destinationArchiveFileName);
using TarReader reader = new TarReader(fileStream);
List <TarEntry> entries = new List <TarEntry>();
TarEntry entry;
while ((entry = reader.GetNextEntry()) != null)
{
entries.Add(entry);
}
int expectedCount = 3 + (includeBaseDirectory ? 1 : 0);
Assert.Equal(expectedCount, entries.Count);
string prefix = includeBaseDirectory ? Path.GetFileName(source.Path) + '/' : string.Empty;
if (includeBaseDirectory)
{
TarEntry baseEntry = entries.FirstOrDefault(x =>
x.EntryType == TarEntryType.Directory &&
x.Name == prefix);
Assert.NotNull(baseEntry);
AssertEntryModeFromFileSystemEquals(baseEntry, baseDirectoryMode);
}
TarEntry entry1 = entries.FirstOrDefault(x =>
x.EntryType == TarEntryType.RegularFile &&
x.Name == prefix + fileName1);
Assert.NotNull(entry1);
AssertEntryModeFromFileSystemEquals(entry1, filename1Mode);
TarEntry directory = entries.FirstOrDefault(x =>
x.EntryType == TarEntryType.Directory &&
x.Name == prefix + subDirectoryName);
Assert.NotNull(directory);
AssertEntryModeFromFileSystemEquals(directory, subDirectoryMode);
string actualFileName2 = subDirectoryName + fileName2; // Notice the trailing separator in subDirectoryName
TarEntry entry2 = entries.FirstOrDefault(x =>
x.EntryType == TarEntryType.RegularFile &&
x.Name == prefix + actualFileName2);
Assert.NotNull(entry2);
AssertEntryModeFromFileSystemEquals(entry2, filename2Mode);
}
public Hapi.Chart.Chart Serialize()
{
var chart = new Hapi.Chart.Chart();
chart.Metadata = this.Metadata;
this.stream.Seek(0, SeekOrigin.Begin);
using (var gzipStream = new GZipStream(this.stream, CompressionMode.Decompress, leaveOpen: true))
using (var reader = TarReader.Open(gzipStream, new ReaderOptions()
{
LeaveStreamOpen = true
}))
{
while (reader.MoveToNextEntry())
{
if (this.IsTemplate(reader.Entry.Key))
{
using (Stream entryStream = reader.OpenEntryStream())
{
var template = new Hapi.Chart.Template()
{
Data = ByteString.FromStream(entryStream),
Name = Normalize(reader.Entry.Key).Substring(this.directoryName.Length + 1)
};
chart.Templates.Add(template);
}
}
else if (this.IsValues(reader.Entry.Key))
{
using (Stream entryStream = reader.OpenEntryStream())
using (StreamReader entryReader = new StreamReader(entryStream))
{
chart.Values = new Hapi.Chart.Config()
{
Raw = entryReader.ReadToEnd()
};
}
}
else if (!this.IsTemplate(reader.Entry.Key) &&
!this.IsMetadata(reader.Entry.Key) &&
!this.IsValues(reader.Entry.Key))
{
// TODO: respect .helmignore
using (Stream entryStream = reader.OpenEntryStream())
{
chart.Files.Add(new Any()
{
TypeUrl = Normalize(reader.Entry.Key).Substring(this.directoryName.Length + 1),
Value = ByteString.FromStream(entryStream)
});
}
}
}
}
// Dependencies are currently not supported
// chart.Dependencies.Add();
return(chart);
}
public TarArchiveReadStream(TarReader tarReader, Action onClose)
{
_tarReader = tarReader;
_onClose = onClose;
}
// Constructor called when reading a TarEntry from a TarReader.
internal GnuTarEntry(TarHeader header, TarReader readerOfOrigin)
: base(header, readerOfOrigin, TarEntryFormat.Gnu)
{
}
public static bool TryOpen(Stream stream, ReaderOptions options, ArchiveTypeMask archiveTypes, out IReader reader)
{
stream.CheckNotNull("stream");
options = options ?? new ReaderOptions()
{
LeaveStreamOpen = false
};
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
if (archiveTypes.HasFlag(ArchiveTypeMask.Zip) && ZipArchive.IsZipFile(rewindableStream, options.Password))
{
rewindableStream.Rewind(true);
reader = ZipReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.GZip) && GZipArchive.IsGZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.GZip);
return(true);
}
rewindableStream.Rewind(true);
reader = GZipReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.BZip2) && BZip2Stream.IsBZip2(rewindableStream))
{
rewindableStream.Rewind(false);
BZip2Stream testStream = new BZip2Stream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress, false);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.BZip2);
return(true);
}
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.LZip) && LZipStream.IsLZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
LZipStream testStream = new LZipStream(new NonDisposingStream(rewindableStream), CompressionMode.Decompress);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.LZip);
return(true);
}
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.Rar) && RarArchive.IsRarFile(rewindableStream, options))
{
rewindableStream.Rewind(true);
reader = RarReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(rewindableStream))
{
rewindableStream.Rewind(true);
reader = TarReader.Open(rewindableStream, options);
return(true);
}
rewindableStream.Rewind(false);
if (XZStream.IsXZStream(rewindableStream))
{
rewindableStream.Rewind(true);
XZStream testStream = new XZStream(rewindableStream);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
reader = new TarReader(rewindableStream, options, CompressionType.Xz);
return(true);
}
}
reader = null;
return(false);
}
// Constructor used when reading an existing archive.
internal UstarTarEntry(TarHeader header, TarReader readerOfOrigin)
: base(header, readerOfOrigin)
{
}
public SoundEffect(Stream inputStream, bool isOpus = false)
{
byte[] pcmData = null;
if (isOpus)
{
using (var opusFile = new OggOpusFile(inputStream)) {
if (opusFile.LinkCount > 1)
{
throw new NotSupportedException("Opus files with multiple links are not supported.");
}
_md = new SfxMetadata()
{
Bits = 16,
Rate = 48000,
Channels = opusFile.GetChannelCount(),
Length = (int)opusFile.GetPcmTotal(),
};
int valuesRead;
pcmData = new byte[sizeof(short) * _md.Channels * _md.Length];
short[] readBuffer = new short[5760 * 2];
using (var dataWriter = new BinaryWriter(new MemoryStream(pcmData))) {
while ((valuesRead = opusFile.Read(readBuffer, 0, readBuffer.Length) * _md.Channels) > 0)
{
for (int i = 0; i < valuesRead; i++)
{
dataWriter.Write(readBuffer[i]);
}
}
}
}
}
else
{
using (var s = inputStream) {
var tr = new TarReader(s);
while (tr.MoveNext(false))
{
switch (tr.FileInfo.FileName)
{
case "sound.bin":
var bytes = new byte[tr.FileInfo.SizeInBytes];
using (var ms = new MemoryStream(bytes)) {
tr.Read(ms);
ms.Position = 0;
using (var br = new BinaryReader(ms)) {
_md = SfxMetadata.Read(br);
}
}
break;
case "sound.pcm":
pcmData = new byte[tr.FileInfo.SizeInBytes];
tr.Read(new MemoryStream(pcmData));
break;
default:
throw new ContentException("Unrecognized sound file " + tr.FileInfo.FileName);
}
}
}
}
ALFormat format;
switch (_md.Channels)
{
case 1:
switch (_md.Bits)
{
case 8:
format = ALFormat.Mono8;
break;
case 16:
format = ALFormat.Mono16;
break;
case 32:
format = ALFormat.MonoFloat32Ext;
break;
default:
throw new NotSupportedException("Sounds must be 8, 16, or 32 bit.");
}
break;
case 2:
switch (_md.Bits)
{
case 8:
format = ALFormat.Stereo8;
break;
case 16:
format = ALFormat.Stereo16;
break;
case 32:
format = ALFormat.StereoFloat32Ext;
break;
default:
throw new NotSupportedException("Sounds must be 8, 16, or 32 bit.");
}
break;
default:
throw new NotSupportedException("Sound effects must be mono or stereo.");
}
_buffer = AL.GenBuffer();
AL.BufferData(_buffer, format, pcmData, pcmData.Length, _md.Rate);
}
// Constructor called when reading a TarEntry from a TarReader.
internal V7TarEntry(TarHeader header, TarReader readerOfOrigin)
: base(header, readerOfOrigin, TarEntryFormat.V7)
{
}
void Initialize(Stream stream, Shader shader = null)
{
ThreadContext.Current.EnsureGLContext();
if (shader == null)
{
shader = new SpriteShader();
}
int filterMode = 0;
var defs = new Dictionary <string, SpriteDefinition>();
var tr = new TarReader(stream);
while (tr.MoveNext(false))
{
switch (tr.FileInfo.FileName)
{
case "atlas.bin":
using (var atlasStream = new MemoryStream()) {
tr.Read(atlasStream);
atlasStream.Position = 0;
using (var br = new BinaryReader(atlasStream)) {
filterMode = br.ReadInt32();
for (var count = br.ReadInt32(); count > 0; --count)
{
var key = br.ReadString();
var value = SpriteDefinition.Read(br);
defs.Add(key, value);
}
}
}
break;
case "sheet.png":
using (var sheetStream = new MemoryStream((int)tr.FileInfo.SizeInBytes)) {
tr.Read(sheetStream);
sheetStream.Position = 0;
var tex = new Texture(sheetStream, new TextureSettings {
MagFilter = filterMode > 0 ? TextureFilter.Linear : TextureFilter.Nearest,
MinFilter = filterMode == 1 ? TextureFilter.Linear : filterMode == 2 ? TextureFilter.Trilinear : TextureFilter.Nearest,
});
_material = new SpriteMaterial(shader, tex);
}
break;
default:
throw new ContentException("Unrecognized atlas file " + tr.FileInfo.FileName);
}
}
if (defs == null)
{
throw new ContentException("Missing atlas file.");
}
if (_material == null)
{
throw new ContentException("Missing image file.");
}
_sprites = new Dictionary <string, Sprite>();
_vbuffer = new VertexBuffer(VertexFormat.PositionColorUV);
_ibuffer = new IndexBuffer();
var vstride = _vbuffer.Format.Stride * 4;
int vOffset = 0, iOffset = 0, vcount = 0;
var vertices = new float[vstride * defs.Count];
var indices = new int[6 * defs.Count];
var tsz = new Vector2(_material.Texture.Size.Width, _material.Texture.Size.Height);
foreach (var kvp in defs)
{
var def = kvp.Value;
var pos = def.Position;
var sz = def.Size;
var orig = def.Origin;
var color = ParseColor(def.Color);
orig.X *= sz.X;
orig.Y *= sz.Y;
if (def.Border != Vector4.Zero)
{
_sprites.Add(kvp.Key, new SlicedSprite(_material, pos, sz, orig, color, def.Border, def.TileX, def.TileY, def.Hollow));
continue;
}
var uv = new Vector4(
pos.X / tsz.X,
((pos.Y + sz.Y)) / tsz.Y,
(pos.X + sz.X) / tsz.X,
(pos.Y) / tsz.Y
);
Array.Copy(new[] {
-orig.X, -orig.Y, 0f, color.X, color.Y, color.Z, color.W, uv.X, uv.Y,
sz.X - orig.X, -orig.Y, 0f, color.X, color.Y, color.Z, color.W, uv.Z, uv.Y,
sz.X - orig.X, sz.Y - orig.Y, 0f, color.X, color.Y, color.Z, color.W, uv.Z, uv.W,
-orig.X, sz.Y - orig.Y, 0f, color.X, color.Y, color.Z, color.W, uv.X, uv.W
}, 0, vertices, vOffset, vstride);
Array.Copy(new[] {
vcount + 0, vcount + 1, vcount + 2, vcount + 2, vcount + 3, vcount + 0
}, 0, indices, iOffset, 6);
var sprite = new Sprite(_material, sz, _vbuffer, _ibuffer, iOffset, 6);
_sprites.Add(kvp.Key, sprite);
vOffset += vstride;
iOffset += 6;
vcount += 4;
}
_vbuffer.Data = vertices;
_vbuffer.Commit();
_ibuffer.Data = indices;
_ibuffer.Commit();
}
public void TestEOF()
{
List<ITarHeader> list = new List<ITarHeader>();
var reader = new TarReader(gnuStream);
while (!reader.EOF)
{
reader.MoveNext(true);
list.Add(reader.FileInfo);
}
Assert.IsNotNull(list.FirstOrDefault(x => x.FileName == "hello/"));
Assert.IsNotNull(list.FirstOrDefault(x => x.FileName == "hello/world/"));
Assert.IsNotNull(list.FirstOrDefault(x => x.FileName == "hello/world/hello"));
}
/// <summary>
/// Opens a Reader for Non-seeking usage
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <returns></returns>
public static IReader Open(Stream stream, ReaderOptions options = null)
{
stream.CheckNotNull("stream");
options = options ?? new ReaderOptions()
{
LeaveStreamOpen = false
};
RewindableStream rewindableStream = new RewindableStream(stream);
rewindableStream.StartRecording();
if (ZipArchive.IsZipFile(rewindableStream, options.Password))
{
rewindableStream.Rewind(true);
return(ZipReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
if (GZipArchive.IsGZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
GZipStream testStream = new GZipStream(rewindableStream, CompressionMode.Decompress);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.GZip));
}
rewindableStream.Rewind(true);
return(GZipReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
if (BZip2Stream.IsBZip2(rewindableStream))
{
rewindableStream.Rewind(false);
BZip2Stream testStream = new BZip2Stream(rewindableStream, CompressionMode.Decompress, true);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.BZip2));
}
}
rewindableStream.Rewind(false);
if (LZipStream.IsLZipFile(rewindableStream))
{
rewindableStream.Rewind(false);
LZipStream testStream = new LZipStream(rewindableStream, CompressionMode.Decompress, true);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.LZip));
}
}
rewindableStream.Rewind(false);
if (RarArchive.IsRarFile(rewindableStream, options))
{
rewindableStream.Rewind(true);
return(RarReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
if (TarArchive.IsTarFile(rewindableStream))
{
rewindableStream.Rewind(true);
return(TarReader.Open(rewindableStream, options));
}
rewindableStream.Rewind(false);
if (XZStream.IsXZStream(rewindableStream))
{
rewindableStream.Rewind(true);
XZStream testStream = new XZStream(rewindableStream);
if (TarArchive.IsTarFile(testStream))
{
rewindableStream.Rewind(true);
return(new TarReader(rewindableStream, options, CompressionType.Xz));
}
}
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Reader Formats: Zip, GZip, BZip2, Tar, Rar, LZip, XZ");
}
private void wc_DownloadDataCompleted(object sender, DownloadDataCompletedEventArgs e)
{
if (e.Error != null)
{
MessageBox.Show(Configuration.Settings.Language.GetTesseractDictionaries.DownloadFailed);
DialogResult = DialogResult.Cancel;
return;
}
string dictionaryFolder = Configuration.TesseractDataFolder;
if (!Directory.Exists(dictionaryFolder))
Directory.CreateDirectory(dictionaryFolder);
int index = comboBoxDictionaries.SelectedIndex;
var tempFileName = Path.GetTempFileName() + ".tar";
using (var ms = new MemoryStream(e.Result))
using (var fs = new FileStream(tempFileName, FileMode.Create))
using (var zip = new GZipStream(ms, CompressionMode.Decompress))
{
byte[] buffer = new byte[1024];
int nRead;
while ((nRead = zip.Read(buffer, 0, buffer.Length)) > 0)
{
fs.Write(buffer, 0, nRead);
}
}
using (var tr = new TarReader(tempFileName))
{
foreach (var th in tr.Files)
{
string fn = Path.Combine(dictionaryFolder, Path.GetFileName(th.FileName.Trim()));
th.WriteData(fn);
}
}
File.Delete(tempFileName);
Cursor = Cursors.Default;
labelPleaseWait.Text = string.Empty;
buttonOK.Enabled = true;
buttonDownload.Enabled = true;
comboBoxDictionaries.Enabled = true;
MessageBox.Show(string.Format(Configuration.Settings.Language.GetDictionaries.XDownloaded, comboBoxDictionaries.Items[index]));
}
/// <summary>
/// Suck the brains out of the app
/// </summary>
static void Main(string[] args)
{
Console.WriteLine("OpenIZ BrainBug - Android Extraction Tool");
Console.WriteLine("Version {0}", Assembly.GetEntryAssembly().GetName().Version);
var parameters = new ParameterParser <ConsoleParameters>().Parse(args);
if (parameters.Help)
{
new ParameterParser <ConsoleParameters>().WriteHelp(Console.Out);
return;
}
if (parameters.TargetFile == null && parameters.ExtractDir == null)
{
Console.WriteLine("Either --tar or --extract must be specified");
return;
}
if (parameters.PackageId != null)
{
var exeFile = Path.Combine(parameters.SdkPath, "platform-tools", "adb.exe");
StringBuilder argStr = new StringBuilder();
if (!String.IsNullOrEmpty(parameters.DeviceId))
{
argStr.AppendFormat(" -s {0} ", parameters.DeviceId);
}
argStr.Append("backup ");
argStr.AppendFormat("-f \"backup.ab\"", parameters.BackupFile);
argStr.Append(" -noapk -noobb ");
argStr.Append(parameters.PackageId);
Console.WriteLine("Starting {0} {1}", exeFile, argStr.ToString());
var pi = new Process();
pi.StartInfo.FileName = String.Format("\"{0}\"", exeFile);
pi.StartInfo.Arguments = argStr.ToString();
pi.StartInfo.CreateNoWindow = true;
pi.StartInfo.RedirectStandardError = true;
pi.StartInfo.RedirectStandardOutput = true;
pi.StartInfo.UseShellExecute = false;
pi.Start();
Console.WriteLine(pi.StandardOutput.ReadToEnd());
Console.WriteLine(pi.StandardError.ReadToEnd());
pi.WaitForExit();
if (File.Exists(parameters.BackupFile))
{
File.Delete(parameters.BackupFile);
}
File.Move("backup.ab", parameters.BackupFile);
}
if (!File.Exists(parameters.BackupFile))
{
Console.WriteLine("Cannot find specified backup file!");
return;
}
try
{
Console.WriteLine("Extracting {0}...", parameters.BackupFile);
byte[] buffer = new byte[8096];
using (FileStream ins = File.OpenRead(parameters.BackupFile))
{
ins.Read(buffer, 0, 24);
String magic = System.Text.Encoding.UTF8.GetString(buffer, 0, 24);
//ins.Seek(24, SeekOrigin.Begin);
using (FileStream outs = File.Create(parameters.TargetFile))
{
using (ZLibNet.ZLibStream df = new ZLibNet.ZLibStream(ins, ZLibNet.CompressionMode.Decompress))
{
int br = 8096;
while (br == 8096)
{
br = df.Read(buffer, 0, 8096);
outs.Write(buffer, 0, br);
}
}
}
}
// Extract
if (parameters.ExtractDir != null)
{
if (!Directory.Exists(parameters.ExtractDir))
{
Directory.CreateDirectory(parameters.ExtractDir);
}
using (var fs = File.OpenRead(parameters.TargetFile))
using (var tar = TarReader.Open(fs))
while (tar.MoveToNextEntry())
{
string outName = Path.Combine(parameters.ExtractDir, tar.Entry.Key);
if (!Directory.Exists(Path.GetDirectoryName(outName)))
{
Directory.CreateDirectory(Path.GetDirectoryName(outName));
}
Console.WriteLine("{0} > {1}", tar.Entry.Key, outName);
if (!tar.Entry.IsDirectory)
{
using (var ofs = File.Create(outName))
tar.WriteEntryTo(ofs);
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public async Task IncludeAllSegmentsOfPath_Async(bool includeBaseDirectory)
{
using (TempDirectory source = new TempDirectory())
using (TempDirectory destination = new TempDirectory())
{
string segment1 = Path.Join(source.Path, "segment1");
Directory.CreateDirectory(segment1);
string segment2 = Path.Join(segment1, "segment2");
Directory.CreateDirectory(segment2);
string textFile = Path.Join(segment2, "file.txt");
File.Create(textFile).Dispose();
string destinationArchiveFileName = Path.Join(destination.Path, "output.tar");
await TarFile.CreateFromDirectoryAsync(source.Path, destinationArchiveFileName, includeBaseDirectory);
FileStreamOptions readOptions = new()
{
Access = FileAccess.Read,
Mode = FileMode.Open,
Options = FileOptions.Asynchronous,
};
await using (FileStream fileStream = File.Open(destinationArchiveFileName, readOptions))
{
await using (TarReader reader = new TarReader(fileStream))
{
string prefix = includeBaseDirectory ? Path.GetFileName(source.Path) + '/' : string.Empty;
TarEntry entry;
if (includeBaseDirectory)
{
entry = await reader.GetNextEntryAsync();
Assert.NotNull(entry);
Assert.Equal(TarEntryType.Directory, entry.EntryType);
Assert.Equal(prefix, entry.Name);
}
entry = await reader.GetNextEntryAsync();
Assert.NotNull(entry);
Assert.Equal(TarEntryType.Directory, entry.EntryType);
Assert.Equal(prefix + "segment1/", entry.Name);
entry = await reader.GetNextEntryAsync();
Assert.NotNull(entry);
Assert.Equal(TarEntryType.Directory, entry.EntryType);
Assert.Equal(prefix + "segment1/segment2/", entry.Name);
entry = await reader.GetNextEntryAsync();
Assert.NotNull(entry);
Assert.Equal(TarEntryType.RegularFile, entry.EntryType);
Assert.Equal(prefix + "segment1/segment2/file.txt", entry.Name);
Assert.Null(await reader.GetNextEntryAsync());
}
}
}
}
