public ZipContainer(SevenZipExtractor zip, ArchiveFileInfo entry, ZipContainer parent)
{
_name = entry.FileName;
_entry = entry;
Zip = zip;
_parent = parent;
}
internal ArchiveEntry(ArchiveFileInfo archiveEntry, string archivePath, InArchiveFormat archiveFormat)
{
Index = (uint) archiveEntry.Index;
Path = archiveEntry.FileName;
Size = archiveEntry.Size;
Name = System.IO.Path.GetFileName(archiveEntry.FileName);
CompressedSize = 0; // Not supported in SevenZipSharp (yet)
ModifiedDate = archiveEntry.LastWriteTime;
IsEncrypted = archiveEntry.Encrypted;
IsFolder = archiveEntry.IsDirectory;
ArchivePath = archivePath;
Format = archiveFormat;
CRC = archiveEntry.Crc;
}
private IEnumerable<ArchiveFileInfo> GetArchiveFileInfos()
{
var archives = new ArchiveFileInfo[(AdditionalArgs.Count + 1) / 3];
for (int i = 0; i < archives.Length; i++)
{
archives[i] = new ArchiveFileInfo
{
Path = Path.GetFullPath(AdditionalArgs[i * 3 + 1]),
SubDir = (AdditionalArgs.Count > i * 3 + 2) ? AdditionalArgs[i * 3 + 2] : null,
MimeType = (AdditionalArgs.Count > i * 3 + 3) ? AdditionalArgs[i * 3 + 3] : Archive.GuessMimeType(AdditionalArgs[i * 3 + 1])
};
}
return archives;
}
public void ReplaceFile(ArchiveFileInfo afi, Stream fileData)
{
afi.SetFileData(fileData);
}
public bool DeleteFile(ArchiveFileInfo archiveFileInfo)
{
files.Remove((APAKFileInfo)archiveFileInfo);
return(true);
}
/// <inheritdoc />
public Task <LoadResult> LoadFile(IStateInfo stateInfo, ArchiveFileInfo afi, Guid pluginId)
{
return(LoadFile(stateInfo, afi, pluginId, new LoadFileContext()));
}
/// <inheritdoc />
public Task <LoadResult> LoadFile(IStateInfo stateInfo, ArchiveFileInfo afi, Guid pluginId, LoadFileContext loadFileContext)
{
return(_parentPluginManager.LoadFile(stateInfo, afi, pluginId, loadFileContext));
}
private FileSystemNode GetContent(ArchiveFileInfo entry)
{
if(Path.GetExtension(entry.FileName) == ".zip" || Path.GetExtension(entry.FileName) == ".7z")
{
// extract the embedded zip and create a new zip container for it with a reference to the parent.
// if we need to we'll leave the contents un-extracted so we can extract that at will later
return new ZipContainer(new SevenZipExtractor(ExtractEntry(Zip, entry)), entry, this);
}
return new ZipContent(Zip, entry);
}
/// <summary>
/// Retrieves all information about the archive.
/// </summary>
/// <exception cref="SevenZip.SevenZipArchiveException"/>
private void GetArchiveInfo(bool disposeStream)
{
if (_archive == null)
{
if (!ThrowException(null, new SevenZipArchiveException()))
{
return;
}
}
else
{
IInStream archiveStream;
using ((archiveStream = GetArchiveStream(disposeStream)) as IDisposable)
{
var openCallback = GetArchiveOpenCallback();
if (!_opened)
{
if (!OpenArchive(archiveStream, openCallback))
{
return;
}
_opened = !disposeStream;
}
_filesCount = _archive.GetNumberOfItems();
_archiveFileData = new List<ArchiveFileInfo>((int)_filesCount);
if (_filesCount != 0)
{
var data = new PropVariant();
try
{
#region Getting archive items data
for (uint i = 0; i < _filesCount; i++)
{
try
{
var fileInfo = new ArchiveFileInfo { Index = (int)i };
_archive.GetProperty(i, ItemPropId.Path, ref data);
fileInfo.FileName = NativeMethods.SafeCast(data, "[no name]");
_archive.GetProperty(i, ItemPropId.LastWriteTime, ref data);
fileInfo.LastWriteTime = NativeMethods.SafeCast(data, DateTime.Now);
_archive.GetProperty(i, ItemPropId.CreationTime, ref data);
fileInfo.CreationTime = NativeMethods.SafeCast(data, DateTime.Now);
_archive.GetProperty(i, ItemPropId.LastAccessTime, ref data);
fileInfo.LastAccessTime = NativeMethods.SafeCast(data, DateTime.Now);
_archive.GetProperty(i, ItemPropId.Size, ref data);
fileInfo.Size = NativeMethods.SafeCast<ulong>(data, 0);
if (fileInfo.Size == 0)
{
fileInfo.Size = NativeMethods.SafeCast<uint>(data, 0);
}
_archive.GetProperty(i, ItemPropId.Attributes, ref data);
fileInfo.Attributes = NativeMethods.SafeCast<uint>(data, 0);
_archive.GetProperty(i, ItemPropId.IsDirectory, ref data);
fileInfo.IsDirectory = NativeMethods.SafeCast(data, false);
_archive.GetProperty(i, ItemPropId.Encrypted, ref data);
fileInfo.Encrypted = NativeMethods.SafeCast(data, false);
_archive.GetProperty(i, ItemPropId.Crc, ref data);
fileInfo.Crc = NativeMethods.SafeCast<uint>(data, 0);
_archive.GetProperty(i, ItemPropId.Comment, ref data);
fileInfo.Comment = NativeMethods.SafeCast(data, "");
_archiveFileData.Add(fileInfo);
}
catch (InvalidCastException)
{
ThrowException(null, new SevenZipArchiveException("probably archive is corrupted."));
}
}
#endregion
#region Getting archive properties
uint numProps = _archive.GetNumberOfArchiveProperties();
var archProps = new List<ArchiveProperty>((int)numProps);
for (uint i = 0; i < numProps; i++)
{
string propName;
ItemPropId propId;
ushort varType;
_archive.GetArchivePropertyInfo(i, out propName, out propId, out varType);
_archive.GetArchiveProperty(propId, ref data);
if (propId == ItemPropId.Solid)
{
_isSolid = NativeMethods.SafeCast(data, true);
}
// TODO Add more archive properties
if (PropIdToName.PropIdNames.ContainsKey(propId))
{
archProps.Add(new ArchiveProperty
{
Name = PropIdToName.PropIdNames[propId],
Value = data.Object
});
}
else
{
Debug.WriteLine(
"An unknown archive property encountered (code " +
((int)propId).ToString(CultureInfo.InvariantCulture) + ')');
}
}
_archiveProperties = new ReadOnlyCollection<ArchiveProperty>(archProps);
if (!_isSolid.HasValue && _format == InArchiveFormat.Zip)
{
_isSolid = false;
}
if (!_isSolid.HasValue)
{
_isSolid = true;
}
#endregion
}
catch (Exception)
{
if (openCallback.ThrowException())
{
throw;
}
}
}
}
if (disposeStream)
{
_archive.Close();
_archiveStream = null;
}
_archiveFileInfoCollection = new ReadOnlyCollection<ArchiveFileInfo>(_archiveFileData);
}
}
public bool AddFile(ArchiveFileInfo afi)
{
_sarc.Files.Add(afi);
return(true);
}
public void WriteFile(string filepath, bool compressNOTWORKING, ArchiveFile file, bool surpressErrors)
{
if (!_writing)
{
throw new Exception("Must call BeginWriting() before calling WriteFile()");
}
if (!_indexTable.ContainsKey(filepath))
{
if (!surpressErrors)
{
throw new FileNotFoundException("File with given path was not found in the releasemanifest");
}
Console.WriteLine("Following file was not found in the releasemanifest: {0}", filepath);
return;
}
if (!_fileTable.ContainsKey(filepath))
{
if (!surpressErrors)
{
throw new FileNotFoundException("File with given path was not found in the file table");
}
Console.WriteLine("Following file was not found: {0}", filepath);
return;
}
var archive = _fileTable[filepath];
for (int i = 0; i < archive.Count; i++)
{
// Handle archive state creation
if (!_archiveStates.ContainsKey(archive[i].FilePath))
{
var state = new ArchiveState();
state.ArchivePath = archive[i].FilePath;
state.OriginalLength = archive[i].DataLength;
state.OriginalValues = new Dictionary <string, ArchiveFileInfo>();
_archiveStates[archive[i].FilePath] = state;
}
if (!_bufferTable.ContainsKey(archive[i].FilePath))
{
_bufferTable[archive[i].FilePath] = new ArchiveWriteBuffer();
}
_bufferTable[archive[i].FilePath].WriteData(filepath, file.Data);
// Copy file info to the list of originals and then modify it
if (!_archiveStates[archive[i].FilePath].OriginalValues.ContainsKey(filepath))
{
_archiveStates[archive[i].FilePath].OriginalValues[filepath] = ArchiveFileInfo.Copy(archive[i].Files[filepath]);
}
}
// Handle manifest changes
_indexTable[filepath].Descriptor.CompressedSize = file.CompressedSize;
_indexTable[filepath].Descriptor.DecompressedSize = file.UncompressedSize;
}
public void LoadFile(ArchiveFileInfo archiveFileInfo)
{
ArchiveFileInfo = archiveFileInfo;
}
public FileSystemPath GetVirtualFilePath(ArchiveFileInfo archiveFile)
{
string path = FileSystemPath.DirectorySeparator + archiveFile.FileName.Replace(Path.DirectorySeparatorChar, FileSystemPath.DirectorySeparator);
if (archiveFile.IsDirectory && path[path.Length - 1] != FileSystemPath.DirectorySeparator)
path += FileSystemPath.DirectorySeparator;
return FileSystemPath.Parse(path);
}
public void LoadFile(ArchiveFileInfo archiveFileInfo, IArchiveFile archiveFile)
{
ArchiveFileInfo = archiveFileInfo;
ArchiveFile = archiveFile;
}
public OpenTabEventArgs(ArchiveFileInfo afi, KoreFileInfo kfi, BaseReadOnlyDirectoryNode fs)
{
Afi = afi;
Kfi = kfi;
FileSystem = fs;
}
/// <summary>
/// Extracts <see cref="Archive"/>s to the <see cref="_store"/>.
/// </summary>
/// <param name="archives">The archives to extract over each other in order.</param>
/// <param name="files">The downloaded archive files, indexes matching those in <paramref name="archives"/>.</param>
/// <param name="manifestDigest">The digest the extracted archives should produce.</param>
/// <exception cref="OperationCanceledException">An IO task was canceled from another thread.</exception>
/// <exception cref="NotSupportedException">A file format, protocal, etc. is unknown or not supported.</exception>
/// <exception cref="IOException">A downloaded file could not be written to the disk or extracted.</exception>
/// <exception cref="ImplementationAlreadyInStoreException">There is already an <see cref="Store.Model.Implementation"/> with the specified <paramref name="manifestDigest"/> in the store.</exception>
/// <exception cref="UnauthorizedAccessException">Write access to <see cref="IStore"/> is not permitted.</exception>
/// <exception cref="DigestMismatchException">An <see cref="Store.Model.Implementation"/>'s <see cref="Archive"/>s don't match the associated <see cref="ManifestDigest"/>.</exception>
private void ApplyArchives([NotNull, ItemNotNull] IList<Archive> archives, [NotNull, ItemNotNull] IList<TemporaryFile> files, ManifestDigest manifestDigest)
{
var archiveFileInfos = new ArchiveFileInfo[archives.Count];
for (int i = 0; i < archiveFileInfos.Length; i++)
{
archiveFileInfos[i] = new ArchiveFileInfo
{
Path = files[i].Path,
SubDir = archives[i].Extract,
Destination = archives[i].Destination,
MimeType = archives[i].MimeType,
StartOffset = archives[i].StartOffset,
OriginalSource = archives[i].Href
};
}
_store.AddArchives(archiveFileInfos, manifestDigest, Handler);
}
public bool AddFile(ArchiveFileInfo afi) => false;
public FileData(string srcFileName, ArchiveFileInfo fileInfo)
{
archiveFileName = srcFileName;
sevenZipFileInfo = fileInfo;
}
/// <summary>
/// Modifies the existing archive (renames files or deletes them).
/// </summary>
/// <param name="archiveName">The archive file name.</param>
/// <param name="newFileNames">New file names. Null value to delete the corresponding index.</param>
/// <param name="password">The archive password.</param>
public void ModifyArchive(string archiveName, Dictionary<int, string> newFileNames, string password
#if CS4
= ""
#endif
)
{
ClearExceptions();
if (!SevenZipLibraryManager.ModifyCapable)
{
throw new SevenZipLibraryException("The specified 7zip native library does not support this method.");
}
if (!File.Exists(archiveName))
{
if (!ThrowException(null, new ArgumentException("The specified archive does not exist.", "archiveName")))
{
return;
}
}
if (newFileNames == null || newFileNames.Count == 0)
{
if (!ThrowException(null, new ArgumentException("Invalid new file names.", "newFileNames")))
{
return;
}
}
try
{
using (var extr = new SevenZipExtractor(archiveName))
{
_updateData = new UpdateData();
var archiveData = new ArchiveFileInfo[extr.ArchiveFileData.Count];
extr.ArchiveFileData.CopyTo(archiveData, 0);
_updateData.ArchiveFileData = new List<ArchiveFileInfo>(archiveData);
}
_updateData.FileNamesToModify = newFileNames;
_updateData.Mode = InternalCompressionMode.Modify;
}
catch (SevenZipException e)
{
if (!ThrowException(null, e))
{
return;
}
}
try
{
ISequentialOutStream sequentialArchiveStream;
_compressingFilesOnDisk = true;
using ((sequentialArchiveStream = GetOutStream(GetArchiveFileStream(archiveName))) as IDisposable)
{
IInStream inArchiveStream;
_archiveName = archiveName;
using ((inArchiveStream = GetInStream()) as IDisposable)
{
IOutArchive outArchive;
// Create IInArchive, read it and convert to IOutArchive
SevenZipLibraryManager.LoadLibrary(
this, Formats.InForOutFormats[_archiveFormat]);
if ((outArchive = MakeOutArchive(inArchiveStream)) == null)
{
return;
}
using (ArchiveUpdateCallback auc = GetArchiveUpdateCallback(null, 0, password))
{
UInt32 deleteCount = 0;
if (_updateData.FileNamesToModify != null)
{
#if CS4 // System.Linq of C# 4 is great
deleteCount = (UInt32)_updateData.FileNamesToModify.Sum(
pairDeleted => pairDeleted.Value == null ? 1 : 0);
#else
foreach(var pairDeleted in _updateData.FileNamesToModify)
{
if (pairDeleted.Value == null)
{
deleteCount++;
}
}
#endif
}
try
{
CheckedExecute(
outArchive.UpdateItems(
sequentialArchiveStream, _oldFilesCount - deleteCount, auc),
SevenZipCompressionFailedException.DEFAULT_MESSAGE, auc);
}
finally
{
FreeCompressionCallback(auc);
}
}
}
}
}
finally
{
SevenZipLibraryManager.FreeLibrary(this, Formats.InForOutFormats[_archiveFormat]);
File.Delete(archiveName);
FinalizeUpdate();
_compressingFilesOnDisk = false;
_updateData.FileNamesToModify = null;
_updateData.ArchiveFileData = null;
OnEvent(CompressionFinished, EventArgs.Empty, false);
}
ThrowUserException();
}
public void FileWriteAsync(ArchiveFileInfo fileInfo, string filePath)
{
fileInfo.DecompressData(fileInfo.FileData).SaveToFile(filePath);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExtractFileCallbackArgs"/> class.
/// </summary>
/// <param name="archiveFileInfo">The information about file in the archive.</param>
public ExtractFileCallbackArgs(ArchiveFileInfo archiveFileInfo)
{
Reason = ExtractFileCallbackReason.Start;
_archiveFileInfo = archiveFileInfo;
}
/// <summary>
/// Begins the file extraction.
/// </summary>
/// <param name="file">The file within the archive.</param>
private void ExtractFile(ArchiveFileInfo file)
{
_ext = Path.Combine(Path.GetDirectoryName(_file), Path.GetFileName(file.FileName));
try
{
using (var fs = File.Create(_ext))
{
fs.Close();
}
}
catch (Exception ex)
{
Log.Warn("Failed to create new file to '" + _ext + "', retrying with temp path...", ex);
_ext = Path.Combine(Path.GetTempPath(), Path.GetFileName(file.FileName));
try
{
using (var fs = File.Create(_ext))
{
fs.Close();
}
}
catch (Exception ex2)
{
Log.Warn("Failed to create new temp file to '" + _ext + "', aborting extraction...", ex2);
TaskDialog.Show(new TaskDialogOptions
{
MainIcon = VistaTaskDialogIcon.Error,
Title = "Extraction error",
MainInstruction = "Extraction error",
Content = "Failed to create new file near archive or in the %TEMP% directory.",
AllowDialogCancellation = true,
CustomButtons = new[] { "OK" }
});
return;
}
}
_active = true;
_tdstr = "Extracting file...";
var mthd = new Thread(() => TaskDialog.Show(new TaskDialogOptions
{
Title = "Extracting...",
MainInstruction = Path.GetFileName(file.FileName),
Content = _tdstr,
CustomButtons = new[]
{
"&Run now", // ID 500
"&Cancel" // ID 501
},
ShowProgressBar = true,
EnableCallbackTimer = true,
AllowDialogCancellation = true,
Callback = (dialog, args, data) =>
{
dialog.SetProgressBarPosition(_tdpos);
dialog.SetContent(_tdstr);
if (args.ButtonId != 0)
{
if (args.ButtonId == 500)
{
if (File.Exists(_ext))
{
try { Utils.Run(_ext); } catch { }
_ran = true;
}
}
else if (args.ButtonId == 501)
{
if (_active)
{
_cancel = true;
if (!string.IsNullOrWhiteSpace(_ext) && File.Exists(_ext))
{
new Thread(() =>
{
try { _thd.Abort(); _thd = null; } catch { }
Thread.Sleep(100);
try { _fs.Close(); _fs.Dispose(); } catch { }
Thread.Sleep(100);
try { File.Delete(_ext); } catch { }
}).Start();
}
}
return(false);
}
}
if (!_active)
{
dialog.ClickButton(500);
return(false);
}
return(true);
}
}));
mthd.SetApartmentState(ApartmentState.STA);
mthd.Start();
var total = file.Size;
var last = DateTime.MinValue;
_thd = new Thread(() =>
{
using (var fs = _fs = File.Open(_ext, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
using (var archive = new SevenZipExtractor(_file))
{
archive.Extracting += (sender, args) =>
{
if (_cancel)
{
args.Cancel = true;
return;
}
if (args.PercentDone == 100)
{
return;
}
if ((DateTime.Now - last).TotalMilliseconds < 150)
{
return;
}
last = DateTime.Now;
_tdpos = args.PercentDone;
_tdstr = "Extracting file: " + Utils.GetFileSize((long)Math.Round((args.PercentDone / 100d) * total)) + " / " + args.PercentDone + "% done...";
};
archive.ExtractionFinished += (sender, args) =>
{
_active = false;
if (!File.Exists(_ext))
{
return;
}
new Thread(() =>
{
if (!_ran || (_ran && !Utils.IsFileLocked(_ext)))
{
Thread.Sleep(250);
Utils.Run(_ext);
}
Thread.Sleep(10000);
AskAfterUse();
}).Start();
};
try
{
archive.ExtractFile(file.Index, fs);
}
catch (Exception ex)
{
Log.Warn("Error during file extraction.", ex);
}
}
if (_cancel && File.Exists(_ext))
{
try { File.Delete(_ext); } catch { }
}
});
_thd.Start();
}
public ZipContent(SevenZipExtractor zip, ArchiveFileInfo entry)
{
_zip = zip;
Entry = entry;
}
public bool DeleteFile(ArchiveFileInfo archiveFileInfo)
{
files.Remove((SarcEntry)archiveFileInfo);
return(true);
}
public bool DeleteFile(ArchiveFileInfo archiveFileInfo)
{
Header.Files.Remove((TMPK_Parser.FileEntry)archiveFileInfo);
return(true);
}
/// <summary>
/// Refreshes the information in this object with new data retrieved
/// from an archive.
/// </summary>
/// <param name="newFileInfo">Fresh instance for the same file just
/// read from the archive.</param>
/// <remarks>
/// This implementation refreshes the <see cref="CabinetFolderNumber"/>.
/// </remarks>
protected override void Refresh(ArchiveFileInfo newFileInfo)
{
base.Refresh(newFileInfo);
this.cabFolder = ((CabFileInfo)newFileInfo).cabFolder;
}
/// <inheritdoc />
public Task <LoadResult> LoadFile(IStateInfo stateInfo, ArchiveFileInfo afi)
{
return(_parentPluginManager.LoadFile(stateInfo, afi));
}
public bool DeleteFile(ArchiveFileInfo archiveFileInfo)
{
return(false);
}
/// <summary>
/// Initializes a new instance of the FileInfoEventArgs class.
/// </summary>
/// <param name="fileInfo">The current ArchiveFileInfo.</param>
/// <param name="percentDone">The percent of finished work.</param>
public FileInfoEventArgs(ArchiveFileInfo fileInfo, byte percentDone)
: base(percentDone)
{
_fileInfo = fileInfo;
}
private string GetFileName(ArchiveFileInfo afi)
{
if ((!_Deploy) && (afi.IsDirectory))
return null;
string path = afi.SafePath();
string TRP = TargetRelativePath(path, _Deploy);
if (TRP == null)
return null;
if (afi.IsDirectory)
{
if (_Deploy)
Directory.CreateDirectory(Path.Combine(_Root, TRP));
return null;
}
string resultDir = Path.Combine(_Root, Path.GetDirectoryName(TRP) ?? string.Empty );
if (_Deploy)
{
Directory.CreateDirectory(resultDir);
}
return FileInternalToolBox.CreateNewAvailableName(resultDir, Path.GetFileNameWithoutExtension(TRP), Path.GetExtension(TRP));
}
public bool AddFile(ArchiveFileInfo archiveFileInfo)
{
return(false);
}
public AfiFileNode(string name, ArchiveFileInfo afi) : base(name)
{
ArchiveFileInfo = afi ?? throw new ArgumentNullException(nameof(afi));
}
public bool DeleteFile(ArchiveFileInfo afi) => throw new NotSupportedException();
/// <summary>
/// Begins the file extraction.
/// </summary>
/// <param name="file">The file within the archive.</param>
private void ExtractFile(ArchiveFileInfo file)
{
_ext = Path.Combine(Path.GetDirectoryName(_file), Path.GetFileName(file.FileName));
try
{
using (var fs = File.Create(_ext))
{
fs.Close();
}
}
catch (Exception ex)
{
Log.Warn("Failed to create new file to '" + _ext + "', retrying with temp path...", ex);
_ext = Path.Combine(Path.GetTempPath(), Path.GetFileName(file.FileName));
try
{
using (var fs = File.Create(_ext))
{
fs.Close();
}
}
catch (Exception ex2)
{
Log.Warn("Failed to create new temp file to '" + _ext + "', aborting extraction...", ex2);
TaskDialog.Show(new TaskDialogOptions
{
MainIcon = VistaTaskDialogIcon.Error,
Title = "Extraction error",
MainInstruction = "Extraction error",
Content = "Failed to create new file near archive or in the %TEMP% directory.",
AllowDialogCancellation = true,
CustomButtons = new[] { "OK" }
});
return;
}
}
_active = true;
_tdstr = "Extracting file...";
var mthd = new Thread(() => TaskDialog.Show(new TaskDialogOptions
{
Title = "Extracting...",
MainInstruction = Path.GetFileName(file.FileName),
Content = _tdstr,
CustomButtons = new[]
{
"&Run now", // ID 500
"&Cancel" // ID 501
},
ShowProgressBar = true,
EnableCallbackTimer = true,
AllowDialogCancellation = true,
Callback = (dialog, args, data) =>
{
dialog.SetProgressBarPosition(_tdpos);
dialog.SetContent(_tdstr);
if (args.ButtonId != 0)
{
if (args.ButtonId == 500)
{
if (File.Exists(_ext))
{
try { Utils.Run(_ext); } catch { }
_ran = true;
}
}
else if (args.ButtonId == 501)
{
if (_active)
{
_cancel = true;
if (!string.IsNullOrWhiteSpace(_ext) && File.Exists(_ext))
{
new Thread(() =>
{
try { _thd.Abort(); _thd = null; } catch { }
Thread.Sleep(100);
try { _fs.Close(); _fs.Dispose(); } catch { }
Thread.Sleep(100);
try { File.Delete(_ext); } catch { }
}).Start();
}
}
return false;
}
}
if (!_active)
{
dialog.ClickButton(500);
return false;
}
return true;
}
}));
mthd.SetApartmentState(ApartmentState.STA);
mthd.Start();
var total = file.Size;
var last = DateTime.MinValue;
_thd = new Thread(() =>
{
using (var fs = _fs = File.Open(_ext, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
using (var archive = new SevenZipExtractor(_file))
{
archive.Extracting += (sender, args) =>
{
if (_cancel)
{
args.Cancel = true;
return;
}
if (args.PercentDone == 100)
{
return;
}
if ((DateTime.Now - last).TotalMilliseconds < 150)
{
return;
}
last = DateTime.Now;
_tdpos = args.PercentDone;
_tdstr = "Extracting file: " + Utils.GetFileSize((long)Math.Round((args.PercentDone / 100d) * total)) + " / " + args.PercentDone + "% done...";
};
archive.ExtractionFinished += (sender, args) =>
{
_active = false;
if (!File.Exists(_ext))
{
return;
}
new Thread(() =>
{
if (!_ran || (_ran && !Utils.IsFileLocked(_ext)))
{
Thread.Sleep(250);
Utils.Run(_ext);
}
Thread.Sleep(10000);
AskAfterUse();
}).Start();
};
try
{
archive.ExtractFile(file.Index, fs);
}
catch (Exception ex)
{
Log.Warn("Error during file extraction.", ex);
}
}
if (_cancel && File.Exists(_ext))
{
try { File.Delete(_ext); } catch { }
}
});
_thd.Start();
}
private static Mod AttemptLoadVirtualMod(ArchiveFileInfo sfarEntry, SevenZipExtractor archive, Mod.MEGame game, string md5)
{
var sfarPath = sfarEntry.FileName;
var cookedPath = FilesystemInterposer.DirectoryGetParent(sfarPath, true);
//Todo: Check if value is CookedPC/CookedPCConsole as further validation
if (!string.IsNullOrEmpty(FilesystemInterposer.DirectoryGetParent(cookedPath, true)))
{
var dlcDir = FilesystemInterposer.DirectoryGetParent(cookedPath, true);
var dlcFolderName = Path.GetFileName(dlcDir);
if (!string.IsNullOrEmpty(dlcFolderName))
{
var thirdPartyInfo = ThirdPartyServices.GetThirdPartyModInfo(dlcFolderName, game);
if (thirdPartyInfo != null)
{
if (thirdPartyInfo.PreventImport == false)
{
Log.Information($@"Third party mod found: {thirdPartyInfo.modname}, preparing virtual moddesc.ini");
//We will have to load a virtual moddesc. Since Mod constructor requires reading an ini, we will build and feed it a virtual one.
IniData virtualModDesc = new IniData();
virtualModDesc[@"ModManager"][@"cmmver"] = App.HighestSupportedModDesc.ToString();
virtualModDesc[@"ModManager"][@"importedby"] = App.BuildNumber.ToString();
virtualModDesc[@"ModInfo"][@"game"] = @"ME3";
virtualModDesc[@"ModInfo"][@"modname"] = thirdPartyInfo.modname;
virtualModDesc[@"ModInfo"][@"moddev"] = thirdPartyInfo.moddev;
virtualModDesc[@"ModInfo"][@"modsite"] = thirdPartyInfo.modsite;
virtualModDesc[@"ModInfo"][@"moddesc"] = thirdPartyInfo.moddesc;
virtualModDesc[@"ModInfo"][@"unofficial"] = @"true";
if (int.TryParse(thirdPartyInfo.updatecode, out var updatecode) && updatecode > 0)
{
virtualModDesc[@"ModInfo"][@"updatecode"] = updatecode.ToString();
virtualModDesc[@"ModInfo"][@"modver"] = 0.001.ToString(CultureInfo.InvariantCulture); //This will force mod to check for update after reload
}
else
{
virtualModDesc[@"ModInfo"][@"modver"] = 0.0.ToString(CultureInfo.InvariantCulture); //Will attempt to look up later after mods have parsed.
}
virtualModDesc[@"CUSTOMDLC"][@"sourcedirs"] = dlcFolderName;
virtualModDesc[@"CUSTOMDLC"][@"destdirs"] = dlcFolderName;
virtualModDesc[@"UPDATES"][@"originalarchivehash"] = md5;
var archiveSize = new FileInfo(archive.FileName).Length;
var importingInfos = ThirdPartyServices.GetImportingInfosBySize(archiveSize);
if (importingInfos.Count == 1 && importingInfos[0].GetParsedRequiredDLC().Count > 0)
{
OnlineContent.QueryModRelay(importingInfos[0].md5, archiveSize); //Tell telemetry relay we are accessing the TPIS for an existing item so it can update latest for tracking
virtualModDesc[@"ModInfo"][@"requireddlc"] = importingInfos[0].requireddlc;
}
return(new Mod(virtualModDesc.ToString(), FilesystemInterposer.DirectoryGetParent(dlcDir, true), archive));
}
//Mod is marked for preventing import
return(new Mod(false)
{
ModName = thirdPartyInfo.modname,
ModDeveloper = thirdPartyInfo.moddev,
LoadFailedReason = M3L.GetString(M3L.string_modCannotBeImportedDueToOneOfTheFollowingReasons)
});
}
else
{
Log.Information($@"No third party mod information for importing {dlcFolderName}. Should this be supported for import? Contact Mgamerz on the ME3Tweaks Discord if it should.");
}
}
}
return(null);
}
private static IEnumerable <FileData> EnumerateFiles(Stream input, string fileName,
FileFilter fileFilter, bool checkEncoding, List <string> includeSearchPatterns,
List <Regex> includeRegexPatterns, List <Regex> excludeRegexPatterns,
List <Regex> includeShebangPatterns, HashSet <string> hiddenDirectories)
{
using (SevenZipExtractor extractor = new SevenZipExtractor(input, true))
{
foreach (var fileInfo in extractor.ArchiveFileData)
{
FileData fileData = new FileData(fileName, fileInfo);
var attr = (FileAttributes)fileInfo.Attributes;
string innerFileName = fileInfo.FileName;
int index = fileInfo.Index;
if (innerFileName == "[no name]" && extractor.ArchiveFileData.Count == 1)
{
index = 0;
innerFileName = Path.GetFileNameWithoutExtension(fileName);
ArchiveFileInfo temp = Copy(fileInfo);
temp.FileName = innerFileName;
fileData = new FileData(fileName, temp);
}
if (fileInfo.IsDirectory)
{
if (!fileFilter.IncludeHidden && attr.HasFlag(FileAttributes.Hidden) &&
!hiddenDirectories.Contains(innerFileName))
{
hiddenDirectories.Add(innerFileName + Path.DirectorySeparator);
}
continue;
}
if (!fileFilter.IncludeHidden)
{
if (attr.HasFlag(FileAttributes.Hidden))
{
continue;
}
bool excludeFile = false;
foreach (string dir in hiddenDirectories)
{
if (innerFileName.StartsWith(dir))
{
excludeFile = true;
break;
}
}
if (excludeFile)
{
continue;
}
}
if (Utils.IsArchive(innerFileName))
{
using (Stream stream = new MemoryStream())
{
extractor.ExtractFile(index, stream);
var enumerator = EnumerateFiles(stream, fileName + ArchiveSeparator + innerFileName,
fileFilter, checkEncoding, includeSearchPatterns, includeRegexPatterns,
excludeRegexPatterns, includeShebangPatterns, hiddenDirectories).GetEnumerator();
while (true)
{
FileData ret = null;
try
{
if (!enumerator.MoveNext())
{
break;
}
ret = enumerator.Current;
}
catch (Exception ex)
{
string msg = string.Format(CultureInfo.CurrentCulture, "Failed to search inside archive '{0}'", fileName + ArchiveSeparator + innerFileName);
logger.Error(ex, msg);
fileData.ErrorMsg = msg + ": " + ex.Message;
ret = fileData;
}
if (ret != null)
{
yield return(ret);
}
}
}
}
else
{
if (IncludeFile(innerFileName,
fileName + ArchiveSeparator + innerFileName,
fileFilter, fileData, includeSearchPatterns,
includeRegexPatterns, excludeRegexPatterns))
{
if (NeedsIncludeFileStream(fileName, fileFilter, checkEncoding,
includeSearchPatterns, includeShebangPatterns))
{
using (Stream stream = new MemoryStream(4096))
{
extractor.ExtractFile(index, stream);
if (IncludeFileStream(stream, fileFilter, fileData,
checkEncoding, includeShebangPatterns))
{
yield return(fileData);
}
}
}
else
{
yield return(fileData);
}
}
}
if (Utils.CancelSearch)
{
break;
}
}
}
}
public bool DeleteFile(ArchiveFileInfo afi) => false;
private ToolStripItem[] GetArchiveMenus(TreeNode node, ArchiveFileInfo info)
{
return(info.FileWrapper.GetContextMenuItems());
}
private Stream ExtractEntry(SevenZipExtractor zip, ArchiveFileInfo? entry)
{
if (entry != null && zip != null)
{
var memoryStream = new MemoryStream();
ArchiveFileInfo entryValue = entry.GetValueOrDefault();
if (entryValue != null)
{
zip.ExtractFile(entryValue.Index, memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
return memoryStream;
}
}
return null;
}
/// <summary>
/// Create UploadPartRequest objects for a multipart upload.
/// </summary>
/// <param name="isNewFileUpload"></param>
/// <param name="existingBucketName"></param>
/// <param name="fileInfo"></param>
/// <param name="uploadedParts"></param>
/// <param name="partsProgress"></param>
/// <param name="token"></param>
/// <returns></returns>
public Queue <UploadPartRequest> PreparePartRequests(bool isNewFileUpload, string existingBucketName, ArchiveFileInfo fileInfo,
List <PartDetail> uploadedParts, Dictionary <int, long> partsProgress)
{
long filePosition = 0;
long partSize = PART_SIZE; // 5 MB
Queue <UploadPartRequest> partRequests = new Queue <UploadPartRequest>();
if (fileInfo.Size < partSize)
{
partSize = fileInfo.Size;
}
for (int i = 1; filePosition < fileInfo.Size; i++)
{
var uploadedPart = uploadedParts.Where(x => x.PartNumber == i).FirstOrDefault();
if (uploadedPart != null) // uploadedParts.Select(x => x.PartNumber).Contains(i))
{
// for each already uploaded part, add total part size as transferred bytes.
partsProgress.Add(i, uploadedPart.Size);
// move the file position
filePosition += uploadedPart.Size;
continue;
}
// for each NOT uploaded part, add a pair in the progress dictionary with value = 0
partsProgress.Add(i, 0);
bool isLastPart = false;
// check remaining size and if it's smalled than partSize
// then set partSize = remainingSize and this as the last part in its request.
long remainingSize = fileInfo.Size - filePosition;
if (remainingSize <= partSize)
{
isLastPart = true;
partSize = remainingSize;
}
// Create request to upload a part.
var uploadPartRequest =
CreateUploadPartRequest(existingBucketName, fileInfo.KeyName, fileInfo.UploadId, i, partSize, filePosition, fileInfo.FilePath);
// Now check if this is the last part and mark the request.
if (isLastPart)
{
uploadPartRequest.IsLastPart = true;
}
partRequests.Enqueue(uploadPartRequest);
// increment position by partSize
filePosition += partSize;
}
return(partRequests);
}
public async Task <bool> UploadMultipartFileAsync(bool isNewFileUpload, string existingBucketName, ArchiveFileInfo fileInfo,
CancellationTokenSource cts, CancellationToken token, IProgress <Tuple <string, long> > progress)
{
token.ThrowIfCancellationRequested();
_log.Debug("Called UploadMultipartFileAsync with ArchiveFileInfo properties: KeyName = \"" + fileInfo.KeyName +
"\", FilePath = \"" + fileInfo.FilePath + "\".");
bool hasException = false;
this.IsUploading = true;
List <PartDetail> uploadedParts = new List <PartDetail>();
Dictionary <int, long> multipartUploadProgress = new Dictionary <int, long>();
var uploadPartTasks = new List <Task <UploadPartResponse> >();
Queue <UploadPartRequest> partRequests = new Queue <UploadPartRequest>();
List <Task <UploadPartResponse> > runningTasks = new List <Task <UploadPartResponse> >();
try
{
token.ThrowIfCancellationRequested();
// if this isn't a new file upload (resuming a past upload)
// then we have to get the uploaded parts so the upload continues
// where it's stopped.
if (!isNewFileUpload)
{
uploadedParts = await this.ListPartsAsync(existingBucketName, fileInfo.KeyName, fileInfo.UploadId, token).ConfigureAwait(false);
}
token.ThrowIfCancellationRequested();
// create all part requests.
partRequests = this.PreparePartRequests(isNewFileUpload, existingBucketName, fileInfo, uploadedParts, multipartUploadProgress);
token.ThrowIfCancellationRequested();
var parallelLimit = (MAX_PARALLEL_ALLOWED > 1) ? MAX_PARALLEL_ALLOWED : 2;
// initialize first tasks to run.
while (runningTasks.Count < parallelLimit && partRequests.Count > 0)
{
var uploadTask = this.UploadPartAsync(partRequests.Dequeue(), multipartUploadProgress, token, progress);
runningTasks.Add(uploadTask);
}
while (runningTasks.Count > 0)
{
token.ThrowIfCancellationRequested();
var finishedTask = await Task <UploadPartResponse> .WhenAny(runningTasks).ConfigureAwait(false);
runningTasks.Remove(finishedTask);
if (finishedTask.Status == TaskStatus.Faulted)
{
throw finishedTask.Exception;
}
if (partRequests.Count > 0)
{
token.ThrowIfCancellationRequested();
var uploadTask = this.UploadPartAsync(partRequests.Dequeue(), multipartUploadProgress, token, progress);
runningTasks.Add(uploadTask);
}
finishedTask = null;
}
token.ThrowIfCancellationRequested();
// if all goes well, return true
return(true);
}
catch (Exception)
{
hasException = true;
partRequests.Clear();
runningTasks.Clear();
multipartUploadProgress.Clear();
uploadedParts.Clear();
uploadPartTasks.Clear();
throw;
}
finally
{
if (hasException && cts != null && !cts.IsCancellationRequested)
{
cts.Cancel();
}
uploadedParts.Clear();
multipartUploadProgress.Clear();
uploadPartTasks.Clear();
partRequests.Clear();
runningTasks.Clear();
this.IsUploading = false;
}
}
public bool AddFile(ArchiveFileInfo archiveFileInfo)
{
//First we need to determine the paths
string fullPath = archiveFileInfo.FileName.Replace("\\", "/");
string filePath = Path.GetFileName(fullPath);
string filePathNoExt = Path.GetFileNameWithoutExtension(fullPath);
string directoryPath = Path.GetDirectoryName(fullPath).Replace("\\", "/");
ulong fullPathHash = 0;
ulong directoryHash = 0;
ulong fileHash = 0;
//Calculate hashes for each one
//Check for full path hashes
if (fullPath.Contains("[FullHash="))
{
string HashString = fullPath.Split('=').LastOrDefault().Replace("]", string.Empty);
HashString = Path.GetFileNameWithoutExtension(HashString);
filePath = filePath.Split('[').FirstOrDefault();
TryParseHex(HashString, out fullPathHash);
}
ulong hash = 0;
bool isDirectoryHash = TryParseHex(directoryPath, out hash);
bool isFileHash = TryParseHex(filePath, out hash);
if (isFileHash)
{
TryParseHex(filePath, out fileHash);
}
else
{
fileHash = FNV64A1.Calculate(filePath);
}
if (isDirectoryHash)
{
TryParseHex(directoryPath, out directoryHash);
}
else
{
directoryHash = FNV64A1.Calculate($"{directoryPath}/");
}
if (!isFileHash && !isDirectoryHash)
{
fullPathHash = FNV64A1.Calculate(fullPath);
}
var folder = folders.FirstOrDefault(x => x.hash == directoryHash);
Console.WriteLine($"{fullPath} FilePathHash {fullPathHash}");
Console.WriteLine($"{directoryPath} FolderHash {directoryHash} directoryHash {directoryHash}");
Console.WriteLine($"{filePath} fileHash {fileHash} isFileHash {isFileHash}");
if (folder != null)
{
folder.hashes.Add(new HashIndex()
{
hash = fileHash,
Parent = folder,
Index = files.Count,
});
}
else
{
folder = new Folder();
folder.hash = directoryHash;
folder.hashes.Add(new HashIndex()
{
hash = fileHash,
Parent = folder,
Index = files.Count,
});
folders.Add(folder);
}
files.Add(new FileEntry(this)
{
FilePathHash = fullPathHash,
FolderHash = folder.hashes.LastOrDefault(),
FileData = archiveFileInfo.FileData,
FileDataStream = archiveFileInfo.FileDataStream,
FileName = archiveFileInfo.FileName,
});
return(true);
}
/// <summary>
/// Initializes a new instance of the FileInfoEventArgs class.
/// </summary>
/// <param name="fileInfo">The current ArchiveFileInfo.</param>
/// <param name="percentDone">The percent of finished work.</param>
public FileInfoEventArgs(ArchiveFileInfo fileInfo, byte percentDone)
: base(percentDone)
{
_fileInfo = fileInfo;
}
/// <inheritdoc />
public Task <LoadResult> LoadFile(IStateInfo stateInfo, ArchiveFileInfo afi, LoadFileContext loadFileContext)
{
return(LoadFile(stateInfo, afi, Guid.Empty, loadFileContext));
}
/// <summary>
/// Refreshes the information in this object with new data retrieved
/// from an archive.
/// </summary>
/// <param name="newFileInfo">Fresh instance for the same file just
/// read from the archive.</param>
/// <remarks>
/// This implementation refreshes the <see cref="CabinetFolderNumber"/>.
/// </remarks>
protected override void Refresh(ArchiveFileInfo newFileInfo)
{
base.Refresh(newFileInfo);
this.cabFolder = ((CabFileInfo) newFileInfo).cabFolder;
}
ArchiveInfo(ArchiveFileInfo archfileinfo)
{
afile = archfileinfo;
}
