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)); }