KnightsOfTheArk
/
DepotDownloader
mirror of https://github.com/SteamRE/DepotDownloader.git
23
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Touched formatting and line endings. Tweaked login key handling.

Browse Source
pull/25/head
Ryan Kistner 8 years ago
parent dceed3a9a1
commit 58b5b6185e
5 changed files with 1100 additions and 1047 deletions
Show Stats Download Patch File Download Diff File

3
DepotDownloader/CDNClientPool.cs
Unescape Escape View File

@ -3,10 +3,7 @@ using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace DepotDownloader
{

1702
DepotDownloader/ContentDownloader.cs
View File

File diff suppressed because it is too large Load Diff

1
DepotDownloader/DownloadConfig.cs
Unescape Escape View File

@ -25,6 +25,7 @@ namespace DepotDownloader
public int MaxServers { get; set; }
public int MaxDownloads { get; set; }
public string SuppliedPassword { get; set; }
public bool RememberPassword { get; set; }
}
}

81
DepotDownloader/Program.cs
Unescape Escape View File

@ -19,7 +19,7 @@ namespace DepotDownloader
DebugLog.Enabled = false;
ConfigStore.LoadFromFile(Path.Combine(Environment.CurrentDirectory, "DepotDownloader.config"));
ConfigStore.LoadFromFile( Path.Combine( Environment.CurrentDirectory, "DepotDownloader.config" ) );
bool bDumpManifest = HasParameter( args, "-manifest-only" );
uint appId = GetParameter<uint>( args, "-app", ContentDownloader.INVALID_APP_ID );
@ -32,24 +32,24 @@ namespace DepotDownloader
return;
}
if (depotId == ContentDownloader.INVALID_DEPOT_ID && ContentDownloader.Config.ManifestId != ContentDownloader.INVALID_MANIFEST_ID)
if ( depotId == ContentDownloader.INVALID_DEPOT_ID && ContentDownloader.Config.ManifestId != ContentDownloader.INVALID_MANIFEST_ID )
{
Console.WriteLine("Error: -manifest requires -depot to be specified");
Console.WriteLine( "Error: -manifest requires -depot to be specified" );
return;
}
ContentDownloader.Config.DownloadManifestOnly = bDumpManifest;
int cellId = GetParameter<int>(args, "-cellid", -1);
if (cellId == -1)
int cellId = GetParameter<int>( args, "-cellid", -1 );
if ( cellId == -1 )
{
cellId = 0;
}
ContentDownloader.Config.CellID = cellId;
ContentDownloader.Config.BetaPassword = GetParameter<string>(args, "-betapassword");
ContentDownloader.Config.BetaPassword = GetParameter<string>( args, "-betapassword" );
string fileList = GetParameter<string>(args, "-filelist");
string fileList = GetParameter<string>( args, "-filelist" );
string[] files = null;
if ( fileList != null )
@ -63,16 +63,16 @@ namespace DepotDownloader
ContentDownloader.Config.FilesToDownload = new List<string>();
ContentDownloader.Config.FilesToDownloadRegex = new List<Regex>();
foreach (var fileEntry in files)
foreach ( var fileEntry in files )
{
try
{
Regex rgx = new Regex(fileEntry, RegexOptions.Compiled | RegexOptions.IgnoreCase);
ContentDownloader.Config.FilesToDownloadRegex.Add(rgx);
Regex rgx = new Regex( fileEntry, RegexOptions.Compiled | RegexOptions.IgnoreCase );
ContentDownloader.Config.FilesToDownloadRegex.Add( rgx );
}
catch
{
ContentDownloader.Config.FilesToDownload.Add(fileEntry);
ContentDownloader.Config.FilesToDownload.Add( fileEntry );
continue;
}
}
@ -85,40 +85,43 @@ namespace DepotDownloader
}
}
string username = GetParameter<string>(args, "-username") ?? GetParameter<string>(args, "-user");
string password = GetParameter<string>(args, "-password") ?? GetParameter<string>(args, "-pass");
ContentDownloader.Config.RememberPassword = HasParameter(args, "-remember-password");
ContentDownloader.Config.InstallDirectory = GetParameter<string>(args, "-dir");
ContentDownloader.Config.DownloadAllPlatforms = HasParameter(args, "-all-platforms");
ContentDownloader.Config.VerifyAll = HasParameter(args, "-verify-all") || HasParameter(args, "-verify_all") || HasParameter(args, "-validate");
ContentDownloader.Config.MaxServers = GetParameter<int>(args, "-max-servers", 20);
ContentDownloader.Config.MaxDownloads = GetParameter<int>(args, "-max-downloads", 4);
string branch = GetParameter<string>(args, "-branch") ?? GetParameter<string>(args, "-beta") ?? "Public";
var forceDepot = HasParameter(args, "-force-depot");
string username = GetParameter<string>( args, "-username" ) ?? GetParameter<string>( args, "-user" );
string password = GetParameter<string>( args, "-password" ) ?? GetParameter<string>( args, "-pass" );
ContentDownloader.Config.RememberPassword = HasParameter( args, "-remember-password" );
ContentDownloader.Config.InstallDirectory = GetParameter<string>( args, "-dir" );
ContentDownloader.Config.DownloadAllPlatforms = HasParameter( args, "-all-platforms" );
ContentDownloader.Config.VerifyAll = HasParameter( args, "-verify-all" ) || HasParameter( args, "-verify_all" ) || HasParameter( args, "-validate" );
ContentDownloader.Config.MaxServers = GetParameter<int>( args, "-max-servers", 20 );
ContentDownloader.Config.MaxDownloads = GetParameter<int>( args, "-max-downloads", 4 );
string branch = GetParameter<string>( args, "-branch" ) ?? GetParameter<string>( args, "-beta" ) ?? "Public";
var forceDepot = HasParameter( args, "-force-depot" );
ContentDownloader.Config.MaxServers = Math.Max(ContentDownloader.Config.MaxServers, ContentDownloader.Config.MaxDownloads);
ContentDownloader.Config.MaxServers = Math.Max( ContentDownloader.Config.MaxServers, ContentDownloader.Config.MaxDownloads );
if (username != null && password == null && !ConfigStore.TheConfig.LoginKeys.ContainsKey(username))
if ( username != null && password == null && !ConfigStore.TheConfig.LoginKeys.ContainsKey( username ) )
{
Console.Write("Enter account password for \"{0}\": ", username);
Console.Write( "Enter account password for \"{0}\": ", username );
password = Util.ReadPassword();
Console.WriteLine();
}
else if (username == null)
else if ( username == null )
{
Console.WriteLine("No username given. Using anonymous account with dedicated server subscription.");
Console.WriteLine( "No username given. Using anonymous account with dedicated server subscription." );
}
if (ContentDownloader.InitializeSteam3(username, password))
// capture the supplied password in case we need to re-use it after checking the login key
ContentDownloader.Config.SuppliedPassword = password;
if ( ContentDownloader.InitializeSteam3( username, password ) )
{
ContentDownloader.DownloadApp(appId, depotId, branch, forceDepot);
ContentDownloader.DownloadApp( appId, depotId, branch, forceDepot );
ContentDownloader.ShutdownSteam3();
}
}
static int IndexOfParam( string[] args, string param )
{
for ( int x = 0 ; x < args.Length ; ++x )
for ( int x = 0; x < args.Length; ++x )
{
if ( args[ x ].Equals( param, StringComparison.OrdinalIgnoreCase ) )
return x;
@ -130,22 +133,22 @@ namespace DepotDownloader
return IndexOfParam( args, param ) > -1;
}
static T GetParameter<T>(string[] args, string param, T defaultValue = default(T))
static T GetParameter<T>( string[] args, string param, T defaultValue = default( T ) )
{
int index = IndexOfParam(args, param);
int index = IndexOfParam( args, param );
if (index == -1 || index == (args.Length - 1))
if ( index == -1 || index == ( args.Length - 1 ) )
return defaultValue;
string strParam = args[index + 1];
string strParam = args[ index + 1 ];
var converter = TypeDescriptor.GetConverter(typeof(T));
if( converter != null )
var converter = TypeDescriptor.GetConverter( typeof( T ) );
if ( converter != null )
{
return (T)converter.ConvertFromString(strParam);
return ( T )converter.ConvertFromString( strParam );
}
return default(T);
return default( T );
}
static void PrintUsage()
@ -153,7 +156,7 @@ namespace DepotDownloader
Console.WriteLine( "\nUsage: depotdownloader <parameters> [optional parameters]\n" );
Console.WriteLine( "Parameters:" );
Console.WriteLine("\t-app <#>\t\t\t\t- the AppID to download.");
Console.WriteLine( "\t-app <#>\t\t\t\t- the AppID to download." );
Console.WriteLine();
Console.WriteLine( "Optional Parameters:" );

360
DepotDownloader/Steam3Session.cs
Unescape Escape View File

@ -86,30 +86,30 @@ namespace DepotDownloader
this.steamUser = this.steamClient.GetHandler<SteamUser>();
this.steamApps = this.steamClient.GetHandler<SteamApps>();
this.callbacks = new CallbackManager(this.steamClient);
this.callbacks = new CallbackManager( this.steamClient );
this.callbacks.Subscribe<SteamClient.ConnectedCallback>(ConnectedCallback);
this.callbacks.Subscribe<SteamClient.DisconnectedCallback>(DisconnectedCallback);
this.callbacks.Subscribe<SteamUser.LoggedOnCallback>(LogOnCallback);
this.callbacks.Subscribe<SteamUser.SessionTokenCallback>(SessionTokenCallback);
this.callbacks.Subscribe<SteamApps.LicenseListCallback>(LicenseListCallback);
this.callbacks.Subscribe<SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback);
this.callbacks.Subscribe<SteamUser.LoginKeyCallback>(LoginKeyCallback);
this.callbacks.Subscribe<SteamClient.ConnectedCallback>( ConnectedCallback );
this.callbacks.Subscribe<SteamClient.DisconnectedCallback>( DisconnectedCallback );
this.callbacks.Subscribe<SteamUser.LoggedOnCallback>( LogOnCallback );
this.callbacks.Subscribe<SteamUser.SessionTokenCallback>( SessionTokenCallback );
this.callbacks.Subscribe<SteamApps.LicenseListCallback>( LicenseListCallback );
this.callbacks.Subscribe<SteamUser.UpdateMachineAuthCallback>( UpdateMachineAuthCallback );
this.callbacks.Subscribe<SteamUser.LoginKeyCallback>( LoginKeyCallback );
Console.Write( "Connecting to Steam3..." );
if ( authenticatedUser )
{
FileInfo fi = new FileInfo(String.Format("{0}.sentryFile", logonDetails.Username));
if (ConfigStore.TheConfig.SentryData != null && ConfigStore.TheConfig.SentryData.ContainsKey(logonDetails.Username))
FileInfo fi = new FileInfo( String.Format( "{0}.sentryFile", logonDetails.Username ) );
if ( ConfigStore.TheConfig.SentryData != null && ConfigStore.TheConfig.SentryData.ContainsKey( logonDetails.Username ) )
{
logonDetails.SentryFileHash = Util.SHAHash(ConfigStore.TheConfig.SentryData[logonDetails.Username]);
logonDetails.SentryFileHash = Util.SHAHash( ConfigStore.TheConfig.SentryData[ logonDetails.Username ] );
}
else if (fi.Exists && fi.Length > 0)
else if ( fi.Exists && fi.Length > 0 )
{
var sentryData = File.ReadAllBytes(fi.FullName);
logonDetails.SentryFileHash = Util.SHAHash(sentryData);
ConfigStore.TheConfig.SentryData[logonDetails.Username] = sentryData;
var sentryData = File.ReadAllBytes( fi.FullName );
logonDetails.SentryFileHash = Util.SHAHash( sentryData );
ConfigStore.TheConfig.SentryData[ logonDetails.Username ] = sentryData;
ConfigStore.Save();
}
}
@ -118,9 +118,9 @@ namespace DepotDownloader
}
public delegate bool WaitCondition();
public bool WaitUntilCallback(Action submitter, WaitCondition waiter)
public bool WaitUntilCallback( Action submitter, WaitCondition waiter )
{
while (!bAborted && !waiter())
while ( !bAborted && !waiter() )
{
submitter();
@ -129,7 +129,7 @@ namespace DepotDownloader
{
WaitForCallbacks();
}
while (!bAborted && this.seq == seq && !waiter());
while ( !bAborted && this.seq == seq && !waiter() );
}
return bAborted;
@ -137,224 +137,229 @@ namespace DepotDownloader
public Credentials WaitForCredentials()
{
if (credentials.IsValid || bAborted)
if ( credentials.IsValid || bAborted )
return credentials;
WaitUntilCallback(() => { }, () => { return credentials.IsValid; });
WaitUntilCallback( () => { }, () => { return credentials.IsValid; } );
return credentials;
}
public void RequestAppInfo(uint appId)
public void RequestAppInfo( uint appId )
{
if (AppInfo.ContainsKey(appId) || bAborted)
if ( AppInfo.ContainsKey( appId ) || bAborted )
return;
bool completed = false;
Action<SteamApps.PICSTokensCallback> cbMethodTokens = (appTokens) =>
Action<SteamApps.PICSTokensCallback> cbMethodTokens = ( appTokens ) =>
{
completed = true;
if (appTokens.AppTokensDenied.Contains(appId))
if ( appTokens.AppTokensDenied.Contains( appId ) )
{
Console.WriteLine("Insufficient privileges to get access token for app {0}", appId);
Console.WriteLine( "Insufficient privileges to get access token for app {0}", appId );
}
foreach (var token_dict in appTokens.AppTokens)
foreach ( var token_dict in appTokens.AppTokens )
{
this.AppTokens.Add(token_dict.Key, token_dict.Value);
this.AppTokens.Add( token_dict.Key, token_dict.Value );
}
};
WaitUntilCallback(() => {
callbacks.Subscribe(steamApps.PICSGetAccessTokens(new List<uint>() { appId }, new List<uint>() { }), cbMethodTokens);
}, () => { return completed; });
WaitUntilCallback( () =>
{
callbacks.Subscribe( steamApps.PICSGetAccessTokens( new List<uint>() { appId }, new List<uint>() { } ), cbMethodTokens );
}, () => { return completed; } );
completed = false;
Action<SteamApps.PICSProductInfoCallback> cbMethod = (appInfo) =>
Action<SteamApps.PICSProductInfoCallback> cbMethod = ( appInfo ) =>
{
completed = !appInfo.ResponsePending;
foreach (var app_value in appInfo.Apps)
foreach ( var app_value in appInfo.Apps )
{
var app = app_value.Value;
Console.WriteLine("Got AppInfo for {0}", app.ID);
AppInfo.Add(app.ID, app);
Console.WriteLine( "Got AppInfo for {0}", app.ID );
AppInfo.Add( app.ID, app );
}
foreach (var app in appInfo.UnknownApps)
foreach ( var app in appInfo.UnknownApps )
{
AppInfo.Add(app, null);
AppInfo.Add( app, null );
}
};
SteamApps.PICSRequest request = new SteamApps.PICSRequest(appId);
if (AppTokens.ContainsKey(appId))
SteamApps.PICSRequest request = new SteamApps.PICSRequest( appId );
if ( AppTokens.ContainsKey( appId ) )
{
request.AccessToken = AppTokens[appId];
request.AccessToken = AppTokens[ appId ];
request.Public = false;
}
WaitUntilCallback(() => {
callbacks.Subscribe(steamApps.PICSGetProductInfo(new List<SteamApps.PICSRequest>() { request }, new List<SteamApps.PICSRequest>() { }), cbMethod);
}, () => { return completed; });
WaitUntilCallback( () =>
{
callbacks.Subscribe( steamApps.PICSGetProductInfo( new List<SteamApps.PICSRequest>() { request }, new List<SteamApps.PICSRequest>() { } ), cbMethod );
}, () => { return completed; } );
}
public void RequestPackageInfo(IEnumerable<uint> packageIds)
public void RequestPackageInfo( IEnumerable<uint> packageIds )
{
List<uint> packages = packageIds.ToList();
packages.RemoveAll(pid => PackageInfo.ContainsKey(pid));
packages.RemoveAll( pid => PackageInfo.ContainsKey( pid ) );
if (packages.Count == 0 || bAborted)
if ( packages.Count == 0 || bAborted )
return;
bool completed = false;
Action<SteamApps.PICSProductInfoCallback> cbMethod = (packageInfo) =>
Action<SteamApps.PICSProductInfoCallback> cbMethod = ( packageInfo ) =>
{
completed = !packageInfo.ResponsePending;
foreach (var package_value in packageInfo.Packages)
foreach ( var package_value in packageInfo.Packages )
{
var package = package_value.Value;
PackageInfo.Add(package.ID, package);
PackageInfo.Add( package.ID, package );
}
foreach (var package in packageInfo.UnknownPackages)
foreach ( var package in packageInfo.UnknownPackages )
{
PackageInfo.Add(package, null);
PackageInfo.Add( package, null );
}
};
WaitUntilCallback(() => {
callbacks.Subscribe(steamApps.PICSGetProductInfo(new List<uint>(), packages), cbMethod);
}, () => { return completed; });
WaitUntilCallback( () =>
{
callbacks.Subscribe( steamApps.PICSGetProductInfo( new List<uint>(), packages ), cbMethod );
}, () => { return completed; } );
}
public bool RequestFreeAppLicense(uint appId)
public bool RequestFreeAppLicense( uint appId )
{
bool success = false;
bool completed = false;
Action<SteamApps.FreeLicenseCallback> cbMethod = (resultInfo) =>
Action<SteamApps.FreeLicenseCallback> cbMethod = ( resultInfo ) =>
{
completed = true;
success = resultInfo.GrantedApps.Contains(appId);
success = resultInfo.GrantedApps.Contains( appId );
};
WaitUntilCallback(() => {
callbacks.Subscribe(steamApps.RequestFreeLicense(appId), cbMethod);
}, () => { return completed; });
WaitUntilCallback( () =>
{
callbacks.Subscribe( steamApps.RequestFreeLicense( appId ), cbMethod );
}, () => { return completed; } );
return success;
}
public void RequestAppTicket(uint appId)
public void RequestAppTicket( uint appId )
{
if (AppTickets.ContainsKey(appId) || bAborted)
if ( AppTickets.ContainsKey( appId ) || bAborted )
return;
if ( !authenticatedUser )
{
AppTickets[appId] = null;
AppTickets[ appId ] = null;
return;
}
bool completed = false;
Action<SteamApps.AppOwnershipTicketCallback> cbMethod = (appTicket) =>
Action<SteamApps.AppOwnershipTicketCallback> cbMethod = ( appTicket ) =>
{
completed = true;
if (appTicket.Result != EResult.OK)
if ( appTicket.Result != EResult.OK )
{
Console.WriteLine("Unable to get appticket for {0}: {1}", appTicket.AppID, appTicket.Result);
Console.WriteLine( "Unable to get appticket for {0}: {1}", appTicket.AppID, appTicket.Result );
Abort();
}
else
{
Console.WriteLine("Got appticket for {0}!", appTicket.AppID);
AppTickets[appTicket.AppID] = appTicket.Ticket;
Console.WriteLine( "Got appticket for {0}!", appTicket.AppID );
AppTickets[ appTicket.AppID ] = appTicket.Ticket;
}
};
WaitUntilCallback(() => {
callbacks.Subscribe(steamApps.GetAppOwnershipTicket(appId), cbMethod);
}, () => { return completed; });
WaitUntilCallback( () =>
{
callbacks.Subscribe( steamApps.GetAppOwnershipTicket( appId ), cbMethod );
}, () => { return completed; } );
}
public void RequestDepotKey(uint depotId, uint appid = 0)
public void RequestDepotKey( uint depotId, uint appid = 0 )
{
if (DepotKeys.ContainsKey(depotId) || bAborted)
if ( DepotKeys.ContainsKey( depotId ) || bAborted )
return;
bool completed = false;
Action<SteamApps.DepotKeyCallback> cbMethod = (depotKey) =>
Action<SteamApps.DepotKeyCallback> cbMethod = ( depotKey ) =>
{
completed = true;
Console.WriteLine("Got depot key for {0} result: {1}", depotKey.DepotID, depotKey.Result);
Console.WriteLine( "Got depot key for {0} result: {1}", depotKey.DepotID, depotKey.Result );
if (depotKey.Result != EResult.OK)
if ( depotKey.Result != EResult.OK )
{
Abort();
return;
}
DepotKeys[depotKey.DepotID] = depotKey.DepotKey;
DepotKeys[ depotKey.DepotID ] = depotKey.DepotKey;
};
WaitUntilCallback(() =>
WaitUntilCallback( () =>
{
callbacks.Subscribe(steamApps.GetDepotDecryptionKey(depotId, appid), cbMethod);
}, () => { return completed; });
callbacks.Subscribe( steamApps.GetDepotDecryptionKey( depotId, appid ), cbMethod );
}, () => { return completed; } );
}
public void RequestCDNAuthToken(uint appid, uint depotid, string host)
public void RequestCDNAuthToken( uint appid, uint depotid, string host )
{
var cdnKey = string.Format("{0:D}:{1}", depotid, host);
var cdnKey = string.Format( "{0:D}:{1}", depotid, host );
if (CDNAuthTokens.ContainsKey(cdnKey) || bAborted)
if ( CDNAuthTokens.ContainsKey( cdnKey ) || bAborted )
return;
bool completed = false;
Action<SteamApps.CDNAuthTokenCallback> cbMethod = (cdnAuth) =>
Action<SteamApps.CDNAuthTokenCallback> cbMethod = ( cdnAuth ) =>
{
completed = true;
Console.WriteLine("Got CDN auth token for {0} result: {1} (expires {2})", host, cdnAuth.Result, cdnAuth.Expiration);
Console.WriteLine( "Got CDN auth token for {0} result: {1} (expires {2})", host, cdnAuth.Result, cdnAuth.Expiration );
if (cdnAuth.Result != EResult.OK)
if ( cdnAuth.Result != EResult.OK )
{
Abort();
return;
}
CDNAuthTokens.TryAdd(cdnKey, cdnAuth);
CDNAuthTokens.TryAdd( cdnKey, cdnAuth );
};
WaitUntilCallback(() =>
WaitUntilCallback( () =>
{
callbacks.Subscribe(steamApps.GetCDNAuthToken(appid, depotid, host), cbMethod);
}, () => { return completed; });
callbacks.Subscribe( steamApps.GetCDNAuthToken( appid, depotid, host ), cbMethod );
}, () => { return completed; } );
}
public void CheckAppBetaPassword(uint appid, string password)
public void CheckAppBetaPassword( uint appid, string password )
{
bool completed = false;
Action<SteamApps.CheckAppBetaPasswordCallback> cbMethod = (appPassword) =>
Action<SteamApps.CheckAppBetaPasswordCallback> cbMethod = ( appPassword ) =>
{
completed = true;
Console.WriteLine("Retrieved {0} beta keys with result: {1}", appPassword.BetaPasswords.Count, appPassword.Result);
Console.WriteLine( "Retrieved {0} beta keys with result: {1}", appPassword.BetaPasswords.Count, appPassword.Result );
foreach (var entry in appPassword.BetaPasswords)
foreach ( var entry in appPassword.BetaPasswords )
{
AppBetaPasswords[entry.Key] = entry.Value;
AppBetaPasswords[ entry.Key ] = entry.Value;
}
};
WaitUntilCallback(() =>
WaitUntilCallback( () =>
{
callbacks.Subscribe(steamApps.CheckAppBetaPassword(appid, password), cbMethod);
}, () => { return completed; });
callbacks.Subscribe( steamApps.CheckAppBetaPassword( appid, password ), cbMethod );
}, () => { return completed; } );
}
void Connect()
@ -369,48 +374,64 @@ namespace DepotDownloader
this.steamClient.Connect();
}
private void Abort(bool sendLogOff=true)
private void Abort( bool sendLogOff = true )
{
Disconnect(sendLogOff);
Disconnect( sendLogOff );
}
public void Disconnect(bool sendLogOff=true)
public void Disconnect( bool sendLogOff = true )
{
if (sendLogOff)
if ( sendLogOff )
{
steamUser.LogOff();
}
steamClient.Disconnect();
bConnected = false;
bConnecting = false;
bAborted = true;
// flush callbacks until our disconnected event
while (!bDidDisconnect)
while ( !bDidDisconnect )
{
callbacks.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(100));
callbacks.RunWaitAllCallbacks( TimeSpan.FromMilliseconds( 100 ) );
}
}
public void TryWaitForLoginKey()
{
if ( logonDetails.Username == null || !ContentDownloader.Config.RememberPassword ) return;
DateTime waitUntil = new DateTime().AddSeconds( 10 );
while ( true )
{
DateTime now = new DateTime();
if ( now >= waitUntil ) break;
if ( ConfigStore.TheConfig.LoginKeys.ContainsKey( logonDetails.Username ) ) break;
callbacks.RunWaitAllCallbacks( TimeSpan.FromMilliseconds( 100 ) );
}
}
private void WaitForCallbacks()
{
callbacks.RunWaitCallbacks( TimeSpan.FromSeconds(1) );
callbacks.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) );
TimeSpan diff = DateTime.Now - connectTime;
if (diff > STEAM3_TIMEOUT && !bConnected)
if ( diff > STEAM3_TIMEOUT && !bConnected )
{
Console.WriteLine("Timeout connecting to Steam3.");
Console.WriteLine( "Timeout connecting to Steam3." );
Abort();
return;
}
}
private void ConnectedCallback(SteamClient.ConnectedCallback connected)
private void ConnectedCallback( SteamClient.ConnectedCallback connected )
{
Console.WriteLine(" Done!");
Console.WriteLine( " Done!" );
bConnecting = false;
bConnected = true;
if ( !authenticatedUser )
@ -425,124 +446,147 @@ namespace DepotDownloader
}
}
private void DisconnectedCallback(SteamClient.DisconnectedCallback disconnected)
private void DisconnectedCallback( SteamClient.DisconnectedCallback disconnected )
{
bDidDisconnect = true;
if (disconnected.UserInitiated || bExpectingDisconnectRemote)
if ( disconnected.UserInitiated || bExpectingDisconnectRemote )
{
Console.WriteLine("Disconnected from Steam");
Console.WriteLine( "Disconnected from Steam" );
}
else if (connectionBackoff >= 10)
else if ( connectionBackoff >= 10 )
{
Console.WriteLine("Could not connect to Steam after 10 tries");
Abort(false);
Console.WriteLine( "Could not connect to Steam after 10 tries" );
Abort( false );
}
else if (!bAborted)
else if ( !bAborted )
{
if (bConnecting)
if ( bConnecting )
{
Console.WriteLine("Connection to Steam failed. Trying again");
} else
Console.WriteLine( "Connection to Steam failed. Trying again" );
}
else
{
Console.WriteLine("Lost connection to Steam. Reconnecting");
Console.WriteLine( "Lost connection to Steam. Reconnecting" );
}
Thread.Sleep(1000 * ++connectionBackoff);
Thread.Sleep( 1000 * ++connectionBackoff );
steamClient.Connect();
}
}
private void LogOnCallback(SteamUser.LoggedOnCallback loggedOn)
private void LogOnCallback( SteamUser.LoggedOnCallback loggedOn )
{
bool isSteamGuard = loggedOn.Result == EResult.AccountLogonDenied;
bool is2FA = loggedOn.Result == EResult.AccountLoginDeniedNeedTwoFactor;
bool isLoginKey = ContentDownloader.Config.RememberPassword && logonDetails.LoginKey != null && loggedOn.Result == EResult.InvalidPassword;
if (isSteamGuard || is2FA)
if ( isSteamGuard || is2FA || isLoginKey )
{
bExpectingDisconnectRemote = true;
Abort(false);
Abort( false );
Console.WriteLine("This account is protected by Steam Guard.");
if ( !isLoginKey )
{
Console.WriteLine( "This account is protected by Steam Guard." );
}
if (is2FA)
if ( is2FA )
{
Console.Write("Please enter your 2 factor auth code from your authenticator app: ");
Console.Write( "Please enter your 2 factor auth code from your authenticator app: " );
logonDetails.TwoFactorCode = Console.ReadLine();
}
else if ( isLoginKey )
{
ConfigStore.TheConfig.LoginKeys.Remove( logonDetails.Username );
ConfigStore.Save();
logonDetails.LoginKey = null;
if ( ContentDownloader.Config.SuppliedPassword != null )
{
Console.WriteLine( "Login key was expired. Connecting with supplied password." );
logonDetails.Password = ContentDownloader.Config.SuppliedPassword;
}
else
{
Console.WriteLine( "Login key was expired. Please enter your password: " );
logonDetails.Password = Util.ReadPassword();
}
}
else
{
Console.Write("Please enter the authentication code sent to your email address: ");
Console.Write( "Please enter the authentication code sent to your email address: " );
logonDetails.AuthCode = Console.ReadLine();
}
Console.Write("Retrying Steam3 connection...");
Console.Write( "Retrying Steam3 connection..." );
Connect();
return;
}
else if (loggedOn.Result == EResult.ServiceUnavailable)
else if ( loggedOn.Result == EResult.ServiceUnavailable )
{
Console.WriteLine("Unable to login to Steam3: {0}", loggedOn.Result);
Abort(false);
Console.WriteLine( "Unable to login to Steam3: {0}", loggedOn.Result );
Abort( false );
return;
}
else if (loggedOn.Result != EResult.OK)
else if ( loggedOn.Result != EResult.OK )
{
Console.WriteLine("Unable to login to Steam3: {0}", loggedOn.Result);
Console.WriteLine( "Unable to login to Steam3: {0}", loggedOn.Result );
Abort();
return;
}
Console.WriteLine(" Done!");
Console.WriteLine( " Done!" );
this.seq++;
credentials.LoggedOn = true;
if (ContentDownloader.Config.CellID == 0)
if ( ContentDownloader.Config.CellID == 0 )
{
Console.WriteLine("Using Steam3 suggested CellID: " + loggedOn.CellID);
ContentDownloader.Config.CellID = (int)loggedOn.CellID;
Console.WriteLine( "Using Steam3 suggested CellID: " + loggedOn.CellID );
ContentDownloader.Config.CellID = ( int )loggedOn.CellID;
}
}
private void SessionTokenCallback(SteamUser.SessionTokenCallback sessionToken)
private void SessionTokenCallback( SteamUser.SessionTokenCallback sessionToken )
{
Console.WriteLine("Got session token!");
Console.WriteLine( "Got session token!" );
credentials.SessionToken = sessionToken.SessionToken;
}
private void LicenseListCallback(SteamApps.LicenseListCallback licenseList)
private void LicenseListCallback( SteamApps.LicenseListCallback licenseList )
{
if (licenseList.Result != EResult.OK)
if ( licenseList.Result != EResult.OK )
{
Console.WriteLine("Unable to get license list: {0} ", licenseList.Result);
Console.WriteLine( "Unable to get license list: {0} ", licenseList.Result );
Abort();
return;
}
Console.WriteLine("Got {0} licenses for account!", licenseList.LicenseList.Count);
Console.WriteLine( "Got {0} licenses for account!", licenseList.LicenseList.Count );
Licenses = licenseList.LicenseList;
IEnumerable<uint> licenseQuery = Licenses.Select(lic =>
IEnumerable<uint> licenseQuery = Licenses.Select( lic =>
{
return lic.PackageID;
});
} );
Console.WriteLine("Licenses: {0}", string.Join(", ", licenseQuery));
Console.WriteLine( "Licenses: {0}", string.Join( ", ", licenseQuery ) );
}
private void UpdateMachineAuthCallback(SteamUser.UpdateMachineAuthCallback machineAuth)
private void UpdateMachineAuthCallback( SteamUser.UpdateMachineAuthCallback machineAuth )
{
byte[] hash = Util.SHAHash(machineAuth.Data);
Console.WriteLine("Got Machine Auth: {0} {1} {2} {3}", machineAuth.FileName, machineAuth.Offset, machineAuth.BytesToWrite, machineAuth.Data.Length, hash);
byte[] hash = Util.SHAHash( machineAuth.Data );
Console.WriteLine( "Got Machine Auth: {0} {1} {2} {3}", machineAuth.FileName, machineAuth.Offset, machineAuth.BytesToWrite, machineAuth.Data.Length, hash );
ConfigStore.TheConfig.SentryData[logonDetails.Username] = machineAuth.Data;
ConfigStore.TheConfig.SentryData[ logonDetails.Username ] = machineAuth.Data;
ConfigStore.Save();
var authResponse = new SteamUser.MachineAuthDetails
{
BytesWritten = machineAuth.BytesToWrite,
@ -564,12 +608,14 @@ namespace DepotDownloader
steamUser.SendMachineAuthResponse( authResponse );
}
private void LoginKeyCallback(SteamUser.LoginKeyCallback loginKey)
private void LoginKeyCallback( SteamUser.LoginKeyCallback loginKey )
{
ConfigStore.TheConfig.LoginKeys[logonDetails.Username] = loginKey.LoginKey;
Console.WriteLine( "Accepted new login key for account {0}", logonDetails.Username );
ConfigStore.TheConfig.LoginKeys[ logonDetails.Username ] = loginKey.LoginKey;
ConfigStore.Save();
steamUser.AcceptNewLoginKey(loginKey);
steamUser.AcceptNewLoginKey( loginKey );
}

Write Preview
Loading…
Cancel
Save