private static void Add7Zip(FileInfo f, DatDir thisDir)
{
DatDir ZipDir = new DatDir(DatFileType.Dir7Zip)
{
Name = Path.GetFileNameWithoutExtension(f.Name),
DGame = new DatGame()
};
ZipDir.DGame.Description = ZipDir.Name;
thisDir.ChildAdd(ZipDir);
SevenZ zf1 = new SevenZ();
zf1.ZipFileOpen(f.FullName, -1, true);
FileScan fs = new FileScan();
List <FileScan.FileResults> fr = fs.Scan(zf1, true, true);
for (int i = 0; i < fr.Count; i++)
{
if (zf1.IsDirectory(i))
{
continue;
}
DatFile df = new DatFile(DatFileType.File7Zip)
{
Name = zf1.Filename(i),
Size = fr[i].Size,
CRC = fr[i].CRC,
SHA1 = fr[i].SHA1
//df.MD5 = zf.MD5(i)
};
ZipDir.ChildAdd(df);
}
zf1.ZipFileClose();
}
private void OnScanUpdated(FileScan scan)
{
this.Dispatcher.Invoke(() =>
{
this.UpdateScans(this.scanManager.Scans);
});
}
static async Task Start(IEndpointInstance endpointInstance)
{
Console.WriteLine("Press '1' to publish the file scan");
Console.WriteLine("Press any other key to exit");
while (true)
{
var key = Console.ReadKey();
Console.WriteLine();
if (key.Key == ConsoleKey.D1)
{
var fileScan = new FileScan
{
Id = Guid.NewGuid(),
FileName = "File.jpg"
};
await endpointInstance.Send(fileScan)
.ConfigureAwait(false);
Console.WriteLine($"Published FileScan Event with Id {fileScan.Id}.");
}
else
{
return;
}
}
}
public static void FromAFile(RvFile file, string directory, EScanLevel eScanLevel, ThreadWorker bgw, ref bool fileErrorAbort)
{
string filename = Path.Combine(directory, file.Name);
ICompress fileToScan = new Compress.File.File();
ZipReturn zr = fileToScan.ZipFileOpen(filename, file.FileModTimeStamp);
if (zr == ZipReturn.ZipFileLocked)
{
file.GotStatus = GotStatus.FileLocked;
return;
}
if (zr != ZipReturn.ZipGood)
{
ReportError.Show("File: " + filename + " Error: " + zr + ". Scan Aborted.");
file.GotStatus = GotStatus.FileLocked;
fileErrorAbort = true;
return;
}
if (_fs == null)
{
_fs = new FileScan();
}
List <FileScan.FileResults> fr = _fs.Scan(fileToScan, true, eScanLevel == EScanLevel.Level2 || eScanLevel == EScanLevel.Level3);
file.HeaderFileType = fr[0].HeaderFileType;
file.Size = fr[0].Size;
file.CRC = fr[0].CRC;
file.SHA1 = fr[0].SHA1;
file.MD5 = fr[0].MD5;
file.AltSize = fr[0].AltSize;
file.AltCRC = fr[0].AltCRC;
file.AltSHA1 = fr[0].AltSHA1;
file.AltMD5 = fr[0].AltMD5;
file.FileStatusSet(
FileStatus.SizeVerified |
(file.HeaderFileType != HeaderFileType.Nothing ? FileStatus.HeaderFileTypeFromHeader : 0) |
(file.CRC != null ? FileStatus.CRCVerified : 0) |
(file.SHA1 != null ? FileStatus.SHA1Verified : 0) |
(file.MD5 != null ? FileStatus.MD5Verified : 0) |
(file.AltSize != null ? FileStatus.AltSizeVerified : 0) |
(file.AltCRC != null ? FileStatus.AltCRCVerified : 0) |
(file.AltSHA1 != null ? FileStatus.AltSHA1Verified : 0) |
(file.AltMD5 != null ? FileStatus.AltMD5Verified : 0)
);
if (fr[0].HeaderFileType == HeaderFileType.CHD)
{
CHD.CheckFile(file, directory);
if (eScanLevel == EScanLevel.Level2 || eScanLevel == EScanLevel.Level3)
{
Utils.ChdManCheck(file, directory, bgw, ref fileErrorAbort);
}
}
fileToScan.ZipFileClose();
}
private void OnScanCreated(FileScan scan)
{
this.Dispatcher.Invoke(() =>
{
this.Log($"File record of {scan.Path} created");
this.UpdateScans(this.scanManager.Scans);
});
}
private static void AddZip(FileInfo f, DatDir thisDir)
{
ZipFile zf1 = new ZipFile();
zf1.ZipFileOpen(f.FullName, -1, true);
zf1.ZipStatus = ZipStatus.TrrntZip;
DatDir ZipDir = new DatDir(zf1.ZipStatus == ZipStatus.TrrntZip ? DatFileType.DirTorrentZip : DatFileType.DirRVZip)
{
Name = Path.GetFileNameWithoutExtension(f.Name),
DGame = new DatGame()
};
ZipDir.DGame.Description = ZipDir.Name;
thisDir.ChildAdd(ZipDir);
FileScan fs = new FileScan();
List <FileScan.FileResults> fr = fs.Scan(zf1, true, true);
bool isTorrentZipDate = true;
for (int i = 0; i < fr.Count; i++)
{
if (fr[i].FileStatus != Compress.ZipReturn.ZipGood)
{
Console.WriteLine("File Error :" + zf1.Filename(i) + " : " + fr[i].FileStatus);
continue;
}
DatFile df = new DatFile(DatFileType.FileTorrentZip)
{
Name = zf1.Filename(i),
Size = fr[i].Size,
CRC = fr[i].CRC,
SHA1 = fr[i].SHA1,
Date = zf1.LastModified(i).ToString("yyyy/MM/dd HH:mm:ss")
//df.MD5 = zf.MD5(i)
};
if (zf1.LastModified(i).Ticks != 629870671200000000)
{
isTorrentZipDate = false;
}
ZipDir.ChildAdd(df);
}
zf1.ZipFileClose();
if (isTorrentZipDate && ZipDir.DatFileType == DatFileType.DirRVZip)
{
ZipDir.DatFileType = DatFileType.DirTorrentZip;
}
if (ZipDir.DatFileType == DatFileType.DirTorrentZip)
{
DatSetCompressionType.SetZip(ZipDir);
DatClean.RemoveUnNeededDirectoriesFromZip(ZipDir);
}
}
public async Task UnlockFromQuarantine(FileScan scan)
{
var path = Path.Combine(this.Directory, scan.QuarantinePath);
try
{
if (scan.QuarantineState != QuarantineState.InQuarantine)
{
throw new Exception($"Scan {scan.Path} is not in quarantine");
}
if (!File.Exists(path))
{
throw new Exception($"Quarantine file {path} not found");
}
scan.QuarantineState = QuarantineState.Decrypting;
this.OnScanUpdated?.Invoke(scan);
using (FileStream outStream = new FileStream(scan.Path, FileMode.Create))
using (FileStream inStream = new FileStream(path, FileMode.Open))
using (RijndaelManaged aes = this.CreateAES())
{
File.SetAttributes(scan.Path, File.GetAttributes(path));
aes.IV = scan.IV;
var decryptor = aes.CreateDecryptor();
using (CryptoStream encryptStream = new CryptoStream(inStream, decryptor, CryptoStreamMode.Read))
{
await encryptStream.CopyToAsync(outStream);
}
outStream.SetLength(scan.Size);
}
File.Delete(path);
scan.QuarantineState = QuarantineState.NotQuarantined;
scan.QuarantinePath = "";
}
catch (Exception e)
{
try
{
File.Delete(scan.Path);
}
catch (IOException)
{
}
scan.QuarantineState = QuarantineState.InQuarantine;
throw e;
}
}
public void Remove(FileScan scan)
{
lock (this.Mutex)
{
this.scans.Delete(scan.Id);
if (this.scans.Find(s => s.Report.Id == scan.Report.Id).Count() == 0)
{
this.reports.Delete(scan.Report.Id);
}
}
}
public async Task LockToQuarantine(FileScan scan)
{
var name = this.GenerateName();
var path = Path.Combine(this.Directory, name);
try
{
if (scan.QuarantineState != QuarantineState.NotQuarantined)
{
throw new Exception($"Scan {scan.Path} is already in quarantine or is being encrypted/decrypted");
}
if (!File.Exists(scan.Path))
{
throw new Exception($"Scan file {scan.Path} not found");
}
scan.QuarantineState = QuarantineState.Encrypting;
this.OnScanUpdated?.Invoke(scan);
using (FileStream outStream = new FileStream(path, FileMode.Create))
using (FileStream inStream = new FileStream(scan.Path, FileMode.Open))
using (RijndaelManaged aes = this.CreateAES())
{
File.SetAttributes(path, File.GetAttributes(scan.Path));
aes.GenerateIV();
scan.IV = aes.IV.ToArray();
var encryptor = aes.CreateEncryptor();
using (CryptoStream encryptStream = new CryptoStream(outStream, encryptor, CryptoStreamMode.Write))
{
await inStream.CopyToAsync(encryptStream);
}
}
scan.QuarantinePath = name;
scan.QuarantineState = QuarantineState.InQuarantine;
File.Delete(scan.Path);
}
catch (Exception e)
{
try
{
File.Delete(path);
}
catch (IOException)
{
}
scan.QuarantineState = QuarantineState.NotQuarantined;
throw e;
}
}
private void UpdateScans(List <FileScan> scans)
{
this.scanGrid.ItemsSource = null;
this.scanGrid.ItemsSource = scans;
this.scanGrid.Items.Refresh();
var scan = this.SelectedScan;
this.SelectedScan = null;
this.SelectedScan = scan;
}
private void InitializeFileScanContol(FileScan fileScan)
{
lb_info1.Text = nameof(fileScan.md5).ToUpper();
lb_info1Result.Text = fileScan.md5 ?? string.Empty;
lb_info2.Text = nameof(fileScan.sha1).ToUpper();
lb_info2Result.Text = fileScan.sha1 ?? string.Empty;
lb_info3.Text = nameof(fileScan.sha256).ToUpper();
lb_info3Result.Text = fileScan.sha256 ?? string.Empty;
llb_permalinkResult.Text = fileScan.permalink ?? string.Empty;
}
private void StartScanForms(DoWorkEventArgs e)
{
if (String.IsNullOrWhiteSpace(Folder))
{
return;
}
Scan scan = new Scan
{
FilePath = Folder,
HashAlgorithm = Algorithm,
Time = DateTime.Now
};
try
{
scan.Insert();
}
catch (Exception ex)
{
}
List <string> allFiles = DirectoryParser.GetAllFiles(Folder, Recursive);
int nFiles = allFiles.Count;
int i = 0;
foreach (string file in allFiles)
{
if (backgroundWorker1.CancellationPending)
{
e.Cancel = true;
break;
}
else
{
try
{
FileScan.ScanFile(file, scan);
int progress = (int)Math.Ceiling((double)i / nFiles) * 100;
backgroundWorker1.ReportProgress(progress, (object)file);
i++;
}
catch (Exception ex)
{
continue;
}
}
}
}
public static string CalculateVirusRisk(FileScan definition)
{
if (definition.TotalScans == 0)
{
return("No Risk");
}
var percentageOfDetectedInfections = definition.PositiveScans * 100 / definition.TotalScans;
if (percentageOfDetectedInfections >= 50)
{
return("Infected");
}
return(percentageOfDetectedInfections >= 1 ? "Risk" : "No Risk");
}
void FillListViewWithFoundViruses()
{
this.HandleInvoke(() =>
{
lvwVirusHistory.Items.Clear();
foreach (var virus in _scanner.FoundViruses)
{
var item = new ListViewItem(Path.GetFileName(virus.Path));
var detectionTimeString = virus.DetectionTime.ToString(CultureInfo.InvariantCulture);
item.SubItems.Add(detectionTimeString);
item.SubItems.Add(virus.HitCount + "/" + virus.ScanCount);
item.SubItems.Add(FileScan.CalculateVirusRisk(virus));
item.SubItems.Add(virus.Path);
lvwVirusHistory.Items.Add(item);
}
});
}
private static void AddFile(FileInfo f, DatDir thisDir)
{
Compress.File.File zf1 = new Compress.File.File();
zf1.ZipFileOpen(f.FullName, -1, true);
FileScan fs = new FileScan();
List <FileScan.FileResults> fr = fs.Scan(zf1, true, true);
DatFile df = new DatFile(DatFileType.File)
{
Name = f.Name,
Size = fr[0].Size,
CRC = fr[0].CRC,
SHA1 = fr[0].SHA1
};
thisDir.ChildAdd(df);
zf1.ZipFileClose();
}
private void SettingDetectionList(FileScan fileScan)
{
Task <List <Detection> > .Factory.StartNew(() =>
{
ShowProcess(true);
List <Detection> detections = new List <Detection>();
PropertyInfo[] propertyInfos = fileScan.scans.GetType().GetProperties();
foreach (PropertyInfo propertyInfo in propertyInfos)
{
if (propertyInfo.GetValue(fileScan.scans, null) is IFileScanInfo fileScanInfo)
{
string engine = propertyInfo.Name;
bool detected = fileScanInfo.detected;
string version = fileScanInfo.version;
string result = fileScanInfo.result?.ToString();
string update = fileScanInfo.update;
detections.Add(Detection.CreateDetection(engine, detected, version, result, update));
}
//dynamic DetectionEngineClass = FileScan.scans.GetType().GetProperty(propertyInfo.Name).GetValue(FileScan.scans, null);
//if (DetectionEngineClass != null)
//{
// string engine = propertyInfo.Name;
// bool detected = DetectionEngineClass.detected;
// string version = DetectionEngineClass.version;
// string result = DetectionEngineClass.result;
// string update = DetectionEngineClass.update;
// detections.Add(Detection.CreateDetection(engine, detected, version, result, update));
//}
}
return(detections);
}).ContinueWith(e =>
{
DetectionListView.SetObjects(e.Result);
ShowProcess(false);
});
}
/// <summary>
/// The event that gets triggered when a new file scan occures
/// </summary>
/// <param name="sender">The class that triggered the event</param>
/// <param name="e">The data that got scanned</param>
void VirusScanner_NewScanFile(object sender, NewFileScanEventHandlerArgs e)
{
this.HandleInvoke(() =>
{
_scanCount++;
var item = new ListViewItem(Path.GetFileName(e.FileScan.Path));
item.SubItems.Add(DateTime.Now.ToLongTimeString());
var totalScans = e.FileScan.TotalScans;
item.SubItems.Add(e.FileScan.PositiveScans + "/" + (totalScans == 0 ? 57 : totalScans));
var virusPrognosis = FileScan.CalculateVirusRisk(e.FileScan);
item.SubItems.Add(virusPrognosis);
lvwScanLog.Items.Add(item);
if (lvwScanLog.Items.Count > 21)
{
lvwScanLog.Items.RemoveAt(0);
}
tbxTotalScans.Text = _scanCount.ToString();
});
}
} // public void Setup
/*M+M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++M+++
* Method: public void BeginScan()
* Summary:
* Args:
* Modifies:
* Returns:
* M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M-M*/
public void BeginScan()
{
DirectoryInfo dir;
FileScan file;
String FullName;
long FileSize;
DateTime CreationDate;
// Setup DirectoryInfo and FileScan instances;
dir = new DirectoryInfo(StartDir);
file = new FileScan();
/*---------------------------------------------------------
* To Do: Need to set this up to call some type of
* callback fcn using whatever mecanisim C#
* supports.
*
* For now, I just call an instance of FileScan
* ----------------------------------------------------------*/
try
{
foreach (FileInfo f in dir.GetFiles(FileFilter))
{
FullName = f.FullName;
FileSize = f.Length;
CreationDate = f.CreationTime;
//Console.WriteLine("{0}", FullName);
file.Setup(FullName, OutputFile, SearchString);
if (0 == file.ScanFile())
{
Console.WriteLine("DirScan:BeginScan() - ERROR - file.ScanFile Failed. Exiting\n");
return;
}
}
}
catch (System.IO.IOException)
{
Console.WriteLine("Caught System.IO.IOException while scanning {0}", FileFilter);
}
} // public void BeginScan
private static void AddZip(FileInfo f, DatDir thisDir)
{
DatDir ZipDir = new DatDir(DatFileType.DirTorrentZip)
{
Name = Path.GetFileNameWithoutExtension(f.Name),
DGame = new DatGame()
};
ZipDir.DGame.Description = ZipDir.Name;
thisDir.ChildAdd(ZipDir);
ZipFile zf1 = new ZipFile();
zf1.ZipFileOpen(f.FullName, -1, true);
FileScan fs = new FileScan();
List <FileScan.FileResults> fr = fs.Scan(zf1, true, true);
for (int i = 0; i < fr.Count; i++)
{
if (fr[i].FileStatus != Compress.ZipReturn.ZipGood)
{
Console.WriteLine("File Error :" + zf1.Filename(i) + " : " + fr[i].FileStatus);
continue;
}
DatFile df = new DatFile(DatFileType.FileTorrentZip)
{
Name = Path.GetFileNameWithoutExtension(f.Name) + Path.GetExtension(zf1.Filename(i)),
Size = fr[i].Size,
CRC = fr[i].CRC,
SHA1 = fr[i].SHA1
//df.MD5 = zf.MD5(i)
};
ZipDir.ChildAdd(df);
}
zf1.ZipFileClose();
}
public static void FromAFile(RvFile file, string directory, EScanLevel eScanLevel, ThreadWorker bgw, ref bool fileErrorAbort)
{
_bgw = bgw;
string filename = Path.Combine(directory, string.IsNullOrWhiteSpace(file.FileName) ? file.Name : file.FileName);
ICompress fileToScan = new Compress.File.File();
ZipReturn zr = fileToScan.ZipFileOpen(filename, file.FileModTimeStamp);
if (zr == ZipReturn.ZipFileLocked)
{
file.GotStatus = GotStatus.FileLocked;
return;
}
if (zr != ZipReturn.ZipGood)
{
ReportError.Show("File: " + filename + " Error: " + zr + ". Scan Aborted.");
file.GotStatus = GotStatus.FileLocked;
fileErrorAbort = true;
return;
}
if (_fs == null)
{
_fs = new FileScan();
}
List <FileScan.FileResults> fr = _fs.Scan(fileToScan, true, eScanLevel == EScanLevel.Level2 || eScanLevel == EScanLevel.Level3);
file.HeaderFileType = fr[0].HeaderFileType;
file.Size = fr[0].Size;
file.CRC = fr[0].CRC;
file.SHA1 = fr[0].SHA1;
file.MD5 = fr[0].MD5;
file.AltSize = fr[0].AltSize;
file.AltCRC = fr[0].AltCRC;
file.AltSHA1 = fr[0].AltSHA1;
file.AltMD5 = fr[0].AltMD5;
file.FileStatusSet(
FileStatus.SizeVerified |
(file.HeaderFileType != HeaderFileType.Nothing ? FileStatus.HeaderFileTypeFromHeader : 0) |
(file.CRC != null ? FileStatus.CRCVerified : 0) |
(file.SHA1 != null ? FileStatus.SHA1Verified : 0) |
(file.MD5 != null ? FileStatus.MD5Verified : 0) |
(file.AltSize != null ? FileStatus.AltSizeVerified : 0) |
(file.AltCRC != null ? FileStatus.AltCRCVerified : 0) |
(file.AltSHA1 != null ? FileStatus.AltSHA1Verified : 0) |
(file.AltMD5 != null ? FileStatus.AltMD5Verified : 0)
);
if (fr[0].HeaderFileType == HeaderFileType.CHD)
{
bool deepCheck = (eScanLevel == EScanLevel.Level2 || eScanLevel == EScanLevel.Level3);
CHD.fileProcess = FileProcess;
CHD.fileProgress = FileProgress;
CHD.fileSystemError = FileSystemError;
CHD.fileError = FileError;
CHD.generalError = GeneralError;
hdErr result = CHD.CheckFile(file.Name, directory, Settings.isLinux, ref deepCheck, out uint?chdVersion, out byte[] chdSHA1, out byte[] chdMD5, ref fileErrorAbort);
switch (result)
{
case hdErr.HDERR_NONE:
file.CHDVersion = chdVersion;
if (chdSHA1 != null)
{
file.AltSHA1 = chdSHA1;
file.FileStatusSet(FileStatus.AltSHA1FromHeader);
if (deepCheck)
{
file.FileStatusSet(FileStatus.AltSHA1Verified);
}
}
if (chdMD5 != null)
{
file.AltMD5 = chdMD5;
file.FileStatusSet(FileStatus.AltMD5FromHeader);
if (deepCheck)
{
file.FileStatusSet(FileStatus.AltMD5Verified);
}
}
break;
case hdErr.HDERR_OUT_OF_MEMORY:
case hdErr.HDERR_INVALID_FILE:
case hdErr.HDERR_INVALID_DATA:
case hdErr.HDERR_READ_ERROR:
case hdErr.HDERR_DECOMPRESSION_ERROR:
case hdErr.HDERR_CANT_VERIFY:
file.GotStatus = GotStatus.Corrupt;
break;
default:
ReportError.UnhandledExceptionHandler(result.ToString());
break;
}
}
fileToScan.ZipFileClose();
}
public void Insert(FileScan scan)
{
this.scans.Insert(scan);
}
public void Update(FileScan scan)
{
this.scans.Update(scan);
}
private static bool ScanAFile(string realFilename, Stream memzip, string displayFilename)
{
Compress.File.File fStream = new Compress.File.File();
if (string.IsNullOrEmpty(realFilename) && memzip != null)
{
fStream.ZipFileOpen(memzip);
}
else
{
ZipReturn zRet = fStream.ZipFileOpen(realFilename, -1, true);
if (zRet != ZipReturn.ZipGood)
{
return(false);
}
}
bool ret = false;
FileScan fScan = new FileScan();
List <FileScan.FileResults> resScan = fScan.Scan(fStream, true, true);
HeaderFileType foundFileType = resScan[0].HeaderFileType;
if (foundFileType == HeaderFileType.CHD)
{
// read altheader values from CHD file.
}
RvFile tFile = new RvFile
{
Size = resScan[0].Size,
CRC = resScan[0].CRC,
MD5 = resScan[0].MD5,
SHA1 = resScan[0].SHA1,
AltType = resScan[0].HeaderFileType,
AltSize = resScan[0].AltSize,
AltCRC = resScan[0].AltCRC,
AltMD5 = resScan[0].AltMD5,
AltSHA1 = resScan[0].AltSHA1
};
// test if needed.
FindStatus res = RvRomFileMatchup.FileneededTest(tFile);
if (res == FindStatus.FileNeededInArchive)
{
_bgw?.ReportProgress(0, new bgwShowError(displayFilename, "found"));
Debug.WriteLine("Reading file as " + tFile.SHA1);
string outfile = RomRootDir.Getfilename(tFile.SHA1);
gZip gz1 = new gZip();
gz1.ZipFileCreate(outfile);
gz1.ExtraData = tFile.SetExtraData();
gz1.ZipFileOpenWriteStream(false, true, "", tFile.Size, 8, out Stream write, null);
fStream.ZipFileOpenReadStream(0, out Stream s, out ulong _);
// do copy
StreamCopier.StreamCopy(s, write, tFile.Size);
fStream.ZipFileCloseReadStream();
fStream.ZipFileClose();
gz1.ZipFileCloseWriteStream(tFile.CRC);
tFile.CompressedSize = gz1.CompressedSize;
gz1.ZipFileClose();
tFile.DBWrite();
ret = true;
}
else if (res == FindStatus.FoundFileInArchive)
{
ret = true;
}
fStream.ZipFileClose();
if (foundFileType == HeaderFileType.ZIP || foundFileType == HeaderFileType.SevenZip || foundFileType == HeaderFileType.GZ)
{
ICompress fz;
switch (foundFileType)
{
case HeaderFileType.SevenZip:
fz = new SevenZ();
break;
case HeaderFileType.GZ:
fz = new gZip();
break;
//case HeaderFileType.ZIP:
default:
fz = new Zip();
break;
}
ZipReturn zp;
if (string.IsNullOrEmpty(realFilename) && memzip != null)
{
memzip.Position = 0;
zp = fz.ZipFileOpen(memzip);
}
else
{
zp = fz.ZipFileOpen(realFilename);
}
if (zp == ZipReturn.ZipGood)
{
bool allZipFound = true;
for (int i = 0; i < fz.LocalFilesCount(); i++)
{
LocalFile lf = fz.GetLocalFile(i);
ZipReturn openFile = fz.ZipFileOpenReadStream(i, out Stream stream, out ulong streamSize);
if (streamSize <= _inMemorySize)
{
if (openFile == ZipReturn.ZipTryingToAccessADirectory)
{
continue;
}
byte[] tmpFile = new byte[streamSize];
stream.Read(tmpFile, 0, (int)streamSize);
using (Stream memStream = new MemoryStream(tmpFile, false))
{
allZipFound &= ScanAFile(null, memStream, lf.Filename);
}
}
else
{
string file = Path.Combine(_tmpDir, Guid.NewGuid().ToString());
FileStream.OpenFileWrite(file, out Stream fs);
ulong sizetogo = streamSize;
while (sizetogo > 0)
{
int sizenow = sizetogo > (ulong)Buffersize ? Buffersize : (int)sizetogo;
stream.Read(Buffer, 0, sizenow);
fs.Write(Buffer, 0, sizenow);
sizetogo -= (ulong)sizenow;
}
fs.Close();
allZipFound &= ScanAFile(file, null, lf.Filename);
File.Delete(file);
}
//fz.ZipFileCloseReadStream();
}
fz.ZipFileClose();
ret |= allZipFound;
}
else
{
ret = false;
}
}
return(ret);
}
public void FileScan_ScanCreated_defaults_to_correct_kind()
{
var x = new FileScan();
Assert.Equal(DateTimeKind.Utc, x.ScanCreated.Kind);
}
private static void AddZip(FileInfo f, DatDir thisDir)
{
Zip zf1 = new Zip();
ZipReturn result = zf1.ZipFileOpen(f.FullName, -1, true);
if (result != ZipReturn.ZipGood)
{
return;
}
zCount += 1;
if ((zf1.ZipStatus & ZipStatus.TrrntZip) == ZipStatus.TrrntZip)
{
tCount += 1;
Console.WriteLine($"{zCount} {tCount} {cCount}");
}
else if (zf1.Filecomment != null && zf1.Filecomment.Length > 0)
{
string comments = ZipUtils.GetString(zf1.Filecomment);
if (comments.Length > 13 && comments.Substring(0, 13) == "TORRENTZIPPED")
{
tCount += 1;
}
else
{
cCount += 1;
Console.WriteLine(f.FullName + " " + zCount);
Console.WriteLine("------------------------");
Console.WriteLine(comments);
}
Console.WriteLine($"{zCount} {tCount} {cCount}");
}
//zf1.ZipStatus = ZipStatus.TrrntZip;
//DatDir ZipDir = new DatDir(zf1.ZipStatus == ZipStatus.TrrntZip ? DatFileType.DirTorrentZip : DatFileType.DirRVZip)
DatDir ZipDir = new DatDir(DatFileType.UnSet)
{
Name = Path.GetFileNameWithoutExtension(f.Name),
DGame = new DatGame()
};
ZipDir.DGame.Description = ZipDir.Name;
thisDir.ChildAdd(ZipDir);
FileScan fs = new FileScan();
List <FileScan.FileResults> fr = fs.Scan(zf1, !quick, !quick);
bool isTorrentZipDate = true;
for (int i = 0; i < fr.Count; i++)
{
if (fr[i].FileStatus != ZipReturn.ZipGood)
{
Console.WriteLine("File Error :" + zf1.Filename(i) + " : " + fr[i].FileStatus);
continue;
}
DatFile df = new DatFile(DatFileType.UnSet)
{
Name = zf1.Filename(i),
Size = fr[i].Size,
CRC = fr[i].CRC,
SHA1 = fr[i].SHA1,
DateModified = new DateTime(zf1.LastModified(i)).ToString("yyyy/MM/dd HH:mm:ss"),
DateCreated = zf1.Created(i) == null ? null : new DateTime((long)zf1.Created(i)).ToString("yyyy/MM/dd HH:mm:ss"),
DateAccessed = zf1.Accessed(i) == null ? null : new DateTime((long)zf1.Accessed(i)).ToString("yyyy/MM/dd HH:mm:ss")
//df.MD5 = zf.MD5(i)
};
if (zf1.LastModified(i) != 629870671200000000)
{
isTorrentZipDate = false;
}
ZipDir.ChildAdd(df);
}
zf1.ZipFileClose();
if (isTorrentZipDate && ZipDir.DatFileType == DatFileType.DirRVZip)
{
ZipDir.DatFileType = DatFileType.DirTorrentZip;
}
if (ZipDir.DatFileType == DatFileType.DirTorrentZip)
{
DatSetCompressionType.SetZip(ZipDir);
DatClean.RemoveUnNeededDirectoriesFromZip(ZipDir);
}
}
private void HandleGridSelection(object sender, SelectionChangedEventArgs e)
{
this.SelectedScan = this.scanGrid.SelectedItem as FileScan;
}
public static RvFile FromAZipFile(RvFile dbDir, EScanLevel eScanLevel, ThreadWorker thWrk)
{
RvFile fileDir = new RvFile(dbDir.FileType);
DatStatus chechingDatStatus = dbDir.IsInToSort ? DatStatus.InToSort : DatStatus.NotInDat;
string filename = dbDir.FullNameCase;
ICompress checkZ = dbDir.FileType == FileType.Zip ? new Zip() : (ICompress) new SevenZ();
ZipReturn zr = checkZ.ZipFileOpen(filename, dbDir.FileModTimeStamp);
if (zr == ZipReturn.ZipGood)
{
dbDir.ZipStatus = checkZ.ZipStatus;
// to be Scanning a ZIP file means it is either new or has changed.
// as the code below only calls back here if that is true.
//
// Level1: Only use header CRC's
// Just get the CRC for the ZIP headers.
//
// Level2: Fully checksum changed only files
// We know this file has been changed to do a full checksum scan.
//
// Level3: Fully checksum everything
// So do a full checksum scan.
if (_fs == null)
{
_fs = new FileScan();
}
List <FileScan.FileResults> fr = _fs.Scan(checkZ, false, eScanLevel == EScanLevel.Level2 || eScanLevel == EScanLevel.Level3);
// add all of the file information from the zip file into scanDir
for (int i = 0; i < checkZ.LocalFilesCount(); i++)
{
LocalFile lf = checkZ.GetLocalFile(i);
RvFile tFile = new RvFile(DBTypeGet.FileFromDir(dbDir.FileType))
{
Name = lf.Filename,
ZipFileIndex = i,
ZipFileHeaderPosition = lf.LocalHead,
Size = lf.UncompressedSize,
CRC = lf.CRC,
FileModTimeStamp = lf.LastModified
};
// all levels read the CRC from the ZIP header
tFile.SetStatus(chechingDatStatus, GotStatus.Got);
tFile.FileStatusSet(FileStatus.SizeFromHeader | FileStatus.CRCFromHeader);
if (fr[i].FileStatus != ZipReturn.ZipGood)
{
thWrk.Report(new bgwShowCorrupt(fr[i].FileStatus, filename + " : " + lf.Filename));
tFile.GotStatus = GotStatus.Corrupt;
}
else
{
tFile.HeaderFileType = fr[i].HeaderFileType;
tFile.SHA1 = fr[i].SHA1;
tFile.MD5 = fr[i].MD5;
tFile.AltSize = fr[i].AltSize;
tFile.AltCRC = fr[i].AltCRC;
tFile.AltSHA1 = fr[i].AltSHA1;
tFile.AltMD5 = fr[i].AltMD5;
if (fr[i].CRC != null)
{
tFile.FileStatusSet(FileStatus.CRCFromHeader);
if (eScanLevel == EScanLevel.Level2 || eScanLevel == EScanLevel.Level3)
{
tFile.FileStatusSet(FileStatus.CRCVerified);
}
}
tFile.FileStatusSet(
FileStatus.SizeVerified |
(fr[i].HeaderFileType != HeaderFileType.Nothing ? FileStatus.HeaderFileTypeFromHeader : 0) |
(fr[i].SHA1 != null ? FileStatus.SHA1Verified : 0) |
(fr[i].MD5 != null ? FileStatus.MD5Verified : 0) |
(fr[i].AltSize != null ? FileStatus.AltSizeVerified : 0) |
(fr[i].AltCRC != null ? FileStatus.AltCRCVerified : 0) |
(fr[i].AltSHA1 != null ? FileStatus.AltSHA1Verified : 0) |
(fr[i].AltMD5 != null ? FileStatus.AltMD5Verified : 0)
);
}
fileDir.ChildAdd(tFile);
}
}
else if (zr == ZipReturn.ZipFileLocked)
{
thWrk.Report(new bgwShowError(filename, "Zip File Locked"));
dbDir.FileModTimeStamp = 0;
dbDir.GotStatus = GotStatus.FileLocked;
}
else
{
thWrk.Report(new bgwShowCorrupt(zr, filename));
dbDir.GotStatus = GotStatus.Corrupt;
}
checkZ.ZipFileClose();
return(fileDir);
}
private static void ScanRomRoot(string directory)
{
_bgw.ReportProgress(0, new bgwText("Scanning Dir : " + directory));
DirectoryInfo di = new DirectoryInfo(directory);
FileInfo[] fi = di.GetFiles();
_bgw.ReportProgress(0, new bgwRange2Visible(true));
_bgw.ReportProgress(0, new bgwSetRange2(fi.Count()));
for (int j = 0; j < fi.Count(); j++)
{
if (_bgw.CancellationPending)
{
return;
}
FileInfo f = fi[j];
_bgw.ReportProgress(0, new bgwValue2(j));
_bgw.ReportProgress(0, new bgwText2(f.Name));
string ext = Path.GetExtension(f.Name);
if (ext.ToLower() == ".gz")
{
gZip gZipTest = new gZip();
ZipReturn errorcode = gZipTest.ZipFileOpen(f.FullName);
if (errorcode != ZipReturn.ZipGood)
{
_bgw.ReportProgress(0, new bgwShowError(f.FullName, "gz File corrupt"));
if (!Directory.Exists("corrupt"))
{
Directory.CreateDirectory("corrupt");
}
File.Move(f.FullName, Path.Combine("corrupt", f.Name));
continue;
}
RvFile tFile = RvFile.fromGZip(f.FullName, gZipTest.ExtraData, gZipTest.CompressedSize);
gZipTest.ZipFileClose();
FindStatus res = fileneededTest(tFile);
if (res != FindStatus.FoundFileInArchive)
{
if (deep)
{
gZipTest = new gZip();
try
{
errorcode = gZipTest.ZipFileOpen(f.FullName);
if (errorcode == ZipReturn.ZipGood)
{
FileScan fs = new FileScan();
List <FileScan.FileResults> gRes = fs.Scan(gZipTest, true, true);
errorcode = gRes[0].FileStatus;
gZipTest.ZipFileClose();
}
}
catch
{
gZipTest.ZipFileClose();
_bgw.ReportProgress(0, new bgwShowError(f.FullName, "gz Crashed Compression"));
if (!Directory.Exists("corrupt"))
{
Directory.CreateDirectory("corrupt");
}
File.Move(f.FullName, Path.Combine("corrupt", f.Name));
continue;
}
if (errorcode != ZipReturn.ZipGood)
{
_bgw.ReportProgress(0, new bgwShowError(f.FullName, "gz File corrupt"));
if (!Directory.Exists("corrupt"))
{
Directory.CreateDirectory("corrupt");
}
File.Move(f.FullName, Path.Combine("corrupt", f.Name));
continue;
}
}
tFile.DBWrite();
}
}
if (_bgw.CancellationPending)
{
return;
}
}
DirectoryInfo[] childdi = di.GetDirectories();
foreach (DirectoryInfo d in childdi)
{
if (_bgw.CancellationPending)
{
return;
}
ScanRomRoot(d.FullName);
}
}
public static void LogFileChanged(FileScan latest, FileScan other)
{
}
