public void MigrateZip()
{
TorrentZip tz = new TorrentZip
{
StatusCallBack = TzStatusCallBack,
StatusLogCallBack = TzStatusLogCallBack,
ThreadId = ThreadId
};
int fileId = 0;
string filename = null;
// get the first file
GetNextFileCallBack?.Invoke(ThreadId, out fileId, out filename);
while (!string.IsNullOrEmpty(filename))
{
FileInfo fi = new FileInfo(filename);
TrrntZipStatus trrntZipFileStatus = tz.Process(fi);
SetFileStatusCallBack?.Invoke(ThreadId, fileId, trrntZipFileStatus);
// get the next file
GetNextFileCallBack?.Invoke(ThreadId, out fileId, out filename);
}
}
private TrrntZipStatus OpenZip(IO.FileInfo fi, out ICompress zipFile)
{
string ext = Path.GetExtension(fi.Name);
if (ext == ".7z")
{
zipFile = new SevenZ();
}
else
{
zipFile = new ZipFile();
}
ZipReturn zr = zipFile.ZipFileOpen(fi.FullName, fi.LastWriteTime, true);
if (zr != ZipReturn.ZipGood)
{
return(TrrntZipStatus.CorruptZip);
}
TrrntZipStatus tzStatus = TrrntZipStatus.Unknown;
// first check if the file is a trrntip files
if (zipFile.ZipStatus == ZipStatus.TrrntZip)
{
tzStatus |= TrrntZipStatus.ValidTrrntzip;
}
return(tzStatus);
}
public void MigrateZip()
{
TorrentZip tz = new TorrentZip
{
StatusCallBack = StatusCallBack,
StatusLogCallBack = null,
ThreadId = ThreadId
};
Debug.WriteLine($"Thread {ThreadId} Starting Up");
foreach (cFile file in bcCfile.GetConsumingEnumerable(CancellationToken.None))
{
if (pauseCancel.Cancelled)
{
continue;
}
pauseCancel.WaitOne();
ProcessFileStartCallBack?.Invoke(ThreadId, file.fileId, file.filename);
Debug.WriteLine($"Thread {ThreadId} Starting to Process File {file.filename}");
FileInfo fileInfo = new FileInfo(file.filename);
TrrntZipStatus trrntZipFileStatus = tz.Process(fileInfo, pauseCancel);
ProcessFileEndCallBack?.Invoke(ThreadId, file.fileId, trrntZipFileStatus);
Debug.WriteLine($"Thread {ThreadId} Finished Process File {file.filename}");
}
Debug.WriteLine($"Thread {ThreadId} Finished");
}
private void ProcessFileEndCallback(int processId, int fileId, TrrntZipStatus trrntZipStatus)
{
if (InvokeRequired)
{
BeginInvoke(new ProcessFileEndCallback(ProcessFileEndCallback), processId, fileId, trrntZipStatus);
return;
}
if (processId == -1)
{
scanningForFiles = false;
if (FileCount == 0)
{
StopWorking();
}
}
else
{
_threads[processId].tProgress = 100;
if ((fileId + 1) > tGridMax)
{
tGridMax = (fileId + 1);
}
dGrid tGridn = new dGrid()
{
fileId = fileId, filename = null
};
switch (trrntZipStatus)
{
case TrrntZipStatus.ValidTrrntzip:
tGridn.status = "Valid TrrntZip";
break;
case TrrntZipStatus.Trrntzipped:
tGridn.status = "TrrntZipped";
break;
default:
tGridn.status = trrntZipStatus.ToString();
break;
}
tGrid.Add(tGridn);
if (!scanningForFiles && (fileId + 1) == FileCount)
{
StopWorking();
}
}
}
private void SetFileStatusCallback(int processId, int fileId, TrrntZipStatus trrntZipStatus)
{
if (InvokeRequired)
{
BeginInvoke(new SetFileStatusCallback(SetFileStatusCallback), processId, fileId, trrntZipStatus);
return;
}
switch (trrntZipStatus)
{
case TrrntZipStatus.ValidTrrntzip:
dataGrid.Rows[fileId].Cells[1].Value = "Valid RV ZIP";
break;
default:
dataGrid.Rows[fileId].Cells[1].Value = trrntZipStatus;
break;
}
}
public TrrntZipStatus Process(FileInfo fi)
{
if (Program.VerboseLogging)
{
StatusLogCallBack?.Invoke(ThreadID, "");
}
StatusLogCallBack?.Invoke(ThreadID, fi.Name + " - ");
// First open the zip (7z) file, and fail out if it is corrupt.
ICompress zipFile;
TrrntZipStatus tzs = OpenZip(fi, out zipFile);
// this will return ValidTrrntZip or CorruptZip.
if ((tzs & TrrntZipStatus.CorruptZip) == TrrntZipStatus.CorruptZip)
{
StatusLogCallBack?.Invoke(ThreadID, "Zip file is corrupt");
return(TrrntZipStatus.CorruptZip);
}
// the zip file may have found a valid trrntzip header, but we now check that all the file info
// is actually valid, and may invalidate it being a valid trrntzip if any problem is found.
List <ZippedFile> zippedFiles = ReadZipContent(zipFile);
tzs |= TorrentZipCheck.CheckZipFiles(ref zippedFiles);
// if tza is now just 'ValidTrrntzip' the it is fully valid, and nothing needs to be done to it.
if (tzs == TrrntZipStatus.ValidTrrntzip && !Program.ForceReZip || Program.CheckOnly)
{
StatusLogCallBack?.Invoke(ThreadID, "Skipping File");
return(TrrntZipStatus.ValidTrrntzip);
}
StatusLogCallBack?.Invoke(ThreadID, "TorrentZipping");
TrrntZipStatus fixedTzs = TorrentZipRebuild.ReZipFiles(zippedFiles, zipFile, _buffer, StatusCallBack, StatusLogCallBack, ThreadID);
return(fixedTzs);
}
private TrrntZipStatus OpenZip(FileInfo fi, out ICompress zipFile)
{
string ext = Path.GetExtension(fi.Name);
switch (ext)
{
case ".iso":
zipFile = new File();
break;
case ".7z":
zipFile = new SevenZ();
break;
default:
zipFile = new Zip();
break;
}
ZipReturn zr = zipFile.ZipFileOpen(fi.FullName, fi.LastWriteTime);
if (zr != ZipReturn.ZipGood)
{
return(TrrntZipStatus.CorruptZip);
}
TrrntZipStatus tzStatus = TrrntZipStatus.Unknown;
// first check if the file is a trrntip files
if (zipFile.ZipStatus == ZipStatus.TrrntZip)
{
tzStatus |= TrrntZipStatus.ValidTrrntzip;
}
return(tzStatus);
}
public static TrrntZipStatus CheckZipFiles(ref List <ZippedFile> zippedFiles)
{
TrrntZipStatus tzStatus = TrrntZipStatus.Unknown;
// ***************************** RULE 1 *************************************
// Directory separator should be a '/' a '\' is invalid and should be replaced with '/'
//
// check if any '\' = 92 need converted to '/' = 47
// this needs done before the sort, so that the sort is correct.
// return BadDirectorySeparator if errors found.
bool error1 = false;
foreach (ZippedFile t in zippedFiles)
{
char[] bytes = t.Name.ToCharArray();
bool fixDir = false;
for (int j = 0; j < bytes.Length; j++)
{
if (bytes[j] != 92)
{
continue;
}
fixDir = true;
bytes[j] = (char)47;
tzStatus |= TrrntZipStatus.BadDirectorySeparator;
if (!error1 && Program.VerboseLogging)
{
error1 = true;
Console.WriteLine("Incorrect directory separator found");
}
}
if (fixDir)
{
t.Name = new string(bytes);
}
}
// ***************************** RULE 2 *************************************
// All Files in a torrentzip should be sorted with a lower case file compare.
//
// if needed sort the files correctly, and return Unsorted if errors found.
bool error2 = false;
bool thisSortFound = true;
while (thisSortFound)
{
thisSortFound = false;
for (int i = 0; i < zippedFiles.Count - 1; i++)
{
int c = TrrntZipStringCompare(zippedFiles[i].Name, zippedFiles[i + 1].Name);
if (c > 0)
{
ZippedFile T = zippedFiles[i];
zippedFiles[i] = zippedFiles[i + 1];
zippedFiles[i + 1] = T;
tzStatus |= TrrntZipStatus.Unsorted;
thisSortFound = true;
if (!error2 && Program.VerboseLogging)
{
error2 = true;
Console.WriteLine("Incorrect file order found");
}
}
}
}
// ***************************** RULE 3 *************************************
// Directory marker files are only needed if they are empty directories.
//
// now that the files are sorted correctly, we can see if there are unneeded
// directory files, by first finding directory files (these end in a '\' character ascii 92)
// and then checking if the next file is a file in that found directory.
// If we find this 2 entry pattern (directory followed by file in that directory)
// then the directory entry should not be present and the torrentzip is incorrect.
// return ExtraDirectoryEnteries if error is found.
bool error3 = false;
for (int i = 0; i < zippedFiles.Count - 1; i++)
{
// check if this is a directory entry
if (zippedFiles[i].Name[zippedFiles[i].Name.Length - 1] != 47)
{
continue;
}
// check if the next filename is shorter or equal to this filename.
// if it is shorter or equal it cannot be a file in the directory.
if (zippedFiles[i + 1].Name.Length <= zippedFiles[i].Name.Length)
{
continue;
}
// check if the directory part of the two file enteries match
// if they do we found an incorrect directory entry.
bool delete = true;
for (int j = 0; j < zippedFiles[i].Name.Length; j++)
{
if (zippedFiles[i].Name[j] != zippedFiles[i + 1].Name[j])
{
delete = false;
break;
}
}
// we found an incorrect directory so remove it.
if (delete)
{
zippedFiles.RemoveAt(i);
tzStatus |= TrrntZipStatus.ExtraDirectoryEnteries;
if (!error3 && Program.VerboseLogging)
{
error3 = true;
Console.WriteLine("Un-needed directory records found");
}
i--;
}
}
// check for repeat files
bool error4 = false;
for (int i = 0; i < zippedFiles.Count - 1; i++)
{
if (zippedFiles[i].Name == zippedFiles[i + 1].Name)
{
tzStatus |= TrrntZipStatus.RepeatFilesFound;
if (!error4 && Program.VerboseLogging)
{
error4 = true;
Console.WriteLine("Duplcate file enteries found");
}
}
}
return(tzStatus);
}
public TrrntZipStatus Process(FileInfo fi)
{
if (Program.VerboseLogging)
{
StatusLogCallBack?.Invoke(ThreadId, "");
}
StatusLogCallBack?.Invoke(ThreadId, fi.Name + " - ");
// First open the zip (7z) file, and fail out if it is corrupt.
TrrntZipStatus tzs = OpenZip(fi, out ICompress zipFile);
// this will return ValidTrrntZip or CorruptZip.
for (int i = 0; i < zipFile.LocalFilesCount(); i++)
{
Debug.WriteLine("Name = " + zipFile.Filename(i) + " , " + zipFile.UncompressedSize(i));
}
if ((tzs & TrrntZipStatus.CorruptZip) == TrrntZipStatus.CorruptZip)
{
StatusLogCallBack?.Invoke(ThreadId, "Zip file is corrupt");
return(TrrntZipStatus.CorruptZip);
}
// the zip file may have found a valid trrntzip header, but we now check that all the file info
// is actually valid, and may invalidate it being a valid trrntzip if any problem is found.
List <ZippedFile> zippedFiles = ReadZipContent(zipFile);
// check if the compression type has changed
zipType inputType;
switch (zipFile)
{
case Zip _:
tzs |= TorrentZipCheck.CheckZipFiles(ref zippedFiles, ThreadId, StatusLogCallBack);
inputType = zipType.zip;
break;
case SevenZ _:
tzs |= TorrentZipCheck.CheckSevenZipFiles(ref zippedFiles, ThreadId, StatusLogCallBack);
inputType = zipType.sevenzip;
break;
case File _:
inputType = zipType.iso;
break;
default:
return(TrrntZipStatus.Unknown);
}
zipType outputType = Program.OutZip == zipType.both ? inputType : Program.OutZip;
if (outputType == zipType.iso)
{
outputType = zipType.zip;
}
bool compressionChanged = inputType != outputType;
// if tza is now just 'ValidTrrntzip' the it is fully valid, and nothing needs to be done to it.
if (((tzs == TrrntZipStatus.ValidTrrntzip) && !compressionChanged && !Program.ForceReZip) || Program.CheckOnly)
{
StatusLogCallBack?.Invoke(ThreadId, "Skipping File");
return(tzs);
}
// if compressionChanged then the required file order will also have changed to need to re-sort the files.
if (compressionChanged)
{
switch (outputType)
{
case zipType.zip:
tzs |= TorrentZipCheck.CheckZipFiles(ref zippedFiles, ThreadId, StatusLogCallBack);
break;
case zipType.sevenzip:
tzs |= TorrentZipCheck.CheckSevenZipFiles(ref zippedFiles, ThreadId, StatusLogCallBack);
break;
}
}
StatusLogCallBack?.Invoke(ThreadId, "TorrentZipping");
TrrntZipStatus fixedTzs = TorrentZipRebuild.ReZipFiles(zippedFiles, zipFile, _buffer, StatusCallBack, StatusLogCallBack, ThreadId);
return(fixedTzs);
}
