public static ReturnCode DecompressSource7ZipFile(RvFile zZipFileIn, bool includeGood, out string error)
{
byte[] buffer = new byte[BufferSize];
RvFile cacheDir = DB.RvFileCache();
string fileNameIn = zZipFileIn.FullName;
SevenZ zipFileIn = new SevenZ();
ZipReturn zr1 = zipFileIn.ZipFileOpen(fileNameIn, zZipFileIn.TimeStamp, true);
if (zr1 != ZipReturn.ZipGood)
{
error = "Error opening 7zip file for caching";
return(ReturnCode.RescanNeeded);
}
RvFile outDir = new RvFile(FileType.Dir)
{
Name = zZipFileIn.Name + ".cache",
Parent = cacheDir,
DatStatus = DatStatus.InToSort,
GotStatus = GotStatus.Got
};
int nameDirIndex = 0;
while (cacheDir.ChildNameSearch(outDir, out int index) == 0)
{
nameDirIndex++;
outDir.Name = zZipFileIn.Name + ".cache (" + nameDirIndex + ")";
}
cacheDir.ChildAdd(outDir);
Directory.CreateDirectory(outDir.FullName);
for (int i = 0; i < zipFileIn.LocalFilesCount(); i++)
{
if (zZipFileIn.Child(i).IsDir)
{
continue;
}
RvFile thisFile = null;
for (int j = 0; j < zZipFileIn.ChildCount; j++)
{
if (zZipFileIn.Child(j).ZipFileIndex != i)
{
continue;
}
thisFile = zZipFileIn.Child(j);
break;
}
if (thisFile == null)
{
error = "Error opening 7zip file for caching";
return(ReturnCode.RescanNeeded);
}
bool extract = true;
// first check to see if we have a file version of this compressed file somewhere else.
foreach (RvFile f in thisFile.FileGroup.Files)
{
if (f.FileType == FileType.File && f.GotStatus == GotStatus.Got)
{
extract = false;
}
}
if (!extract)
{
continue;
}
extract = false;
if (includeGood)
{
// if this is the file we are fixing then pull out the correct files.
if (thisFile.RepStatus == RepStatus.Correct)
{
extract = true;
}
}
// next check to see if we need this extracted to fix another file
foreach (RvFile f in thisFile.FileGroup.Files)
{
if (f.RepStatus == RepStatus.CanBeFixed)
{
extract = true;
break;
}
}
if (!extract)
{
continue;
}
string cleanedName = thisFile.Name;
cleanedName = cleanedName.Replace("/", "-");
cleanedName = cleanedName.Replace("\\", "-");
RvFile outFile = new RvFile(FileType.File)
{
Name = cleanedName,
Size = thisFile.Size,
CRC = thisFile.CRC,
SHA1 = thisFile.SHA1,
MD5 = thisFile.MD5,
HeaderFileType = thisFile.HeaderFileType,
AltSize = thisFile.AltSize,
AltCRC = thisFile.AltCRC,
AltSHA1 = thisFile.AltSHA1,
AltMD5 = thisFile.AltMD5,
FileGroup = thisFile.FileGroup
};
outFile.SetStatus(DatStatus.InToSort, GotStatus.Got);
outFile.FileStatusSet(
FileStatus.HeaderFileTypeFromHeader |
FileStatus.SizeFromHeader | FileStatus.SizeVerified |
FileStatus.CRCFromHeader | FileStatus.CRCVerified |
FileStatus.SHA1FromHeader | FileStatus.SHA1Verified |
FileStatus.MD5FromHeader | FileStatus.MD5Verified |
FileStatus.AltSizeFromHeader | FileStatus.AltSizeVerified |
FileStatus.AltCRCFromHeader | FileStatus.AltCRCVerified |
FileStatus.AltSHA1FromHeader | FileStatus.AltSHA1Verified |
FileStatus.AltMD5FromHeader | FileStatus.AltMD5Verified
, thisFile);
outFile.RepStatus = RepStatus.NeededForFix;
zipFileIn.ZipFileOpenReadStream(i, out Stream readStream, out ulong unCompressedSize);
string filenameOut = Path.Combine(outDir.FullName, outFile.Name);
ThreadMD5 tmd5 = null;
ThreadSHA1 tsha1 = null;
ThreadCRC tcrc32 = new ThreadCRC();
if (Settings.rvSettings.FixLevel != EFixLevel.Level1 && Settings.rvSettings.FixLevel != EFixLevel.TrrntZipLevel1)
{
tmd5 = new ThreadMD5();
tsha1 = new ThreadSHA1();
}
int errorCode = FileStream.OpenFileWrite(filenameOut, out Stream writeStream);
ulong sizetogo = unCompressedSize;
while (sizetogo > 0)
{
int sizenow = sizetogo > BufferSize ? BufferSize : (int)sizetogo;
try
{
readStream.Read(buffer, 0, sizenow);
}
catch (Exception ex)
{
if (ex is ZlibException || ex is DataErrorException)
{
ZipReturn zr = zipFileIn.ZipFileCloseReadStream();
if (zr != ZipReturn.ZipGood)
{
error = "Error Closing " + zr + " Stream :" + zipFileIn.ZipFilename;
return(ReturnCode.FileSystemError);
}
zipFileIn.ZipFileClose();
writeStream.Flush();
writeStream.Close();
if (filenameOut != null)
{
File.Delete(filenameOut);
}
thisFile.GotStatus = GotStatus.Corrupt;
error = "Unexpected corrupt archive file found:\n" + zZipFileIn.FullName +
"\nRun Find Fixes, and Fix to continue fixing correctly.";
return(ReturnCode.SourceDataStreamCorrupt);
}
error = "Error reading Source File " + ex.Message;
return(ReturnCode.FileSystemError);
}
tcrc32.Trigger(buffer, sizenow);
tmd5?.Trigger(buffer, sizenow);
tsha1?.Trigger(buffer, sizenow);
tcrc32.Wait();
tmd5?.Wait();
tsha1?.Wait();
try
{
writeStream.Write(buffer, 0, sizenow);
}
catch (Exception e)
{
error = "Error writing out file. " + Environment.NewLine + e.Message;
return(ReturnCode.FileSystemError);
}
sizetogo = sizetogo - (ulong)sizenow;
}
writeStream.Flush();
writeStream.Close();
writeStream.Dispose();
tcrc32.Finish();
tmd5?.Finish();
tsha1?.Finish();
byte[] bCRC = tcrc32.Hash;
byte[] bMD5 = tmd5?.Hash;
byte[] bSHA1 = tsha1?.Hash;
tcrc32.Dispose();
tmd5?.Dispose();
tsha1?.Dispose();
FileInfo fi = new FileInfo(filenameOut);
outFile.TimeStamp = fi.LastWriteTime;
if (bCRC != null && thisFile.CRC != null && !ArrByte.BCompare(bCRC, thisFile.CRC))
{
// error in file.
}
if (bMD5 != null && thisFile.MD5 != null && !ArrByte.BCompare(bMD5, thisFile.MD5))
{
// error in file.
}
if (bSHA1 != null && thisFile.SHA1 != null && !ArrByte.BCompare(bSHA1, thisFile.SHA1))
{
// error in file.
}
thisFile.FileGroup.Files.Add(outFile);
outDir.ChildAdd(outFile);
}
zipFileIn.ZipFileClose();
error = "";
return(ReturnCode.Good);
}
/// <inheritdoc/>
public override bool CopyAll(string outDir)
{
bool encounteredErrors = true;
try
{
// Create the temp directory
Directory.CreateDirectory(outDir);
// Extract all files to the temp directory
SevenZ zf = new SevenZ();
ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
if (zr != ZipReturn.ZipGood)
{
throw new Exception(ZipUtils.ZipErrorMessageText(zr));
}
for (int i = 0; i < zf.LocalFilesCount() && zr == ZipReturn.ZipGood; i++)
{
// Open the read stream
zr = zf.ZipFileOpenReadStream(i, out Stream readStream, out ulong streamsize);
// Create the rest of the path, if needed
if (!string.IsNullOrWhiteSpace(Path.GetDirectoryName(zf.Filename(i))))
{
Directory.CreateDirectory(Path.Combine(outDir, Path.GetDirectoryName(zf.Filename(i))));
}
// If the entry ends with a directory separator, continue to the next item, if any
if (zf.Filename(i).EndsWith(Path.DirectorySeparatorChar.ToString()) ||
zf.Filename(i).EndsWith(Path.AltDirectorySeparatorChar.ToString()) ||
zf.Filename(i).EndsWith(Path.PathSeparator.ToString()))
{
zf.ZipFileCloseReadStream();
continue;
}
FileStream writeStream = File.Create(Path.Combine(outDir, zf.Filename(i)));
// If the stream is smaller than the buffer, just run one loop through to avoid issues
if (streamsize < _bufferSize)
{
byte[] ibuffer = new byte[streamsize];
int ilen = readStream.Read(ibuffer, 0, (int)streamsize);
writeStream.Write(ibuffer, 0, ilen);
writeStream.Flush();
}
// Otherwise, we do the normal loop
else
{
int realBufferSize = (streamsize < _bufferSize ? (int)streamsize : _bufferSize);
byte[] ibuffer = new byte[realBufferSize];
int ilen;
while ((ilen = readStream.Read(ibuffer, 0, realBufferSize)) > 0)
{
writeStream.Write(ibuffer, 0, ilen);
writeStream.Flush();
}
}
zr = zf.ZipFileCloseReadStream();
writeStream.Dispose();
}
zf.ZipFileClose();
encounteredErrors = false;
}
catch (EndOfStreamException ex)
{
// Catch this but don't count it as an error because SharpCompress is unsafe
logger.Verbose(ex);
}
catch (InvalidOperationException ex)
{
logger.Warning(ex);
encounteredErrors = true;
}
catch (Exception ex)
{
logger.Error(ex);
encounteredErrors = true;
}
return(encounteredErrors);
}
/// <inheritdoc/>
public override List <BaseFile> GetChildren()
{
List <BaseFile> found = new List <BaseFile>();
string gamename = Path.GetFileNameWithoutExtension(this.Filename);
try
{
SevenZ zf = new SevenZ();
ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
if (zr != ZipReturn.ZipGood)
{
throw new Exception(ZipUtils.ZipErrorMessageText(zr));
}
for (int i = 0; i < zf.LocalFilesCount(); i++)
{
// If the entry is a directory (or looks like a directory), we don't want to open it
if (zf.IsDirectory(i) ||
zf.Filename(i).EndsWith(Path.DirectorySeparatorChar.ToString()) ||
zf.Filename(i).EndsWith(Path.AltDirectorySeparatorChar.ToString()) ||
zf.Filename(i).EndsWith(Path.PathSeparator.ToString()))
{
continue;
}
// Open the read stream
zr = zf.ZipFileOpenReadStream(i, out Stream readStream, out ulong streamsize);
// If we get a read error, log it and continue
if (zr != ZipReturn.ZipGood)
{
logger.Warning($"An error occurred while reading archive {this.Filename}: Zip Error - {zr}");
zr = zf.ZipFileCloseReadStream();
continue;
}
// Create a blank item for the entry
BaseFile zipEntryRom = new BaseFile();
// Perform a quickscan, if flagged to
if (this.AvailableHashes == Hash.CRC)
{
zipEntryRom.Size = (long)zf.UncompressedSize(i);
zipEntryRom.CRC = zf.CRC32(i);
}
// Otherwise, use the stream directly
else
{
zipEntryRom = GetInfo(readStream, size: (long)zf.UncompressedSize(i), hashes: this.AvailableHashes, keepReadOpen: true);
}
// Fill in comon details and add to the list
zipEntryRom.Filename = zf.Filename(i);
zipEntryRom.Parent = gamename;
found.Add(zipEntryRom);
}
// Dispose of the archive
zr = zf.ZipFileCloseReadStream();
zf.ZipFileClose();
}
catch (Exception ex)
{
logger.Error(ex);
return(null);
}
return(found);
}
/// <inheritdoc/>
public override bool Write(Stream inputStream, string outDir, BaseFile baseFile)
{
bool success = false;
string tempFile = Path.Combine(outDir, $"tmp{Guid.NewGuid()}");
// If either input is null or empty, return
if (inputStream == null || baseFile == null || baseFile.Filename == null)
{
return(success);
}
// If the stream is not readable, return
if (!inputStream.CanRead)
{
return(success);
}
// Seek to the beginning of the stream
inputStream.Seek(0, SeekOrigin.Begin);
// Get the output archive name from the first rebuild rom
string archiveFileName = Path.Combine(outDir, Utilities.RemovePathUnsafeCharacters(baseFile.Parent) + (baseFile.Parent.EndsWith(".7z") ? string.Empty : ".7z"));
// Set internal variables
Stream writeStream = null;
SevenZ oldZipFile = new SevenZ();
SevenZ zipFile = new SevenZ();
ZipReturn zipReturn = ZipReturn.ZipGood;
try
{
// If the full output path doesn't exist, create it
if (!Directory.Exists(Path.GetDirectoryName(archiveFileName)))
{
Directory.CreateDirectory(Path.GetDirectoryName(archiveFileName));
}
// If the archive doesn't exist, create it and put the single file
if (!File.Exists(archiveFileName))
{
inputStream.Seek(0, SeekOrigin.Begin);
zipReturn = zipFile.ZipFileCreate(tempFile);
// Open the input file for reading
ulong istreamSize = (ulong)(inputStream.Length);
DateTime dt = DateTime.Now;
if (UseDates && !string.IsNullOrWhiteSpace(baseFile.Date) && DateTime.TryParse(baseFile.Date.Replace('\\', '/'), out dt))
{
long msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(dt);
TimeStamps ts = new TimeStamps {
ModTime = msDosDateTime
};
zipFile.ZipFileOpenWriteStream(false, false, baseFile.Filename.Replace('\\', '/'), istreamSize, 0, out writeStream, ts);
}
else
{
zipFile.ZipFileOpenWriteStream(false, true, baseFile.Filename.Replace('\\', '/'), istreamSize, 0, out writeStream, null);
}
// Copy the input stream to the output
byte[] ibuffer = new byte[_bufferSize];
int ilen;
while ((ilen = inputStream.Read(ibuffer, 0, _bufferSize)) > 0)
{
writeStream.Write(ibuffer, 0, ilen);
writeStream.Flush();
}
zipFile.ZipFileCloseWriteStream(baseFile.CRC);
}
// Otherwise, sort the input files and write out in the correct order
else
{
// Open the old archive for reading
oldZipFile.ZipFileOpen(archiveFileName, -1, true);
// Map all inputs to index
Dictionary <string, int> inputIndexMap = new Dictionary <string, int>();
var oldZipFileContents = new List <string>();
for (int i = 0; i < oldZipFile.LocalFilesCount(); i++)
{
oldZipFileContents.Add(oldZipFile.Filename(i));
}
// If the old one doesn't contain the new file, then add it
if (!oldZipFileContents.Contains(baseFile.Filename.Replace('\\', '/')))
{
inputIndexMap.Add(baseFile.Filename.Replace('\\', '/'), -1);
}
// Then add all of the old entries to it too
for (int i = 0; i < oldZipFile.LocalFilesCount(); i++)
{
inputIndexMap.Add(oldZipFile.Filename(i), i);
}
// If the number of entries is the same as the old archive, skip out
if (inputIndexMap.Keys.Count <= oldZipFile.LocalFilesCount())
{
success = true;
return(success);
}
// Otherwise, process the old zipfile
zipFile.ZipFileCreate(tempFile);
// Get the order for the entries with the new file
List <string> keys = inputIndexMap.Keys.ToList();
keys.Sort(ZipUtils.TrrntZipStringCompare);
// Copy over all files to the new archive
foreach (string key in keys)
{
// Get the index mapped to the key
int index = inputIndexMap[key];
// If we have the input file, add it now
if (index < 0)
{
// Open the input file for reading
ulong istreamSize = (ulong)(inputStream.Length);
DateTime dt = DateTime.Now;
if (UseDates && !string.IsNullOrWhiteSpace(baseFile.Date) && DateTime.TryParse(baseFile.Date.Replace('\\', '/'), out dt))
{
long msDosDateTime = Utilities.ConvertDateTimeToMsDosTimeFormat(dt);
TimeStamps ts = new TimeStamps {
ModTime = msDosDateTime
};
zipFile.ZipFileOpenWriteStream(false, false, baseFile.Filename.Replace('\\', '/'), istreamSize, 0, out writeStream, ts);
}
else
{
zipFile.ZipFileOpenWriteStream(false, true, baseFile.Filename.Replace('\\', '/'), istreamSize, 0, out writeStream, null);
}
// Copy the input stream to the output
byte[] ibuffer = new byte[_bufferSize];
int ilen;
while ((ilen = inputStream.Read(ibuffer, 0, _bufferSize)) > 0)
{
writeStream.Write(ibuffer, 0, ilen);
writeStream.Flush();
}
zipFile.ZipFileCloseWriteStream(baseFile.CRC);
}
// Otherwise, copy the file from the old archive
else
{
// Instantiate the streams
oldZipFile.ZipFileOpenReadStream(index, out Stream zreadStream, out ulong istreamSize);
zipFile.ZipFileOpenWriteStream(false, true, oldZipFile.Filename(index), istreamSize, 0, out writeStream, null);
// Copy the input stream to the output
byte[] ibuffer = new byte[_bufferSize];
int ilen;
while ((ilen = zreadStream.Read(ibuffer, 0, _bufferSize)) > 0)
{
writeStream.Write(ibuffer, 0, ilen);
writeStream.Flush();
}
oldZipFile.ZipFileCloseReadStream();
zipFile.ZipFileCloseWriteStream(oldZipFile.CRC32(index));
}
}
}
// Close the output zip file
zipFile.ZipFileClose();
oldZipFile.ZipFileClose();
success = true;
}
catch (Exception ex)
{
logger.Error(ex);
success = false;
}
finally
{
}
// If the old file exists, delete it and replace
if (File.Exists(archiveFileName))
{
File.Delete(archiveFileName);
}
File.Move(tempFile, archiveFileName);
return(true);
}
/// <inheritdoc/>
public override (MemoryStream, string) CopyToStream(string entryName)
{
MemoryStream ms = new MemoryStream();
string realEntry = null;
try
{
SevenZ zf = new SevenZ();
ZipReturn zr = zf.ZipFileOpen(this.Filename, -1, true);
if (zr != ZipReturn.ZipGood)
{
throw new Exception(ZipUtils.ZipErrorMessageText(zr));
}
for (int i = 0; i < zf.LocalFilesCount() && zr == ZipReturn.ZipGood; i++)
{
if (zf.Filename(i).Contains(entryName))
{
// Open the read stream
realEntry = zf.Filename(i);
zr = zf.ZipFileOpenReadStream(i, out Stream readStream, out ulong streamsize);
// If the stream is smaller than the buffer, just run one loop through to avoid issues
if (streamsize < _bufferSize)
{
byte[] ibuffer = new byte[streamsize];
int ilen = readStream.Read(ibuffer, 0, (int)streamsize);
ms.Write(ibuffer, 0, ilen);
ms.Flush();
}
// Otherwise, we do the normal loop
else
{
byte[] ibuffer = new byte[_bufferSize];
int ilen;
while (streamsize > _bufferSize)
{
ilen = readStream.Read(ibuffer, 0, _bufferSize);
ms.Write(ibuffer, 0, ilen);
ms.Flush();
streamsize -= _bufferSize;
}
ilen = readStream.Read(ibuffer, 0, (int)streamsize);
ms.Write(ibuffer, 0, ilen);
ms.Flush();
}
zr = zf.ZipFileCloseReadStream();
}
}
zf.ZipFileClose();
}
catch (Exception ex)
{
logger.Error(ex);
ms = null;
realEntry = null;
}
return(ms, realEntry);
}
