/// <summary>
/// Verifies the client in a directory is extracted correctly.
/// </summary>
/// <param name="targetLocation">Location to verify.</param>
/// <returns>Whether the extract was verified.</returns>
public override bool Verify(string targetLocation)
{
// Get the archive entries.
using var rarFile = RarArchive.Open(this.ArchiveFile);
var archiveDirectory = Path.GetDirectoryName(rarFile.Entries.First(entry => Path.GetFileName(entry.Key).ToLower() == "legouniverse.exe").Key);
// Verify the files exist and return false if a file is missing.
foreach (var entry in rarFile.Entries)
{
// Return if the file is not in the parent directory of legouniverse.exe.
// Some archives include other files that should not be looked at.
if (!entry.Key.ToLower().StartsWith(archiveDirectory !.ToLower()) || entry.IsDirectory)
{
continue;
}
// Determine the destination file path.
var filePath = Path.Combine(targetLocation, Path.GetRelativePath(archiveDirectory, entry.Key));
if (entry.Size == 0 || File.Exists(filePath))
{
continue;
}
return(false);
}
// Return true (verified).
return(true);
}
private void UnArch(Label label, ProgressBar progressBar)
{
using (var archive = RarArchive.Open(gamepath + "\\Archive.rar"))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(gamepath, new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
File.Delete(gamepath + "\\Archive.rar");
MessageBox.Show("Dowload and installing complited.\nNow you have a game!");
if (label.InvokeRequired && progressBar.InvokeRequired)
{
label.Invoke(new MethodInvoker(delegate
{
label.Visible = false;
}));
progressBar.Invoke(new MethodInvoker(delegate
{
progressBar.Visible = false;
progressBar.Value = 0;
}));
}
}
public static BoolWithMessage ExtractRarFile(string pathToRar, string extractPath)
{
try
{
Logger.Info($"extracting .rar {pathToRar} ...");
using (RarArchive archive = RarArchive.Open(pathToRar))
{
Logger.Info("... Opened .rar for read");
foreach (RarArchiveEntry entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
Logger.Info($"...... extracting {entry.Key}");
entry.WriteToDirectory(extractPath, new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
Logger.Info($"......... extracted!");
}
}
}
catch (Exception e)
{
Logger.Error(e);
return(new BoolWithMessage(false, e.Message));
}
return(new BoolWithMessage(true));
}
/// <summary>
/// Opens an Archive for random access
/// </summary>
/// <param name="stream"></param>
/// <param name="readerOptions"></param>
/// <returns></returns>
public static IArchive Open(Stream stream, ReaderOptions?readerOptions = null)
{
stream.CheckNotNull(nameof(stream));
if (!stream.CanRead || !stream.CanSeek)
{
throw new ArgumentException("Stream should be readable and seekable");
}
readerOptions ??= new ReaderOptions();
ArchiveType?type;
IsArchive(stream, out type); //test and reset stream position
if (type != null)
{
switch (type.Value)
{
case ArchiveType.Zip:
return(ZipArchive.Open(stream, readerOptions));
case ArchiveType.SevenZip:
return(SevenZipArchive.Open(stream, readerOptions));
case ArchiveType.GZip:
return(GZipArchive.Open(stream, readerOptions));
case ArchiveType.Rar:
return(RarArchive.Open(stream, readerOptions));
case ArchiveType.Tar:
return(TarArchive.Open(stream, readerOptions));
}
}
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip");
}
public int GetEntriesCount()
{
switch (Type)
{
case ArchiveType.Rar:
using (var archive = RarArchive.Open(FullName, ReaderOptions))
return(archive.Entries.Count);
case ArchiveType.Zip:
using (var archive = ZipArchive.Open(FullName, ReaderOptions))
return(archive.Entries.Count);
case ArchiveType.Tar:
using (var archive = TarArchive.Open(FullName, ReaderOptions))
return(archive.Entries.Count);
case ArchiveType.SevenZip:
using (var archive = SevenZipArchive.Open(FullName, ReaderOptions))
return(archive.Entries.Count);
case ArchiveType.GZip:
using (var archive = GZipArchive.Open(FullName, ReaderOptions))
return(archive.Entries.Count);
default:
throw new ArgumentOutOfRangeException(nameof(Type), Type, null);
}
}
private static void InstallLITONE5()
{
Console.Out.WriteLine("Downloading LITONE5...");
FileDownloader.DownloadFileFromURLToPath($"https://drive.google.com/uc?id=15JN3UUS2up8U80X-79nLFukVZamBwKjB", @"litone5.rar");
Console.Out.WriteLine("Unzip LITONE5...");
using (var archive = RarArchive.Open(@"litone5.rar"))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(@"beatoraja0.6.1/skin", new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
FileDownloader.DownloadFileFromURLToPath($"https://drive.google.com/uc?id=1GB-pVfUlt36dXNUoTyQJLP7fSAfAz2-G", @"litone5_patch.rar");
Console.Out.WriteLine("Unzip LITONE5 patch...");
using (var archive = RarArchive.Open(@"litone5_patch.rar"))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(@"beatoraja0.6.1/skin", new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
}
public static IArchive Open(string filename, string password)
{
var archive = ArchiveFactory.Open(filename);
if (password == null)
{
return(archive);
}
switch (archive.Type)
{
case ArchiveType.Rar:
return(RarArchive.Open(filename, new ReaderOptions {
Password = password
}));
case ArchiveType.Zip:
return(ZipArchive.Open(filename, new ReaderOptions {
Password = password
}));
case ArchiveType.Tar:
case ArchiveType.SevenZip:
case ArchiveType.GZip:
throw new NotSupportedException(string.Format(ToolsStrings.ArchiveInstallator_UnsupportedEncryption, archive.Type));
default:
throw new ArgumentOutOfRangeException();
}
}
public static List <string> ExtractRarFile(string pathToRar, string extractPath, IProgress <double> progress = null)
{
List <string> filesExtracted = new List <string>();
Logger.Info($"extracting .rar {pathToRar} ...");
int entryCount = 1;
int currentCount = 0;
using (RarArchive archive = RarArchive.Open(pathToRar))
{
Logger.Info("... Opened .rar for read");
entryCount = archive.Entries.Count;
foreach (RarArchiveEntry entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
Logger.Info($"...... extracting {entry.Key}");
entry.WriteToDirectory(extractPath, new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
currentCount++;
progress?.Report((double)currentCount / (double)entryCount);
filesExtracted.Add(Path.Combine(extractPath, entry.Key));
Logger.Info($"......... extracted!");
}
}
return(filesExtracted);
}
public static bool ReemplazarDatosDelMundo()
{
Console.WriteLine("Chequeando archivo rar del escritorio...");
var filePath = Path.Combine(GetDesktopPath(), "GinkgoBilobaValheim.rar");
var exists = File.Exists(filePath);
if (!exists)
{
Console.WriteLine("No hay ningun archivo .rar con el nombre de 'GinkgoBilobaValheim' en el escritorio");
return(false);
}
Console.WriteLine("Archivo encontrado");
try
{
Console.WriteLine("Reemplazando archivos del mundo...");
using (var archive = RarArchive.Open(Path.Combine(GetDesktopPath(), "GinkgoBilobaValheim.rar")))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(GetWordPath(), new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine("Error! " + ex.Message);
return(false);
}
}
//Extract the 2nd file in a solid archive to check that the first file is skipped properly
private void DoRar_IsSolidEntryStreamCheck(string filename)
{
using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)))
{
using (var archive = RarArchive.Open(stream))
{
Assert.True(archive.IsSolid);
IArchiveEntry[] entries = archive.Entries.Where(a => !a.IsDirectory).ToArray();
Assert.NotInRange(entries.Length, 0, 1);
Assert.False(entries[0].IsSolid); //first item in a solid archive is not marked solid and is seekable
IArchiveEntry testEntry = entries[1];
Assert.True(testEntry.IsSolid); //the target. The non seekable entry
//process all entries in solid archive until the one we want to test
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
using (CrcCheckStream crcStream = new CrcCheckStream((uint)entry.Crc)) //use the 7zip CRC stream for convenience (required a bug fix)
{
using (Stream eStream = entry.OpenEntryStream()) //bug fix in RarStream to report the correct Position
eStream.CopyTo(crcStream);
} //throws if not valid
if (entry == testEntry)
{
break;
}
}
}
}
}
static void Main(string[] args)
{
using (Stream stream = File.OpenRead("ar.rar"))
using (var archive = RarArchive.Open(stream, new ReaderOptions()
{
Password = "******",
LeaveStreamOpen = true
}))
{
foreach (var entry in archive.Entries)
{
if (!entry.IsDirectory)
{
if (CompressionType.Rar == entry.CompressionType)
{
System.Console.WriteLine("Extention correct");
}
else
{
System.Console.WriteLine("Extention NOT correct!");
}
entry.WriteToDirectory(".", new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
}
}
private void Form1_Load(object sender, EventArgs e)
{
string[] arguments = Environment.GetCommandLineArgs();
string argumentinstring = string.Join(", ", arguments);
if (argumentinstring.EndsWith(@".zip"))
{
using (var archive = ZipArchive.Open(argumentinstring.Substring(argumentinstring.IndexOf(',') + 1)))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(Path.GetTempPath() + @"ZortosUnzipper", new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
//ZipFile.ExtractToDirectory(argumentinstring.Substring(argumentinstring.IndexOf(',') + 1), Path.GetTempPath() + @"ZortosUnzipper");
MessageBox.Show("Done File Extracted inside" + "\n" + Path.GetTempPath() + @"ZortosUnzipper");
Dispose();
Environment.Exit(0);
}
if (argumentinstring.EndsWith(".7z"))
{
using (var archive = SevenZipArchive.Open(argumentinstring.Substring(argumentinstring.IndexOf(',') + 1)))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(Path.GetTempPath() + @"ZortosUnzipper", new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
MessageBox.Show("Done File Extracted inside" + "\n" + Path.GetTempPath() + @"ZortosUnzipper");
Dispose();
Environment.Exit(0);
}
if (argumentinstring.EndsWith(".rar"))
{
using (var archive = RarArchive.Open(argumentinstring.Substring(argumentinstring.IndexOf(',') + 1)))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(Path.GetTempPath() + @"ZortosUnzipper", new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
MessageBox.Show("Done File Extracted inside:" + "\n" + Path.GetTempPath() + @"ZortosUnzipper");
Dispose();
Environment.Exit(0);
}
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
public static IArchive Open(FileInfo fileInfo, ReaderOptions options = null)
{
fileInfo.CheckNotNull(nameof(fileInfo));
options = options ?? new ReaderOptions {
LeaveStreamOpen = false
};
using (var stream = fileInfo.OpenRead())
{
if (ZipArchive.IsZipFile(stream, null))
{
return(ZipArchive.Open(fileInfo, options));
}
stream.Seek(0, SeekOrigin.Begin);
if (SevenZipArchive.IsSevenZipFile(stream))
{
return(SevenZipArchive.Open(fileInfo, options));
}
stream.Seek(0, SeekOrigin.Begin);
if (GZipArchive.IsGZipFile(stream))
{
return(GZipArchive.Open(fileInfo, options));
}
stream.Seek(0, SeekOrigin.Begin);
if (RarArchive.IsRarFile(stream, options))
{
return(RarArchive.Open(fileInfo, options));
}
stream.Seek(0, SeekOrigin.Begin);
if (TarArchive.IsTarFile(stream))
{
return(TarArchive.Open(fileInfo, options));
}
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
}
}
public void Rar_Multi_ArchiveStreamRead()
{
var testArchives = new string[] { "Rar.multi.part01.rar",
"Rar.multi.part02.rar",
"Rar.multi.part03.rar",
"Rar.multi.part04.rar",
"Rar.multi.part05.rar",
"Rar.multi.part06.rar" };
ResetScratch();
using (var archive = RarArchive.Open(testArchives.Select(s => Path.Combine(TEST_ARCHIVES_PATH, s))
.Select(File.OpenRead)))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
VerifyFiles();
}
/// <summary>
/// создает правильно сформированную папку с файлами для архива
/// </summary>
/// <param name="correctNameOfFile"></param>
/// <returns>путь, где лежит папка с файлами правильными</returns>
static string CreateCorrectFolders(string correctNameOfFile)
{
Console.WriteLine("Создние времеменной папки для хранения правильного набора данных...");
Directory.CreateDirectory(PathToSave + correctNameOfFile.Replace(".rar", ""));
for (int i = 0; i < CorrectFoldersItem.Count - 1; i++)
{
Directory.CreateDirectory(PathToSave + correctNameOfFile.Replace(".rar", "") + "\\" + CorrectFoldersItem[i]);
}
RarArchive archive = RarArchive.Open(PathToLastFileInArchive); //добавили файлы из архива в поток
foreach (RarArchiveEntry entry in archive.Entries) // проходимся по ним в цикле и записываем в папку темп
{
string filename = Path.GetFileName(entry.FilePath); //файл;
if (entry.ToString().Contains(CorrectFoldersItem[0])) //all_twn
{
entry.WriteToFile(PathToSave + correctNameOfFile.Replace(".rar", "") + "\\" + CorrectFoldersItem[0] + "\\" + filename, ExtractOptions.ExtractFullPath | ExtractOptions.Overwrite);
}
else if (entry.ToString().Contains(CorrectFoldersItem[1]))//cl_cod
{
entry.WriteToFile(PathToSave + correctNameOfFile.Replace(".rar", "") + "\\" + CorrectFoldersItem[1] + "\\" + filename, ExtractOptions.ExtractFullPath | ExtractOptions.Overwrite);
}
else//rgis.xml
{
entry.WriteToFile(PathToSave + correctNameOfFile.Replace(".rar", "") + "\\" + filename, ExtractOptions.ExtractFullPath | ExtractOptions.Overwrite);
}
}
return(PathToSave + correctNameOfFile.Replace(".rar", "") + "\\");
}
private void ReadRarPassword(string testArchive, string password)
{
ResetScratch();
using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testArchive)))
using (var archive = RarArchive.Open(stream, new ReaderOptions()
{
Password = password,
LeaveStreamOpen = true
}))
{
foreach (var entry in archive.Entries)
{
if (!entry.IsDirectory)
{
Assert.Equal(CompressionType.Rar, entry.CompressionType);
entry.WriteToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
}
VerifyFiles();
}
public string ExtractRARFile(string filePath, string UserID, int Fileid)
{
try
{
string[] FileDetail = filePath.ToString().Split(new string[] { "\\", ".rar" }, StringSplitOptions.RemoveEmptyEntries);
string fileName = FileDetail[FileDetail.Length - 1];
string newPath = null;
RarArchive file = RarArchive.Open(filePath);
newPath = Path.Combine(Server.MapPath("~/Files"), fileName);
using (DBClass context = new DBClass())
{
context.AddParameter("@FileID", Fileid);
context.AddParameter("@UserID", UserID);
context.AddParameter("@FileName", fileName);
context.AddParameter("@NewPath", newPath);
context.ExecuteNonQuery("UpdateFileData", CommandType.StoredProcedure);
}
foreach (RarArchiveEntry rarFile in file.Entries)
{
rarFile.WriteToDirectory(newPath, ExtractOptions.ExtractFullPath);
}
//if(System.IO.File.Exists(filePath))
//{
// System.IO.File.Delete(filePath);
//}
return(newPath);
}
catch (Exception e) { throw e; }
}
private bool ExtractZip(string path)
{
try
{
switch (Path.GetExtension(path).ToLower())
{
case ".7z":
using (var archive = SevenZipArchive.Open(path))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(Path.GetDirectoryName(path), new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
break;
case ".zip":
using (var archive = ZipArchive.Open(path))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(Path.GetDirectoryName(path), new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
break;
case ".rar":
using (var archive = RarArchive.Open(path))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(Path.GetDirectoryName(path), new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
break;
default:
break;
}
}
catch (Exception ex)
{
Error?.Invoke("Zip extraction failed: " + ex.Message);
return(false);
}
return(true);
}
public static void rarFunction(List <ExtractFile> inputList)
{
// extract files
foreach (var item in inputList)
{
try
{
using (var archive = RarArchive.Open(item.fileName))
{
foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
{
entry.WriteToDirectory(item.fileDestination, new ExtractionOptions()
{
ExtractFullPath = true,
Overwrite = true
});
}
}
using (FileStream fs = File.Create(item.filePath + @"\unrared"))
{
logger.Info($"file: {item.fileName} unrared.");
}
}
catch (Exception)
{
Console.WriteLine("fuckup");
logger.Info($"file: {item.fileName} did not unrar, error.");
}
}
}
static void ExtractRar(string file)
{
try {
//var tr = SharpCompress.Archives.Rar.RarArchive.Open(file);
//using (var reader = tr.ExtractAllEntries())
//{
// var options = new ExtractionOptions();
// options.ExtractFullPath = true;
// options.Overwrite = true;
// reader.WriteAllToDirectory(Path.GetDirectoryName(file), options);
//}
var filename = Path.GetFileNameWithoutExtension(file);
var rars = Directory.GetFiles(Path.GetDirectoryName(file), filename + ".r??").ToList()
.Where(f => !f.EndsWith(".rar")).OrderBy(x => x.ToString()).ToList();
//var str = File.OpenRead
//var reader = RarArchive.Open(file, new ReaderOptions { })
List <Stream> streams = new List <Stream>();
streams.Add(File.OpenRead(file));
foreach (var f in rars)
{
streams.Add(File.OpenRead(f));
}
//using (Stream stream = File.OpenRead(file))
//using (var reader = RarArchive.Open(streams))
//{
// foreach(var entry in reader.Entries)
// {
// var curDir = Path.GetDirectoryName(file);
// Console.WriteLine("-> " + entry.Key);
// entry.WriteEntryToDirectory(curDir, new ExtractionOptions()
// {
// ExtractFullPath = true,
// Overwrite = true,
// });
// }
//}
using (var reader = RarArchive.Open(streams))
{
//using (var entries = reader. ExtractAllEntries())
//{
// var options = new ExtractionOptions();
// options.ExtractFullPath = true;
// options.Overwrite = true;
// entries.WriteAllToDirectory(Path.GetDirectoryName(file), options);
//}
}
Console.WriteLine($"extracted rar {file}");
//delete rar files
foreach (var rar in Directory.EnumerateFiles(Path.GetDirectoryName(file), filename + ".r??"))
{
Console.WriteLine($"Deleting rar file {rar}");
File.Delete(rar);
}
}
catch (Exception ex)
{
throw;
}
}
private void DoRar_IsFirstVolume_False(string notFirstFilename)
{
using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, notFirstFilename)))
{
Assert.True(archive.IsMultipartVolume());
Assert.False(archive.IsFirstVolume());
}
}
public void Rar_IsFirstVolume_False()
{
using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "Rar.multi.part03.rar")))
{
Assert.True(archive.IsMultipartVolume());
Assert.False(archive.IsFirstVolume());
}
}
public override List <FB2File> LoadFile(string fileName, IFB2ImportSettings settings)
{
var result = new List <FB2File>();
try
{
RarArchive rarFile = RarArchive.Open(fileName);
int n = rarFile.Entries.Count;
Logger.Log.DebugFormat("Detected {0} entries in RAR file", n);
foreach (var entry in rarFile.Entries)
{
if (entry.IsDirectory)
{
Logger.Log.DebugFormat("{0} is not file but folder", fileName);
continue;
}
var extension = Path.GetExtension(entry.FilePath);
if (extension != null && extension.ToUpper() == ".FB2")
{
try
{
string tempPath = Path.GetTempPath();
entry.WriteToDirectory(tempPath);
if (FileTypeDetector.DetectFileType(tempPath) != FileTypeDetector.FileTypesEnum.FileTypeFB2)
{
Logger.Log.ErrorFormat("{0} is not FB2 file", entry.FilePath);
continue;
}
string fileNameOnly = Path.GetFileName(entry.FilePath);
Logger.Log.InfoFormat("Processing {0} ...", fileNameOnly);
var fb2Loader = new FB2FileLoader();
try
{
result.AddRange(fb2Loader.LoadFile(string.Format(@"{0}\{1}", tempPath, fileNameOnly), settings));
}
catch (Exception)
{
Logger.Log.ErrorFormat("Unable to load {0}", fileNameOnly);
}
}
catch (Exception ex)
{
Logger.Log.ErrorFormat("Unable to unrar file entry {0} : {1}", entry.FilePath, ex);
}
}
else
{
Logger.Log.InfoFormat("{0} is not FB2 file", entry.FilePath);
}
}
}
catch (Exception ex)
{
Logger.Log.ErrorFormat("Error loading RAR file : {0}", ex);
}
return(result);
}
private async Task LoadCBRComic(StorageFile storageFile)
{
try
{
using (var zipStream = await storageFile.OpenStreamForReadAsync())
using (var memoryStream = new MemoryStream((int)zipStream.Length))
{
await zipStream.CopyToAsync(memoryStream);
memoryStream.Position = 0;
var rarArchive = RarArchive.Open(memoryStream);
if (rarArchive == null)
{
return;
}
var comic = new DisplayComic
{
File = storageFile,
FullPath = storageFile.Name,
Name = storageFile.DisplayName,
Pages = rarArchive.Entries.Count
};
foreach (var entry in rarArchive.Entries)
{
if (IsValidEntry(entry))
{
continue;
}
using (var entryStream = new MemoryStream((int)entry.Size))
{
entry.WriteTo(entryStream);
entryStream.Position = 0;
using (var binaryReader = new BinaryReader(entryStream))
{
var bytes = binaryReader.ReadBytes((int)entryStream.Length);
comic.CoverageImageBytes = bytes;
break;
}
}
}
comics.Add(comic);
}
}
catch (Exception ex)
{
// Do nothing
}
}
/// <summary>指定されたエクセルブックファイルに含まれる画像を圧縮します。</summary>
/// <param name="sourceFilePath">ファイルパス</param>
/// <param name="targetInnerPath">処理対象内部パス</param>
internal void QuantFromZipFile(string sourceFilePath, string targetInnerPath = "")
{
string reg = this.IsConvertToPng ? @"{0}.*\.png|{0}.*\.jpeg|{0}.*\.jpg|{0}.*\.bmp" : @"{0}.*\.png";
reg = string.Format(reg, targetInnerPath);
Regex regex = new Regex(reg);
Console.WriteLine("減色を開始します：{0}", sourceFilePath);
string distinationFileName = Path.GetFileNameWithoutExtension(sourceFilePath) + ".zip";
string.Format(Properties.Settings.Default.FileNameTemplate, distinationFileName);
string distinationFilePath = Path.GetDirectoryName(sourceFilePath);
distinationFilePath = Path.Combine(distinationFilePath, distinationFileName);
this.OutputFilePath = distinationFilePath;
using (RarArchive archive = RarArchive.Open(sourceFilePath))
using (ZipArchive distArchive = new ZipArchive(new FileStream(distinationFilePath, FileMode.Create, FileAccess.Write), ZipArchiveMode.Create))
using (PngQuant pngquant = new PngQuant())
{
foreach (RarArchiveEntry entry in archive.Entries)
{
if (regex.IsMatch(entry.Key.ToLower()) == false)
{
ZipArchiveEntry distEntry = distArchive.CreateEntry(entry.Key);
using (Stream srcStream = entry.OpenEntryStream())
using (Stream distStream = distEntry.Open())
{
srcStream.CopyTo(distStream);
}
continue;
}
// 解凍して一時ファイルを作成し、減色する
Stream tranStream;
using (Stream s = entry.OpenEntryStream())
{
tranStream = pngquant.Subtractive(s);
}
// 減色したファイルをブックに再設定
string distEntryName = PathUtils.ChangeExtension(entry.Key, ".png");
var e = distArchive.CreateEntry(distEntryName, CompressionLevel.NoCompression);
using (var stream = e.Open())
{
tranStream.CopyTo(stream);
}
Console.WriteLine("・{0}", entry.Key);
// 変換イベントを発生させる
this.FileNameChanged?.Invoke(this, new FileNameChangedEventArgs(entry.Key, distEntryName));
}
}
}
RarArchive FirstArchiveForFile(string filePath)
{
if (ValidateArchive(filePath))
{
RarArchive archive = RarArchive.Open(filePath);
return(FirstArchiveForArchive(archive));
}
return(null);
}
public static void TestRar()
{
var archive = RarArchive.Open(@"C:\Code\sharpcompress\TestArchives\sharpcompress.rar");
foreach (var entry in archive.Entries)
{
entry.WriteToDirectory(@"C:\temp");
}
}
private RarArchive?GetRarArchive(FileEntry fileEntry, ExtractorOptions options)
{
RarArchive?rarArchive = null;
try
{
rarArchive = RarArchive.Open(fileEntry.Content);
}
catch (Exception e)
{
Logger.Debug(Extractor.DEBUG_STRING, ArchiveFileType.RAR, fileEntry.FullPath, string.Empty, e.GetType());
}
var needsPassword = false;
try
{
using var testStream = rarArchive.Entries.First().OpenEntryStream();
}
catch (Exception e)
{
needsPassword = true;
}
if (needsPassword is true)
{
var passwordFound = false;
foreach (var passwords in options.Passwords.Where(x => x.Key.IsMatch(fileEntry.Name)))
{
if (passwordFound)
{
break;
}
foreach (var password in passwords.Value)
{
try
{
fileEntry.Content.Position = 0;
rarArchive = RarArchive.Open(fileEntry.Content, new SharpCompress.Readers.ReaderOptions()
{
Password = password, LookForHeader = true
});
var count = 0; //To do something in the loop
foreach (var entry in rarArchive.Entries)
{
//Just do anything in the loop, but you need to loop over entries to check if the password is correct
count++;
}
break;
}
catch (Exception e)
{
Logger.Debug(Extractor.DEBUG_STRING, ArchiveFileType.RAR, fileEntry.FullPath, string.Empty, e.GetType());
}
}
}
}
return(rarArchive);
}
public static void TestRar3()
{
var archive = RarArchive.Open(@"C:\Code\sharpcompress\TestArchives\sharpcompress2.part001.rar");
foreach (var entry in archive.Entries)
{
Console.WriteLine(entry.FilePath);
entry.WriteToDirectory(@"C:\temp", ExtractOptions.ExtractFullPath | ExtractOptions.Overwrite);
}
}
private void ReadRarArchive(string localPath)
{
using (RarArchive ra = RarArchive.Open(localPath))
{
foreach (RarArchiveEntry entry in ra.Entries)
{
PopulateSelfList(entry);
}
}
}
