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())); } }); }
// MT: On startup only, this is run in parallel with MainForm.ctor and .InitThreadable() // So don't touch anything the other touches: anything affecting the view. // @CAN_RUN_BEFORE_VIEW_INIT private static List <int> FindInternal(bool startup) { if (!startup) { // Make sure we don't lose anything when we re-find! // NOTE: This also writes out TagsStrings and then reads them back in and syncs them with Tags. // Critical that that gets done. Ini.WriteFullFMDataIni(); // Do this every time we modify FMsViewList in realtime, to prevent FMsDGV from redrawing from // the list when it's in an indeterminate state (which can cause a selection change (bad) and/or // a visible change of the list (not really bad but unprofessional looking)). // MT: Don't do this on startup because we're running in parallel with the form new/init in that case. Core.View.SetRowCount(0); } // Init or reinit - must be deep-copied or changes propagate back because reference types // MT: This is thread-safe, the view ctor and InitThreadable() doesn't touch it. PresetTags.DeepCopyTo(GlobalTags); #region Back up lists and read FM data file // Copy FMs to backup lists before clearing, in case we can't read the ini file. We don't want to end // up with a blank or incomplete list and then glibly save it out later. FanMission[] backupList = new FanMission[FMDataIniList.Count]; FMDataIniList.CopyTo(backupList); FanMission[] viewBackupList = new FanMission[FMsViewList.Count]; FMsViewList.CopyTo(viewBackupList); FMDataIniList.Clear(); FMsViewList.Clear(); bool fmDataIniExists = File.Exists(Paths.FMDataIni); if (fmDataIniExists) { try { Ini.ReadFMDataIni(Paths.FMDataIni, FMDataIniList); } catch (Exception ex) { Log("Exception reading FM data ini", ex); if (startup) { // Language will be loaded by this point Dialogs.ShowError(LText.AlertMessages.FindFMs_ExceptionReadingFMDataIni); Core.EnvironmentExitDoShutdownTasks(1); } else { FMDataIniList.ClearAndAdd(backupList); FMsViewList.ClearAndAdd(viewBackupList); return(new List <int>()); } } } #endregion #region Get installed dirs from disk // Could check inside the folder for a .mis file to confirm it's really an FM folder, but that's // horrendously expensive. Talking like eight seconds vs. < 4ms for the 1098 set. Weird. var perGameInstFMDirsList = new List <List <string> >(SupportedGameCount); var perGameInstFMDirsDatesList = new List <List <DateTime> >(SupportedGameCount); for (int gi = 0; gi < SupportedGameCount; gi++) { // NOTE! Make sure this list ends up with SupportedGameCount items in it. Just in case I change // the loop or something. perGameInstFMDirsList.Add(new List <string>()); perGameInstFMDirsDatesList.Add(new List <DateTime>()); string instPath = Config.GetFMInstallPath((GameIndex)gi); if (Directory.Exists(instPath)) { try { var dirs = FastIO.GetDirsTopOnly_FMs(instPath, "*", out List <DateTime> dateTimes); for (int di = 0; di < dirs.Count; di++) { string d = dirs[di]; if (!d.EqualsI(Paths.FMSelCache)) { perGameInstFMDirsList[gi].Add(d); perGameInstFMDirsDatesList[gi].Add(dateTimes[di]); } } } catch (Exception ex) { Log("Exception getting directories in " + instPath, ex); } } } #endregion #region Get archives from disk var fmArchivesAndDatesDict = new DictionaryI <DateTime>(); var archivePaths = FMArchives.GetFMArchivePaths(); bool onlyOnePath = archivePaths.Count == 1; for (int ai = 0; ai < archivePaths.Count; ai++) { try { // Returns filenames only (not full paths) var files = FastIO.GetFilesTopOnly_FMs(archivePaths[ai], "*", out List <DateTime> dateTimes); for (int fi = 0; fi < files.Count; fi++) { string f = files[fi]; // Do this first because it should be faster than a dictionary lookup if (!f.ExtIsArchive()) { continue; } // NOTE: We do a ContainsKey check to keep behavior the same as previously. When we use // dict[key] = value, it _replaces_ the value with the new one every time. What we want // is for it to just not touch it at all if the key is already in there. This check does // technically slow it down some, but the actual perf degradation is negligible. And we // still avoid the n-squared 1.6-million-call nightmare we get with ~1600 FMs in the list. // Nevertheless, we can avoid even this small extra cost if we only have one FM archive // path, so no harm in keeping the only-one-path check. if ((onlyOnePath || !fmArchivesAndDatesDict.ContainsKey(f)) && // @DIRSEP: These are filename only, no need for PathContainsI() !f.ContainsI(Paths.FMSelBak)) { fmArchivesAndDatesDict[f] = dateTimes[fi]; } } } catch (Exception ex) { Log("Exception getting files in " + archivePaths[ai], ex); } } int fmArchivesAndDatesDictLen = fmArchivesAndDatesDict.Count; // PERF_TODO: May want to keep these as dicts later or change other vars to dicts string[] fmArchives = new string[fmArchivesAndDatesDictLen]; DateTime[] fmArchivesDates = new DateTime[fmArchivesAndDatesDictLen]; { int i = 0; foreach (var item in fmArchivesAndDatesDict) { fmArchives[i] = item.Key; fmArchivesDates[i] = item.Value; i++; } } #endregion #region Build FanMission objects from installed dirs var perGameFMsList = new List <List <FanMission> >(SupportedGameCount); for (int gi = 0; gi < SupportedGameCount; gi++) { // NOTE! List must have SupportedGameCount items in it perGameFMsList.Add(new List <FanMission>()); for (int di = 0; di < perGameInstFMDirsList[gi].Count; di++) { perGameFMsList[gi].Add(new FanMission { InstalledDir = perGameInstFMDirsList[gi][di], Game = GameIndexToGame((GameIndex)gi), Installed = true }); } } #endregion MergeNewArchiveFMs(fmArchives, fmArchivesDates); int instInitCount = FMDataIniList.Count; for (int i = 0; i < SupportedGameCount; i++) { var curGameInstFMsList = perGameFMsList[i]; if (curGameInstFMsList.Count > 0) { MergeNewInstalledFMs(curGameInstFMsList, perGameInstFMDirsDatesList[i], instInitCount); } } SetArchiveNames(fmArchives); SetInstalledNames(); // Super quick-n-cheap hack for perf: So we don't have to iterate the whole list looking for unscanned // FMs. This will contain indexes into FMDataIniList (not FMsViewList!) var fmsViewListUnscanned = new List <int>(FMDataIniList.Count); BuildViewList(fmArchives, perGameInstFMDirsList, fmsViewListUnscanned); return(fmsViewListUnscanned); /* * TODO: There's an extreme corner case where duplicate FMs can appear in the list * It's so unlikely it's almost not worth worrying about, but here's the scenario: * -The FM is installed by hand and not truncated * -The FM is not in the list * -A matching archive exists for the FM * In this scenario, the FM is added twice to the list, once with the full installed folder name and * NoArchive set to true, and once with a truncated installed dir name, the correct archive name, and * NoArchive not present (false). * The code in here is so crazy-go-nuts I can't even find where this is happening. But putting this * note down for the future. */ }