/// <summary>
/// Verifies the integrity of the file in the manifest entry.
/// </summary>
/// <param name="entry">The manifest entry to test.</param>
/// <returns><c>true</c>, if file was complete and undamaged, <c>false</c> otherwise.</returns>
public static bool IsFileIntegrityIntact(this ManifestEntry entry)
{
var localPath = $"{DirectoryHelpers.GetLocalGameDirectory()}{entry.RelativePath}";
if (!File.Exists(localPath))
{
return(false);
}
var fileInfo = new FileInfo(localPath);
if (fileInfo.Length != entry.Size)
{
return(false);
}
using (Stream file = File.OpenRead(localPath))
{
string localHash = MD5Handler.GetStreamHash(file);
if (localHash != entry.Hash)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Downloads the manifest.
/// </summary>
public void DownloadManifest()
{
Stream manifestStream = null;
try
{
FTPHandler FTP = new FTPHandler();
string remoteChecksum = FTP.GetRemoteManifestChecksum();
string localChecksum = "";
string RemoteURL = Config.GetManifestURL();
string LocalPath = ConfigHandler.GetManifestPath();
if (File.Exists(ConfigHandler.GetManifestPath()))
{
manifestStream = File.OpenRead(ConfigHandler.GetManifestPath());
localChecksum = MD5Handler.GetFileHash(manifestStream);
if (!(remoteChecksum == localChecksum))
{
//Copy the old manifest so that we can compare them when updating the game
File.Copy(LocalPath, LocalPath + ".old", true);
FTP.DownloadFTPFile(RemoteURL, LocalPath, false);
}
}
else
{
FTP.DownloadFTPFile(RemoteURL, LocalPath, false);
}
}
catch (IOException ioex)
{
Console.WriteLine("IOException in DownloadManifest(): " + ioex.Message);
}
finally
{
if (manifestStream != null)
{
manifestStream.Close();
}
}
}
/// <summary>
/// Determines whether the manifest is outdated.
/// </summary>
/// <returns><c>true</c> if the manifest is outdated; otherwise, <c>false</c>.</returns>
public bool IsManifestOutdated()
{
if (File.Exists(ConfigHandler.GetManifestPath()))
{
FTPHandler FTP = new FTPHandler();
string manifestURL = Config.GetManifestURL();
string remoteHash = FTP.ReadFTPFile(manifestURL);
string localHash = MD5Handler.GetFileHash(File.OpenRead(ConfigHandler.GetManifestPath()));
if (remoteHash != localHash)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(true);
}
}
private void RepairGameAsync()
{
//This value is filled with either a path to the last downloaded file, or with an exception message
//this message is used in the main UI to determine how it responds to a failed download.
string repairMetadata = "";
try
{
//check all local file MD5s against latest manifest. Resume partial files, download broken files.
FTPHandler FTP = new FTPHandler();
//bind event handlers
FTP.FileProgressChanged += OnDownloadProgressChanged;
//first, verify that the manifest is correct.
string LocalManifestHash = MD5Handler.GetFileHash(File.OpenRead(ConfigHandler.GetManifestPath()));
string RemoteManifestHash = FTP.GetRemoteManifestChecksum();
//if it is not, download a new copy.
if (!(LocalManifestHash == RemoteManifestHash))
{
LauncherHandler Launcher = new LauncherHandler();
Launcher.DownloadManifest();
}
//then, begin repairing the game
ManifestHandler manifestHandler = new ManifestHandler();
List <ManifestEntry> Manifest = manifestHandler.Manifest;
ProgressArgs.TotalFiles = Manifest.Count;
int i = 0;
foreach (ManifestEntry Entry in Manifest)
{
string RemotePath = String.Format("{0}{1}",
Config.GetGameURL(true),
Entry.RelativePath);
string LocalPath = String.Format("{0}{1}",
Config.GetGamePath(true),
Entry.RelativePath);
ProgressArgs.FileName = Path.GetFileName(LocalPath);
//make sure the directory for the file exists
Directory.CreateDirectory(Directory.GetParent(LocalPath).ToString());
if (File.Exists(LocalPath))
{
FileInfo fileInfo = new FileInfo(LocalPath);
if (fileInfo.Length != Entry.Size)
{
//Resume the download of this partial file.
OnProgressChanged();
repairMetadata = FTP.DownloadFTPFile(RemotePath, LocalPath, fileInfo.Length, false);
//Now verify the file
string localHash = MD5Handler.GetFileHash(File.OpenRead(LocalPath));
if (localHash != Entry.Hash)
{
Console.WriteLine("RepairGameAsync: Resumed file hash was invalid, downloading fresh copy from server.");
//download the file, since it was broken
OnProgressChanged();
repairMetadata = FTP.DownloadFTPFile(RemotePath, LocalPath, false);
}
}
}
else
{
//download the file, since it was missing
OnProgressChanged();
repairMetadata = FTP.DownloadFTPFile(RemotePath, LocalPath, false);
}
if (ChecksHandler.IsRunningOnUnix())
{
//if we're dealing with a file that should be executable,
string gameName = Config.GetGameName();
bool bFileIsGameExecutable = (Path.GetFileName(LocalPath).EndsWith(".exe")) || (Path.GetFileNameWithoutExtension(LocalPath) == gameName);
if (bFileIsGameExecutable)
{
//set the execute bits.
UnixHandler.MakeExecutable(LocalPath);
}
}
++i;
ProgressArgs.DownloadedFiles = i;
OnProgressChanged();
}
OnGameRepairFinished();
//clear out the event handler
FTP.FileProgressChanged -= OnDownloadProgressChanged;
}
catch (IOException ioex)
{
Console.WriteLine("IOException in RepairGameAsync(): " + ioex.Message);
DownloadFailedArgs.Result = "1";
DownloadFailedArgs.ResultType = "Repair";
DownloadFailedArgs.Metadata = repairMetadata;
OnGameRepairFailed();
}
}
private void InstallGameAsync()
{
//This value is filled with either a path to the last downloaded file, or with an exception message
//this message is used in the main UI to determine how it responds to a failed download.
string fileReturn = "";
try
{
FTPHandler FTP = new FTPHandler();
ManifestHandler manifestHandler = new ManifestHandler();
List <ManifestEntry> Manifest = manifestHandler.Manifest;
//create the .install file to mark that an installation has begun
//if it exists, do nothing.
ConfigHandler.CreateInstallCookie();
//raise the progress changed event by binding to the
//event in the FTP class
FTP.FileProgressChanged += OnDownloadProgressChanged;
//in order to be able to resume downloading, we check if there is an entry
//stored in the install cookie.
ManifestEntry lastDownloadedFile = null;
string installCookiePath = ConfigHandler.GetInstallCookiePath();
//attempt to parse whatever is inside the install cookie
if (ManifestEntry.TryParse(File.ReadAllText(installCookiePath), out lastDownloadedFile))
{
//loop through all the entries in the manifest until we encounter
//an entry which matches the one in the install cookie
foreach (ManifestEntry Entry in Manifest)
{
if (lastDownloadedFile == Entry)
{
//remove all entries before the one we were last at.
Manifest.RemoveRange(0, Manifest.IndexOf(Entry));
}
}
}
//then, start downloading the entries that remain in the manifest.
foreach (ManifestEntry Entry in Manifest)
{
string RemotePath = String.Format("{0}{1}",
Config.GetGameURL(true),
Entry.RelativePath);
string LocalPath = String.Format("{0}{1}{2}",
Config.GetGamePath(true),
System.IO.Path.DirectorySeparatorChar,
Entry.RelativePath);
//make sure we have a game directory to put files in
Directory.CreateDirectory(Path.GetDirectoryName(LocalPath));
//write the current file progress to the install cookie
TextWriter textWriterProgress = new StreamWriter(ConfigHandler.GetInstallCookiePath());
textWriterProgress.WriteLine(Entry.ToString());
textWriterProgress.Close();
if (File.Exists(LocalPath))
{
FileInfo fileInfo = new FileInfo(LocalPath);
if (fileInfo.Length != Entry.Size)
{
//Resume the download of this partial file.
OnProgressChanged();
fileReturn = FTP.DownloadFTPFile(RemotePath, LocalPath, fileInfo.Length, false);
//Now verify the file
string localHash = MD5Handler.GetFileHash(File.OpenRead(LocalPath));
if (localHash != Entry.Hash)
{
Console.WriteLine("InstallGameAsync: Resumed file hash was invalid, downloading fresh copy from server.");
OnProgressChanged();
fileReturn = FTP.DownloadFTPFile(RemotePath, LocalPath, false);
}
}
}
else
{
//no file, download it
OnProgressChanged();
fileReturn = FTP.DownloadFTPFile(RemotePath, LocalPath, false);
}
if (ChecksHandler.IsRunningOnUnix())
{
//if we're dealing with a file that should be executable,
string gameName = Config.GetGameName();
bool bFileIsGameExecutable = (Path.GetFileName(LocalPath).EndsWith(".exe")) || (Path.GetFileNameWithoutExtension(LocalPath) == gameName);
if (bFileIsGameExecutable)
{
//set the execute bits
UnixHandler.MakeExecutable(LocalPath);
}
}
}
//we've finished the download, so empty the cookie
File.WriteAllText(ConfigHandler.GetInstallCookiePath(), String.Empty);
//raise the finished event
OnGameDownloadFinished();
//clear out the event handler
FTP.FileProgressChanged -= OnDownloadProgressChanged;
}
catch (IOException ioex)
{
Console.WriteLine("IOException in InstallGameAsync(): " + ioex.Message);
DownloadFailedArgs.Result = "1";
DownloadFailedArgs.ResultType = "Install";
DownloadFinishedArgs.Metadata = fileReturn;
OnGameDownloadFailed();
}
}
