private static CacheData GetCacheableDataInFMInstalledDir(FanMission fm)
{
AssertR(fm.Installed, "fm.Installed is false when it should be true");
string thisFMInstallsBasePath = Config.GetFMInstallPathUnsafe(fm.Game);
string path = Path.Combine(thisFMInstallsBasePath, fm.InstalledDir);
var files = FastIO.GetFilesTopOnly(path, "*");
string t3ReadmePath1 = Path.Combine(path, Paths.T3ReadmeDir1);
string t3ReadmePath2 = Path.Combine(path, Paths.T3ReadmeDir2);
if (Directory.Exists(t3ReadmePath1))
{
files.AddRange(FastIO.GetFilesTopOnly(t3ReadmePath1, "*"));
}
if (Directory.Exists(t3ReadmePath2))
{
files.AddRange(FastIO.GetFilesTopOnly(t3ReadmePath2, "*"));
}
RemoveEmptyFiles(files);
var readmes = new List <string>(files.Count);
foreach (string f in files)
{
if (f.IsValidReadme())
{
readmes.Add(f.Substring(path.Length + 1));
}
}
return(new CacheData(readmes));
}
private static void ClearCacheDir(FanMission fm)
{
string fmCachePath = Path.Combine(Paths.FMsCache, fm.InstalledDir);
if (!fmCachePath.TrimEnd(CA_BS_FS).PathEqualsI(Paths.FMsCache.TrimEnd(CA_BS_FS)) && Directory.Exists(fmCachePath))
{
try
{
foreach (string f in FastIO.GetFilesTopOnly(fmCachePath, "*"))
{
File.Delete(f);
}
foreach (string d in FastIO.GetDirsTopOnly(fmCachePath, "*"))
{
Directory.Delete(d, recursive: true);
}
}
catch (Exception ex)
{
Log("Exception clearing files in FM cache for " + fm.Archive + " / " + fm.InstalledDir, ex);
}
}
}
internal static void CreateOrClearTempPath(string path)
{
#region Safety check
// Make sure we never delete any paths that are not safely tucked in our temp folder
string baseTemp = _baseTemp.TrimEnd(CA_BS_FS_Space);
// @DIRSEP: getting rid of this concat is more trouble than it's worth
// This method is called rarely and only once in a row
bool pathIsInTempDir = path.PathStartsWithI(baseTemp + "\\");
Misc.AssertR(pathIsInTempDir, "Path '" + path + "' is not in temp dir '" + baseTemp + "'");
if (!pathIsInTempDir)
{
return;
}
#endregion
if (Directory.Exists(path))
{
try
{
foreach (string f in Directory.GetFiles(path, "*", SearchOption.AllDirectories))
{
new FileInfo(f).IsReadOnly = false;
}
foreach (string d in Directory.GetDirectories(path, "*", SearchOption.AllDirectories))
{
Misc.Dir_UnSetReadOnly(d);
}
}
catch (Exception ex)
{
Log("Exception setting temp path subtree to all non-readonly.\r\n" +
"path was: " + path, ex);
}
try
{
foreach (string f in FastIO.GetFilesTopOnly(path, "*"))
{
File.Delete(f);
}
foreach (string d in FastIO.GetDirsTopOnly(path, "*"))
{
Directory.Delete(d, recursive: true);
}
}
catch (Exception ex)
{
Log("Exception clearing temp path " + path, ex);
}
}
else
{
try
{
Directory.CreateDirectory(path);
}
catch (Exception ex)
{
Log("Exception creating temp path " + path, ex);
}
}
}
internal static async Task RestoreFM(FanMission fm)
{
if (!GameIsKnownAndSupported(fm.Game))
{
Log("Game type is unknown or unsupported (" + fm.Archive + ", " + fm.InstalledDir + ", " + fm.Game + ")", stackTrace: true);
return;
}
bool restoreSavesAndScreensOnly = Config.BackupFMData == BackupFMData.SavesAndScreensOnly &&
(fm.Game != Game.Thief3 || !Config.T3UseCentralSaves);
bool fmIsT3 = fm.Game == Game.Thief3;
await Task.Run(() =>
{
(string Name, bool DarkLoader)fileToUse = ("", false);
#region DarkLoader
string dlBakDir = Path.Combine(Config.FMsBackupPath, Paths.DarkLoaderSaveBakDir);
if (Directory.Exists(dlBakDir))
{
foreach (string f in FastIO.GetFilesTopOnly(dlBakDir, "*.zip"))
{
string fn = f.GetFileNameFast();
int index = fn.LastIndexOf("_saves.zip", StringComparison.OrdinalIgnoreCase);
if (index == -1)
{
continue;
}
string an = fn.Substring(0, index).Trim();
// Account for the fact that DarkLoader trims archive names for save backup zips
// Note: I guess it doesn't?! The code heavily implies it does. Still, it works either
// way, so whatever.
if (!an.IsEmpty() && an.PathEqualsI(fm.Archive.RemoveExtension().Trim()))
{
fileToUse = (f, true);
break;
}
}
}
#endregion
#region AngelLoader / FMSel / NewDarkLoader
if (fileToUse.Name.IsEmpty())
{
var bakFiles = new List <FileInfo>();
void AddBakFilesFrom(string path)
{
for (int i = 0; i < 2; i++)
{
string fNoExt = i == 0 ? fm.Archive.RemoveExtension() : fm.InstalledDir;
string bakFile = Path.Combine(path, fNoExt + Paths.FMBackupSuffix);
if (File.Exists(bakFile))
{
bakFiles.Add(new FileInfo(bakFile));
}
}
}
// Our backup path, separate to avoid creating any more ambiguity
AddBakFilesFrom(Config.FMsBackupPath);
// If ArchiveName.bak and InstalledName.bak files both exist, use the newest of the two
fileToUse.Name = bakFiles.Count == 1
? bakFiles[0].FullName
: bakFiles.Count > 1
? bakFiles.OrderByDescending(x => x.LastWriteTime).ToList()[0].FullName
: "";
bakFiles.Clear();
// Use file from our bak dir if it exists, otherwise use the newest file from all archive dirs
// (for automatic use of FMSel/NDL saves)
if (fileToUse.Name.IsEmpty())
{
foreach (string path in FMArchives.GetFMArchivePaths())
{
AddBakFilesFrom(path);
}
if (bakFiles.Count == 0)
{
return;
}
// Use the newest of all files found in all archive dirs
fileToUse.Name = bakFiles.OrderByDescending(x => x.LastWriteTime).ToList()[0].FullName;
}
}
#endregion
var fileExcludes = new List <string>();
//var dirExcludes = new List<string>();
string thisFMInstallsBasePath = Config.GetFMInstallPathUnsafe(fm.Game);
string fmInstalledPath = Path.Combine(thisFMInstallsBasePath, fm.InstalledDir);
using (var archive = GetZipArchiveCharEnc(fileToUse.Name))
{
int filesCount = archive.Entries.Count;
if (fileToUse.DarkLoader)
{
for (int i = 0; i < filesCount; i++)
{
var entry = archive.Entries[i];
string fn = entry.FullName;
if (!fn.ContainsDirSep())
{
Directory.CreateDirectory(Path.Combine(fmInstalledPath, _darkSavesDir));
entry.ExtractToFile(Path.Combine(fmInstalledPath, _darkSavesDir, fn), overwrite: true);
}
else if (fm.Game == Game.SS2 && (_ss2SaveDirsInZipRegex.IsMatch(fn) || fn.PathStartsWithI(_ss2CurrentDirS)))
{
Directory.CreateDirectory(Path.Combine(fmInstalledPath, fn.Substring(0, fn.LastIndexOfDirSep())));
entry.ExtractToFile(Path.Combine(fmInstalledPath, fn), overwrite: true);
}
}
}
else
{
string savesDirS = fmIsT3 ? _t3SavesDirS : _darkSavesDirS;
if (restoreSavesAndScreensOnly)
{
for (int i = 0; i < filesCount; i++)
{
var entry = archive.Entries[i];
string fn = entry.FullName;
if (fn.Length > 0 && !fn[fn.Length - 1].IsDirSep() &&
(fn.PathStartsWithI(savesDirS) ||
fn.PathStartsWithI(_darkNetSavesDirS) ||
fn.PathStartsWithI(_screensDirS) ||
(fm.Game == Game.SS2 &&
(_ss2SaveDirsInZipRegex.IsMatch(fn) || fn.PathStartsWithI(_ss2CurrentDirS)))))
{
Directory.CreateDirectory(Path.Combine(fmInstalledPath, fn.Substring(0, fn.LastIndexOfDirSep())));
entry.ExtractToFile(Path.Combine(fmInstalledPath, fn), overwrite: true);
}
}
}
else
{
var fmSelInf = archive.GetEntry(Paths.FMSelInf);
// Cap the length, cause... well, nobody's going to put a 500MB binary file named
// fmsel.inf, but hey...
// Null check required because GetEntry() can return null
if (fmSelInf?.Length < ByteSize.MB * 10)
{
using var eo = fmSelInf.Open();
using var sr = new StreamReader(eo);
string?line;
while ((line = sr.ReadLine()) != null)
{
bool startsWithRemoveFile = line.StartsWithFast_NoNullChecks(_removeFileEq);
bool startsWithRemoveDir = false;
if (!startsWithRemoveFile)
{
startsWithRemoveDir = line.StartsWithFast_NoNullChecks(_removeDirEq);
}
if (!startsWithRemoveFile && !startsWithRemoveDir)
{
continue;
}
string val = line.Substring(startsWithRemoveFile ? 11 : 10).Trim();
if (!val.PathStartsWithI(savesDirS) &&
!val.PathStartsWithI(_darkNetSavesDirS) &&
!val.PathStartsWithI(_screensDirS) &&
(fm.Game != Game.SS2 ||
(!_ss2SaveDirsInZipRegex.IsMatch(val) && !val.PathStartsWithI(_ss2CurrentDirS))) &&
!val.PathEqualsI(Paths.FMSelInf) &&
!val.PathEqualsI(_startMisSav) &&
// Reject malformed and/or maliciously formed paths - we're going to
// delete these files, and we don't want to delete anything outside
// the FM folder
!val.StartsWithDirSep() &&
!val.Contains(':') &&
// @DIRSEP: Critical: Check both / and \ here because we have no dirsep-agnostic string.Contains()
!val.Contains("./") &&
!val.Contains(".\\"))
{
if (startsWithRemoveFile)
{
fileExcludes.Add(val);
}
//else
//{
// dirExcludes.Add(val);
//}
}
}
}
for (int i = 0; i < filesCount; i++)
{
var f = archive.Entries[i];
string fn = f.FullName;
if (fn.PathEqualsI(Paths.FMSelInf) ||
fn.PathEqualsI(_startMisSav) ||
(fn.Length > 0 && fn[fn.Length - 1].IsDirSep()) ||
fileExcludes.PathContainsI(fn))
{
continue;
}
if (fn.ContainsDirSep())
{
Directory.CreateDirectory(Path.Combine(fmInstalledPath, fn.Substring(0, fn.LastIndexOfDirSep())));
}
f.ExtractToFile(Path.Combine(fmInstalledPath, fn), overwrite: true);
}
}
}
}
if (!restoreSavesAndScreensOnly)
{
foreach (string f in Directory.GetFiles(fmInstalledPath, "*", SearchOption.AllDirectories))
{
if (fileExcludes.PathContainsI(f.Substring(fmInstalledPath.Length).Trim(CA_BS_FS)))
{
// TODO: Deleted dirs are not detected, they're detected as "delete every file in this dir"
// If we have crf files replacing dirs, the empty dir will override the crf. We want
// to store whether dirs were actually removed so we can remove them again.
File.Delete(f);
}
}
// Disabled till this is working completely
#if false
// Crappy hack method
var crfs = Directory.GetFiles(fmInstalledPath, "*.crf", SearchOption.TopDirectoryOnly);
var dirRemoveList = new List <string>();
foreach (string d in Directory.GetDirectories(fmInstalledPath, "*", SearchOption.TopDirectoryOnly))
{
string dt = d.GetDirNameFast();
if (Directory.GetFiles(d, "*", SearchOption.AllDirectories).Length == 0)
{
for (int i = 0; i < crfs.Length; i++)
{
string ft = crfs[i].GetFileNameFast().RemoveExtension();
if (ft.PathEqualsI(dt))
{
dirRemoveList.Add(d);
}
}
}
}
if (dirRemoveList.Count > 0)
{
for (int i = 0; i < dirRemoveList.Count; i++)
{
Directory.Delete(dirRemoveList[i], recursive: true);
}
}
// Proper method
foreach (string d in Directory.GetDirectories(fmInstalledPath, "*", SearchOption.AllDirectories))
{
if (dirExcludes.PathContainsI(d.Substring(fmInstalledPath.Length).Trim(CA_BS_FS)))
{
Directory.Delete(d, recursive: true);
}
}
#endif
}
if (fileToUse.DarkLoader)
{
string dlOrigBakDir = Path.Combine(Config.FMsBackupPath, Paths.DarkLoaderSaveOrigBakDir);
Directory.CreateDirectory(dlOrigBakDir);
File.Move(fileToUse.Name, Path.Combine(dlOrigBakDir, fileToUse.Name.GetFileNameFast()));
}
});
}
private static async Task <CacheData> GetCacheableDataInFMCacheDir(FanMission fm, bool refreshCache)
{
var readmes = new List <string>();
AssertR(!fm.InstalledDir.IsEmpty(), "fm.InstalledFolderName is null or empty");
string fmCachePath = Path.Combine(Paths.FMsCache, fm.InstalledDir);
if (Directory.Exists(fmCachePath))
{
foreach (string fn in FastIO.GetFilesTopOnly(fmCachePath, "*"))
{
if (fn.IsValidReadme() && new FileInfo(fn).Length > 0)
{
readmes.Add(fn.Substring(fmCachePath.Length + 1));
}
}
for (int i = 0; i < 2; i++)
{
string t3ReadmePath = Path.Combine(fmCachePath, i == 0 ? Paths.T3ReadmeDir1 : Paths.T3ReadmeDir2);
if (Directory.Exists(t3ReadmePath))
{
foreach (string fn in FastIO.GetFilesTopOnly(t3ReadmePath, "*"))
{
if (fn.IsValidReadme() && new FileInfo(fn).Length > 0)
{
readmes.Add(fn.Substring(fmCachePath.Length + 1));
}
}
}
}
bool checkArchive = refreshCache || (readmes.Count == 0 && !fm.NoReadmes);
if (!checkArchive)
{
return(new CacheData(readmes));
}
}
// If cache dir DOESN'T exist, the above checkArchive decision won't be run, so run it here (prevents
// FMs with no readmes from being reloaded from their archive all the time, which is the whole purpose
// of NoReadmes in the first place).
if (!refreshCache && fm.NoReadmes)
{
return(new CacheData());
}
readmes.Clear();
ClearCacheDir(fm);
string fmArchivePath = FindFMArchive(fm.Archive);
// In weird situations this could be true, so just say none and at least don't crash
if (fmArchivePath.IsEmpty())
{
return(new CacheData());
}
if (fm.Archive.ExtIsZip())
{
ZipExtract(fmArchivePath, fmCachePath, readmes);
// TODO: Support HTML ref extraction for .7z files too
// Will require full extract for the same reason scan does - we need to scan files to know what
// other files to scan, etc. and a full extract is with 99.9999% certainty going to be faster
// than chugging through the whole thing over and over and over for each new file we find we need
// Guard check so we don't do useless HTML work if we don't have any HTML readmes
bool htmlReadmeExists = false;
for (int i = 0; i < readmes.Count; i++)
{
if (readmes[i].ExtIsHtml())
{
htmlReadmeExists = true;
break;
}
}
if (htmlReadmeExists && Directory.Exists(fmCachePath))
{
try
{
ExtractHTMLRefFiles(fmArchivePath, fmCachePath);
}
catch (Exception ex)
{
Log("Exception in " + nameof(ExtractHTMLRefFiles), ex);
}
}
}
else
{
await SevenZipExtract(fmArchivePath, fmCachePath, readmes);
}
fm.NoReadmes = readmes.Count == 0;
return(new CacheData(readmes));
}