Exemple #1
0
        internal static int IncrementalPatchComparison(IncrementalPatch patch1, IncrementalPatch patch2)
        {
            int comparison = patch1.FromVersion.CompareTo(patch2.FromVersion);

            if (comparison != 0)
            {
                return(comparison);
            }

            // If FromVersion's are the same, the patch with higher ToVersion should be put in front of the other
            return(patch2.ToVersion.CompareTo(patch1.ToVersion));
        }
Exemple #2
0
        public string GetInfoURLFor(IncrementalPatch patch)
        {
            if (!string.IsNullOrEmpty(patch.InfoURL))
            {
                return(patch.InfoURL);
            }

            if (!string.IsNullOrEmpty(BaseDownloadURL))
            {
                return(BaseDownloadURL + PatchParameters.INCREMENTAL_PATCH_DIRECTORY + '/' + patch.PatchVersion() + PatchParameters.PATCH_INFO_EXTENSION);
            }

            return(null);
        }
Exemple #3
0
 public static string PatchVersion(this IncrementalPatch incrementalPatch)
 {
     return(incrementalPatch.FromVersion.ToString().Replace('.', '_') + "__" + incrementalPatch.ToVersion.ToString().Replace('.', '_'));
 }
Exemple #4
0
 public static string PatchVersionBrief(this IncrementalPatch incrementalPatch)
 {
     return(incrementalPatch.FromVersion + "_" + incrementalPatch.ToVersion);
 }
        public bool UpdateDownloadLinks(Dictionary <string, string> downloadLinks)
        {
            // Replace all AltDirectorySeparatorChar's with DirectorySeparatorChar's in the dictionary keys
            List <string> keys = new List <string>(downloadLinks.Keys);

            for (int i = 0; i < keys.Count; i++)
            {
                string key = keys[i];
                if (key.IndexOf(PatchUtils.AltDirectorySeparatorChar) >= 0)
                {
                    downloadLinks[key.Replace(PatchUtils.AltDirectorySeparatorChar, Path.DirectorySeparatorChar)] = downloadLinks[key];
                    downloadLinks.Remove(key);
                }
            }

            int updateCount = 0;
            int totalCount  = VersionInfo.Files.Count + VersionInfo.IncrementalPatches.Count;

            for (int i = 0; i < VersionInfo.Files.Count; i++)
            {
                VersionItem item = VersionInfo.Files[i];

                string downloadLink;
                string relativePath = item.Path.Replace(PatchUtils.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
                if (downloadLinks.TryGetValue(relativePath, out downloadLink) ||
                    downloadLinks.TryGetValue(relativePath + PatchParameters.REPAIR_PATCH_FILE_EXTENSION, out downloadLink) ||
                    downloadLinks.TryGetValue(PatchParameters.REPAIR_PATCH_DIRECTORY + Path.DirectorySeparatorChar + relativePath, out downloadLink) ||
                    downloadLinks.TryGetValue(PatchParameters.REPAIR_PATCH_DIRECTORY + Path.DirectorySeparatorChar + relativePath + PatchParameters.REPAIR_PATCH_FILE_EXTENSION, out downloadLink))
                {
                    item.DownloadURL = downloadLink;
                    updateCount++;
                }
            }

            for (int i = 0; i < VersionInfo.IncrementalPatches.Count; i++)
            {
                IncrementalPatch patch = VersionInfo.IncrementalPatches[i];

                string downloadLink;
                string relativePath = patch.PatchVersion() + PatchParameters.INCREMENTAL_PATCH_FILE_EXTENSION;
                if (downloadLinks.TryGetValue(relativePath, out downloadLink) ||
                    downloadLinks.TryGetValue(PatchParameters.INCREMENTAL_PATCH_DIRECTORY + Path.DirectorySeparatorChar + relativePath, out downloadLink))
                {
                    patch.DownloadURL = downloadLink;
                    updateCount++;
                }

                relativePath = patch.PatchVersion() + PatchParameters.INCREMENTAL_PATCH_INFO_EXTENSION;
                if (downloadLinks.TryGetValue(relativePath, out downloadLink) ||
                    downloadLinks.TryGetValue(PatchParameters.INCREMENTAL_PATCH_DIRECTORY + Path.DirectorySeparatorChar + relativePath, out downloadLink))
                {
                    patch.InfoURL = downloadLink;
                    updateCount++;
                }

                if (patch.Files > 0)
                {
                    totalCount++;
                }
            }

            if (VersionInfo.InstallerPatch.PatchSize > 0L || !string.IsNullOrEmpty(VersionInfo.InstallerPatch.PatchMd5Hash))
            {
                string downloadLink;
                string relativePath = PatchParameters.INSTALLER_PATCH_FILENAME;
                if (downloadLinks.TryGetValue(relativePath, out downloadLink) ||
                    downloadLinks.TryGetValue(PatchParameters.INSTALLER_PATCH_DIRECTORY + Path.DirectorySeparatorChar + relativePath, out downloadLink))
                {
                    VersionInfo.InstallerPatch.DownloadURL = downloadLink;
                    updateCount++;
                }

                totalCount++;
            }

            if (Logger != null)
            {
                Logger(Localization.Get(StringId.XDownloadLinksAreUpdatedSuccessfully, updateCount, totalCount));
            }

            return(true);
        }
        private PatchResult Patch()
        {
            PatchStage = PatchStage.CheckingUpdates;

            Stopwatch timer = Stopwatch.StartNew();

            comms.Log(Localization.Get(StringId.RetrievingVersionInfo));

            if (!FetchVersionInfo())
            {
                return(PatchResult.Failed);
            }

            if (comms.IsUnderMaintenance())
            {
                return(PatchResult.Failed);
            }

            if (!currentVersion.IsValid)
            {
                currentVersion = new VersionCode(0);
            }

            VersionCode rootVersion = currentVersion;

            if (comms.SelfPatching)
            {
                VersionCode patchedVersion = PatchUtils.GetVersion(comms.DecompressedFilesPath, comms.VersionInfo.Name);
                if (patchedVersion > currentVersion)
                {
                    currentVersion = patchedVersion;
                }
            }

            PatchStage = PatchStage.CheckingFileIntegrity;

            if (CheckLocalFilesUpToDate(true, false))
            {
                return(PatchResult.AlreadyUpToDate);
            }

            if (!PatchUtils.CheckWriteAccessToFolder(comms.RootPath))
            {
                FailReason  = PatchFailReason.RequiresAdminPriviledges;
                FailDetails = Localization.Get(StringId.E_AccessToXIsForbiddenRunInAdminMode, comms.RootPath);

                return(PatchResult.Failed);
            }

            if (!PatchUtils.CheckWriteAccessToFolder(comms.CachePath))
            {
                FailReason  = PatchFailReason.RequiresAdminPriviledges;
                FailDetails = Localization.Get(StringId.E_AccessToXIsForbiddenRunInAdminMode, comms.CachePath);

                return(PatchResult.Failed);
            }

            if (checkForMultipleRunningInstances)
            {
                string currentExecutablePath = PatchUtils.GetCurrentExecutablePath();
                if (PatchUtils.GetNumberOfRunningProcesses(currentExecutablePath) > 1)
                {
                    FailReason  = PatchFailReason.MultipleRunningInstances;
                    FailDetails = Localization.Get(StringId.E_AnotherInstanceOfXIsRunning, Path.GetFileName(currentExecutablePath));

                    return(PatchResult.Failed);
                }
            }

            if (comms.Cancel)
            {
                return(PatchResult.Failed);
            }

            // Add a date holder file to the cache to save the last access time reliably
            DateTime dateTimeNow = DateTime.UtcNow;

            File.WriteAllText(comms.CachePath + PatchParameters.CACHE_DATE_HOLDER_FILENAME, dateTimeNow.ToString("O"));

            // Check if there are any leftover files from other SimplePatchTool integrated apps in cache
            DirectoryInfo[] patcherCaches = new DirectoryInfo(comms.CachePath).Parent.GetDirectories();
            for (int i = 0; i < patcherCaches.Length; i++)
            {
                DirectoryInfo cacheDir = patcherCaches[i];
                if (cacheDir.Name.Equals(comms.VersionInfo.Name, StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                FileInfo dateHolder = new FileInfo(PatchUtils.GetPathWithTrailingSeparatorChar(cacheDir.FullName) + PatchParameters.CACHE_DATE_HOLDER_FILENAME);
                if (dateHolder.Exists && dateHolder.Length > 0L)
                {
                    DateTime lastAccessTime;
                    if (DateTime.TryParseExact(File.ReadAllText(dateHolder.FullName), "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out lastAccessTime))
                    {
                        if ((dateTimeNow - lastAccessTime).TotalDays <= PatchParameters.CACHE_DATE_EXPIRE_DAYS)
                        {
                            continue;
                        }
                    }
                }

                // This cache directory doesn't have a date holder file or is older than CACHE_DATE_EXPIRE_DAYS, delete it
                cacheDir.Delete(true);
            }

            bool canRepairPatch      = this.canRepairPatch;
            bool canIncrementalPatch = this.canIncrementalPatch;
            bool canInstallerPatch   = this.canInstallerPatch;

            List <PatchMethodHolder> preferredPatchMethods = new List <PatchMethodHolder>(3);
            List <VersionItem>       versionInfoFiles      = comms.VersionInfo.Files;

            if (canRepairPatch)
            {
                for (int i = 0; i < versionInfoFiles.Count; i++)
                {
                    VersionItem item = versionInfoFiles[i];
                    if (item.CompressedFileSize == 0L && string.IsNullOrEmpty(item.CompressedMd5Hash))
                    {
                        canRepairPatch = false;
                        break;
                    }
                }

                if (canRepairPatch)
                {
                    long repairPatchSize = 0L;
                    for (int i = 0; i < versionInfoFiles.Count; i++)
                    {
                        VersionItem item      = versionInfoFiles[i];
                        FileInfo    localFile = new FileInfo(comms.RootPath + item.Path);
                        if (localFile.Exists && localFile.MatchesSignature(item.FileSize, item.Md5Hash))
                        {
                            continue;
                        }

                        FileInfo downloadedFile = new FileInfo(comms.DownloadsPath + item.Path);
                        if (downloadedFile.Exists && downloadedFile.MatchesSignature(item.CompressedFileSize, item.CompressedMd5Hash))
                        {
                            continue;
                        }

                        if (comms.SelfPatching)
                        {
                            FileInfo decompressedFile = new FileInfo(comms.DecompressedFilesPath + item.Path);
                            if (decompressedFile.Exists && decompressedFile.MatchesSignature(item.FileSize, item.Md5Hash))
                            {
                                continue;
                            }
                        }

                        repairPatchSize += item.CompressedFileSize;
                    }

                    preferredPatchMethods.Add(new PatchMethodHolder(PatchMethod.RepairPatch, repairPatchSize));
                }
            }

            if (canIncrementalPatch)
            {
                // Find incremental patches to apply
                VersionCode             thisVersion        = rootVersion;
                List <IncrementalPatch> versionInfoPatches = comms.VersionInfo.IncrementalPatches;
                for (int i = 0; i < versionInfoPatches.Count; i++)
                {
                    if (thisVersion == comms.VersionInfo.Version)
                    {
                        break;
                    }

                    IncrementalPatch patch = versionInfoPatches[i];
                    if (thisVersion == patch.FromVersion)
                    {
                        thisVersion = patch.ToVersion;
                        incrementalPatches.Add(patch);
                    }
                }

                if (thisVersion != comms.VersionInfo.Version)
                {
                    incrementalPatches.Clear();
                }

                if (incrementalPatches.Count == 0)
                {
                    canIncrementalPatch = false;
                }
                else
                {
                    long incrementalPatchSize = 0L;
                    for (int i = 0; i < incrementalPatches.Count; i++)
                    {
                        IncrementalPatch incrementalPatch = incrementalPatches[i];
                        if (currentVersion > incrementalPatch.FromVersion)
                        {
                            continue;
                        }

                        FileInfo patchFile = new FileInfo(comms.GetDownloadPathForPatch(incrementalPatch.PatchVersion()));
                        if (patchFile.Exists && patchFile.MatchesSignature(incrementalPatch.PatchSize, incrementalPatch.PatchMd5Hash))
                        {
                            continue;
                        }

                        incrementalPatchSize += incrementalPatch.PatchSize;
                    }

                    preferredPatchMethods.Add(new PatchMethodHolder(PatchMethod.IncrementalPatch, incrementalPatchSize));
                }
            }

            if (canInstallerPatch)
            {
                InstallerPatch installerPatch = comms.VersionInfo.InstallerPatch;
                if (installerPatch.PatchSize == 0L && string.IsNullOrEmpty(installerPatch.PatchMd5Hash))
                {
                    canInstallerPatch = false;
                }
                else
                {
                    preferredPatchMethods.Add(new PatchMethodHolder(PatchMethod.InstallerPatch, installerPatch.PatchSize));
                }
            }

            preferredPatchMethods.Sort((p1, p2) => p1.size.CompareTo(p2.size));

            if (preferredPatchMethods.Count == 0)
            {
                FailReason  = PatchFailReason.NoSuitablePatchMethodFound;
                FailDetails = Localization.Get(StringId.E_NoSuitablePatchMethodFound);

                return(PatchResult.Failed);
            }

            // Check if there is enough free disk space
            long requiredFreeSpaceInCache = preferredPatchMethods[0].size, requiredFreeSpaceInRoot = 0L;

            for (int i = 0; i < versionInfoFiles.Count; i++)
            {
                VersionItem item      = versionInfoFiles[i];
                FileInfo    localFile = new FileInfo(comms.RootPath + item.Path);
                if (!localFile.Exists)
                {
                    requiredFreeSpaceInCache += item.FileSize;
                    requiredFreeSpaceInRoot  += item.FileSize;
                }
                else if (!localFile.MatchesSignature(item.FileSize, item.Md5Hash))
                {
                    requiredFreeSpaceInCache += item.FileSize;

                    long deltaSize = item.FileSize - localFile.Length;
                    if (deltaSize > 0L)
                    {
                        requiredFreeSpaceInRoot += deltaSize;
                    }
                }
            }

            requiredFreeSpaceInCache += requiredFreeSpaceInCache / 3;    // Require additional 33% free space (might be needed by compressed files and/or incremental patches)
            requiredFreeSpaceInCache += 1024 * 1024 * 1024L;             // Require additional 1 GB of free space, just in case

            string rootDrive = new DirectoryInfo(comms.RootPath).Root.FullName;
            string cacheDrive = new DirectoryInfo(comms.CachePath).Root.FullName;

            if (rootDrive.Equals(cacheDrive, StringComparison.OrdinalIgnoreCase))
            {
                if (!CheckFreeSpace(rootDrive, requiredFreeSpaceInCache + requiredFreeSpaceInRoot))
                {
                    return(PatchResult.Failed);
                }
            }
            else
            {
                if (!CheckFreeSpace(rootDrive, requiredFreeSpaceInRoot))
                {
                    return(PatchResult.Failed);
                }

                if (!CheckFreeSpace(cacheDrive, requiredFreeSpaceInCache))
                {
                    return(PatchResult.Failed);
                }
            }

            for (int i = 0; i < preferredPatchMethods.Count; i++)
            {
                comms.LogToFile(Localization.Get(StringId.PatchMethodXSizeY, preferredPatchMethods[i].method, preferredPatchMethods[i].size.ToMegabytes() + "MB"));
            }

            // Start patching
            for (int i = 0; i < preferredPatchMethods.Count; i++)
            {
                PatchMethod patchMethod = preferredPatchMethods[i].method;

                bool success;
                if (patchMethod == PatchMethod.RepairPatch)
                {
                    PatchMethod = PatchMethod.RepairPatch;
                    comms.ListenerCallPatchMethodChanged(PatchMethod);

                    success = PatchUsingRepairPatch();
                }
                else if (patchMethod == PatchMethod.IncrementalPatch)
                {
                    PatchMethod = PatchMethod.IncrementalPatch;
                    comms.ListenerCallPatchMethodChanged(PatchMethod);

                    success = PatchUsingIncrementalPatches();
                }
                else
                {
                    PatchMethod = PatchMethod.InstallerPatch;
                    comms.ListenerCallPatchMethodChanged(PatchMethod);

                    success = PatchUsingInstallerPatch();
                }

                if (comms.Cancel)
                {
                    return(PatchResult.Failed);
                }

                if (success)
                {
                    break;
                }
                else
                {
                    comms.LogToFile(string.Concat(comms.FailReason, ": ", comms.FailDetails));

                    if (i == preferredPatchMethods.Count - 1)
                    {
                        return(PatchResult.Failed);
                    }
                }
            }

            PatchStage = PatchStage.CheckingFileIntegrity;

            if (!CheckLocalFilesUpToDate(false, comms.SelfPatching))
            {
                comms.Log(Localization.Get(StringId.SomeFilesAreStillNotUpToDate));

                if (canRepairPatch)
                {
                    if (!PatchUsingRepairPatch())
                    {
                        return(PatchResult.Failed);
                    }
                }
                else
                {
                    FailReason  = PatchFailReason.FilesAreNotUpToDateAfterPatch;
                    FailDetails = Localization.Get(StringId.E_FilesAreNotUpToDateAfterPatch);

                    return(PatchResult.Failed);
                }
            }

            comms.UpdateVersion(comms.VersionInfo.Version);

            PatchStage = PatchStage.DeletingObsoleteFiles;
            comms.Log(Localization.Get(StringId.CalculatingObsoleteFiles));

            List <string> obsoleteFiles = FindFilesToDelete(comms.RootPath);

            if (!comms.SelfPatching)
            {
                if (obsoleteFiles.Count > 0)
                {
                    comms.Log(Localization.Get(StringId.DeletingXObsoleteFiles, obsoleteFiles.Count));
                    for (int i = 0; i < obsoleteFiles.Count; i++)
                    {
                        comms.Log(Localization.Get(StringId.DeletingX, obsoleteFiles[i]));
                        File.Delete(comms.RootPath + obsoleteFiles[i]);
                    }
                }
                else
                {
                    comms.Log(Localization.Get(StringId.NoObsoleteFiles));
                }

                PatchUtils.DeleteDirectory(comms.CachePath);
            }
            else
            {
                // Delete obsolete self patching files
                List <string> obsoleteSelfPatchingFiles = FindFilesToDelete(comms.DecompressedFilesPath);
                if (obsoleteSelfPatchingFiles.Count > 0)
                {
                    comms.Log(Localization.Get(StringId.DeletingXObsoleteFiles, obsoleteSelfPatchingFiles.Count));
                    for (int i = 0; i < obsoleteSelfPatchingFiles.Count; i++)
                    {
                        comms.Log(Localization.Get(StringId.DeletingX, obsoleteSelfPatchingFiles[i]));
                        File.Delete(comms.DecompressedFilesPath + obsoleteSelfPatchingFiles[i]);
                    }
                }
                else
                {
                    comms.Log(Localization.Get(StringId.NoObsoleteFiles));
                }

                // Self patcher executable, if exists, can't self patch itself, so patch it manually here
                // This assumes that self patcher and any related files are located at SELF_PATCHER_DIRECTORY
                string selfPatcherFiles = comms.DecompressedFilesPath + PatchParameters.SELF_PATCHER_DIRECTORY;
                if (Directory.Exists(selfPatcherFiles))
                {
                    PatchUtils.MoveDirectory(selfPatcherFiles, comms.RootPath + PatchParameters.SELF_PATCHER_DIRECTORY);
                }

                string        separator = PatchParameters.SELF_PATCH_OP_SEPARATOR;
                StringBuilder sb        = new StringBuilder(500);

                // Append current version to the beginning of the file
                sb.Append(rootVersion);

                // 1. Rename files
                if (incrementalPatchesInfo.Count > 0)
                {
                    sb.Append(separator).Append(PatchParameters.SELF_PATCH_MOVE_OP);
                    for (int i = 0; i < incrementalPatchesInfo.Count; i++)
                    {
                        IncrementalPatchInfo incrementalPatch = incrementalPatchesInfo[i];
                        for (int j = 0; j < incrementalPatch.RenamedFiles.Count; j++)
                        {
                            PatchRenamedItem renamedItem = incrementalPatch.RenamedFiles[j];
                            sb.Append(separator).Append(comms.RootPath + renamedItem.BeforePath).Append(separator).Append(comms.RootPath + renamedItem.AfterPath);
                        }
                    }
                }

                // 2. Update files
                sb.Append(separator).Append(PatchParameters.SELF_PATCH_MOVE_OP);

                DirectoryInfo   updatedFilesDir       = new DirectoryInfo(comms.DecompressedFilesPath);
                DirectoryInfo[] updatedSubDirectories = updatedFilesDir.GetDirectories();
                for (int i = 0; i < updatedSubDirectories.Length; i++)
                {
                    sb.Append(separator).Append(comms.DecompressedFilesPath).Append(updatedSubDirectories[i].Name).Append(Path.DirectorySeparatorChar).Append(separator).Append(comms.RootPath).Append(updatedSubDirectories[i].Name).Append(Path.DirectorySeparatorChar);
                }

                string     versionHolderFilename = comms.VersionInfo.Name + PatchParameters.VERSION_HOLDER_FILENAME_POSTFIX;
                FileInfo[] updatedFiles          = updatedFilesDir.GetFiles();
                for (int i = 0; i < updatedFiles.Length; i++)
                {
                    // Don't update the version holder file until everything else is updated properly
                    if (updatedFiles[i].Name != versionHolderFilename)
                    {
                        sb.Append(separator).Append(comms.DecompressedFilesPath).Append(updatedFiles[i].Name).Append(separator).Append(comms.RootPath).Append(updatedFiles[i].Name);
                    }
                }

                // Update the version holder now
                sb.Append(separator).Append(comms.DecompressedFilesPath).Append(versionHolderFilename).Append(separator).Append(comms.RootPath).Append(versionHolderFilename);

                // 3. Delete obsolete files
                if (obsoleteFiles.Count > 0)
                {
                    string selfPatcherDirectory = PatchParameters.SELF_PATCHER_DIRECTORY + Path.DirectorySeparatorChar;
                    sb.Append(separator).Append(PatchParameters.SELF_PATCH_DELETE_OP);

                    comms.Log(Localization.Get(StringId.DeletingXObsoleteFiles, obsoleteFiles.Count));
                    for (int i = 0; i < obsoleteFiles.Count; i++)
                    {
                        // Delete the obsolete files inside SELF_PATCHER_DIRECTORY manually
                        string absolutePath = comms.RootPath + obsoleteFiles[i];
                        if (obsoleteFiles[i].StartsWith(selfPatcherDirectory, StringComparison.OrdinalIgnoreCase))
                        {
                            comms.Log(Localization.Get(StringId.DeletingX, obsoleteFiles[i]));

                            if (File.Exists(absolutePath))
                            {
                                File.Delete(absolutePath);
                            }
                            else if (Directory.Exists(absolutePath))
                            {
                                PatchUtils.DeleteDirectory(absolutePath);
                            }
                        }
                        else
                        {
                            // '-->' indicates that the file will be deleted by the self patcher executable
                            comms.LogToFile(Localization.Get(StringId.DeletingX, "--> " + obsoleteFiles[i]));
                            sb.Append(separator).Append(absolutePath);
                        }
                    }
                }
                else
                {
                    comms.Log(Localization.Get(StringId.NoObsoleteFiles));
                }

                sb.Append(separator).Append(comms.CachePath);

                File.Delete(comms.CachePath + PatchParameters.SELF_PATCH_COMPLETED_INSTRUCTIONS_FILENAME);
                File.WriteAllText(comms.CachePath + PatchParameters.SELF_PATCH_INSTRUCTIONS_FILENAME, sb.Append(separator).ToString());
            }

            comms.Log(Localization.Get(StringId.PatchCompletedInXSeconds, timer.ElapsedSeconds()));
            return(PatchResult.Success);
        }
        private bool PatchUsingIncrementalPatches()
        {
            if (comms.Cancel)
            {
                return(false);
            }

            comms.LogToFile(Localization.Get(StringId.ApplyingIncrementalPatch));

            if (incrementalPatches.Count == 0)
            {
                return(false);
            }

            if (comms.VerifyFiles)
            {
                PatchStage = PatchStage.VerifyingFilesOnServer;

                for (int i = 0; i < incrementalPatches.Count; i++)
                {
                    if (comms.Cancel)
                    {
                        return(false);
                    }

                    IncrementalPatch incrementalPatch = incrementalPatches[i];
                    long             fileSize;
                    if (!comms.DownloadManager.FileExistsAtUrl(comms.VersionInfo.GetInfoURLFor(incrementalPatch), out fileSize))
                    {
                        FailReason  = PatchFailReason.FileDoesNotExistOnServer;
                        FailDetails = Localization.Get(StringId.E_FileXDoesNotExistOnServer, incrementalPatch.PatchVersion() + PatchParameters.INCREMENTAL_PATCH_INFO_EXTENSION);

                        return(false);
                    }

                    if (incrementalPatch.Files > 0)
                    {
                        if (!comms.DownloadManager.FileExistsAtUrl(comms.VersionInfo.GetDownloadURLFor(incrementalPatch), out fileSize))
                        {
                            FailReason  = PatchFailReason.FileDoesNotExistOnServer;
                            FailDetails = Localization.Get(StringId.E_FileXDoesNotExistOnServer, incrementalPatch.PatchVersion() + PatchParameters.INCREMENTAL_PATCH_FILE_EXTENSION);

                            return(false);
                        }
                        else if (fileSize > 0L && fileSize != incrementalPatch.PatchSize)
                        {
                            FailReason  = PatchFailReason.FileIsNotValidOnServer;
                            FailDetails = Localization.Get(StringId.E_FileXIsNotValidOnServer, incrementalPatch.PatchVersion() + PatchParameters.INCREMENTAL_PATCH_FILE_EXTENSION);

                            return(false);
                        }
                    }
                }
            }

            for (int i = 0; i < incrementalPatches.Count; i++)
            {
                if (comms.Cancel)
                {
                    return(false);
                }

                IncrementalPatch incrementalPatch = incrementalPatches[i];
                string           patchInfoXML     = comms.DownloadManager.DownloadTextFromURL(comms.VersionInfo.GetInfoURLFor(incrementalPatch));
                if (patchInfoXML == null)
                {
                    FailReason  = PatchFailReason.DownloadError;
                    FailDetails = Localization.Get(StringId.E_CouldNotDownloadPatchInfoX, incrementalPatch.PatchVersionBrief());

                    return(false);
                }

                if (PatchInfoVerifier != null && !PatchInfoVerifier(ref patchInfoXML))
                {
                    FailReason  = PatchFailReason.CantVerifyPatchInfo;
                    FailDetails = Localization.Get(StringId.E_PatchInfoCouldNotBeVerified);

                    return(false);
                }

                IncrementalPatchInfo patchInfo;
                try
                {
                    patchInfo = PatchUtils.DeserializeXMLToIncrementalPatchInfo(patchInfoXML);
                }
                catch (Exception e)
                {
                    comms.LogToFile(e);

                    FailReason  = PatchFailReason.XmlDeserializeError;
                    FailDetails = Localization.Get(StringId.E_InvalidPatchInfoX, incrementalPatch.PatchVersionBrief());

                    return(false);
                }

                patchInfo.FromVersion        = incrementalPatch.FromVersion;
                patchInfo.ToVersion          = incrementalPatch.ToVersion;
                patchInfo.DownloadURL        = comms.VersionInfo.GetDownloadURLFor(incrementalPatch);
                patchInfo.CompressedFileSize = incrementalPatch.PatchSize;
                patchInfo.CompressedMd5Hash  = incrementalPatch.PatchMd5Hash;
                patchInfo.CompressionFormat  = incrementalPatch.CompressionFormat;

                incrementalPatchesInfo.Add(patchInfo);

                if (currentVersion > incrementalPatch.FromVersion)
                {
                    continue;
                }

                if (new IncrementalPatchApplier(comms, patchInfo).Run() == PatchResult.Failed)
                {
                    return(false);
                }
            }

            return(true);
        }