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

Merge remote-tracking branch 'origin/master' into dotnet-core

Browse Source 
# Conflicts:
#	DepotDownloader/ContentDownloader.cs
#	DepotDownloader/Program.cs
pull/19/head
Netshroud 8 years ago
parent 52f12030c1 42b832e465
commit 0da80d9601
6 changed files with 1181 additions and 1095 deletions
Show Stats Download Patch File Download Diff File

4
DepotDownloader/ConfigStore.cs
Unescape Escape View File

@ -18,6 +18,9 @@ namespace DepotDownloader
[ProtoMember(4, IsRequired = false)]
public System.Collections.Concurrent.ConcurrentDictionary<string, int> ContentServerPenalty { get; private set; }
[ProtoMember(5, IsRequired = false)]
public Dictionary<string, string> LoginKeys { get; private set; }
string FileName = null;
ConfigStore()
@ -25,6 +28,7 @@ namespace DepotDownloader
LastManifests = new Dictionary<uint, ulong>();
SentryData = new Dictionary<string, byte[]>();
ContentServerPenalty = new System.Collections.Concurrent.ConcurrentDictionary<string, int>();
LoginKeys = new Dictionary<string, string>();
}
static bool Loaded

1815
DepotDownloader/ContentDownloader.cs
View File

File diff suppressed because it is too large Load Diff

3
DepotDownloader/DownloadConfig.cs
Unescape Escape View File

@ -24,5 +24,8 @@ namespace DepotDownloader
public int MaxServers { get; set; }
public int MaxDownloads { get; set; }
public string SuppliedPassword { get; set; }
public bool RememberPassword { get; set; }
}
}

91
DepotDownloader/Program.cs
Unescape Escape View File

@ -11,7 +11,7 @@ namespace DepotDownloader
class Program
{
static void Main( string[] args )
=> MainAsync(args).GetAwaiter().GetResult();
=> MainAsync( args ).GetAwaiter().GetResult();
static async Task MainAsync( string[] args )
{
@ -23,7 +23,7 @@ namespace DepotDownloader
DebugLog.Enabled = false;
ConfigStore.LoadFromFile(Path.Combine(Directory.GetCurrentDirectory(), "DepotDownloader.config"));
ConfigStore.LoadFromFile( Path.Combine( Directory.GetCurrentDirectory(), "DepotDownloader.config" ) );
bool bDumpManifest = HasParameter( args, "-manifest-only" );
uint appId = GetParameter<uint>( args, "-app", ContentDownloader.INVALID_APP_ID );
@ -36,24 +36,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 )
@ -67,16 +67,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;
}
}
@ -89,39 +89,50 @@ namespace DepotDownloader
}
}
string username = GetParameter<string>(args, "-username") ?? GetParameter<string>(args, "-user");
string password = GetParameter<string>(args, "-password") ?? GetParameter<string>(args, "-pass");
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";
bool forceDepot = HasParameter( args, "-force-depot" );
string os = GetParameter<string>( args, "-os", null );
if ( ContentDownloader.Config.DownloadAllPlatforms && !String.IsNullOrEmpty( os ) )
{
Console.WriteLine( "Error: Cannot specify -os when -all-platforms is specified." );
return;
}
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)
if ( username != null && password == null && ( !ContentDownloader.Config.RememberPassword || !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 ) )
{
await ContentDownloader.DownloadAppAsync(appId, depotId, branch, forceDepot).ConfigureAwait(false);
await ContentDownloader.DownloadAppAsync( appId, depotId, branch, os, forceDepot ).ConfigureAwait( false );
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;
@ -133,22 +144,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()
@ -156,7 +167,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:" );
@ -164,7 +175,9 @@ namespace DepotDownloader
Console.WriteLine( "\t-cellid <#>\t\t\t- the overridden CellID of the content server to download from." );
Console.WriteLine( "\t-username <user>\t\t\t- the username of the account to login to for restricted content." );
Console.WriteLine( "\t-password <pass>\t\t\t- the password of the account to login to for restricted content." );
Console.WriteLine( "\t-remember-password\t\t\t- if set, remember the password for subsequent logins of this user." );
Console.WriteLine( "\t-dir <installdir>\t\t\t- the directory in which to place downloaded files." );
Console.WriteLine( "\t-os <os>\t\t\t- the operating system for which to download the game (windows, macos or linux, default: OS the program is currently running on)" );
Console.WriteLine( "\t-filelist <filename.txt>\t\t- a list of files to download (from the manifest). Can optionally use regex to download only certain files." );
Console.WriteLine( "\t-all-platforms\t\t\t- downloads all platform-specific depots when -app is used." );
Console.WriteLine( "\t-manifest-only\t\t\t- downloads a human readable manifest for any depots that would be downloaded." );

361
DepotDownloader/Steam3Session.cs
Unescape Escape View File

@ -86,29 +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<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();
}
}
@ -117,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();
@ -128,7 +129,7 @@ namespace DepotDownloader
{
WaitForCallbacks();
}
while (!bAborted && this.seq == seq && !waiter());
while ( !bAborted && this.seq == seq && !waiter() );
}
return bAborted;
@ -136,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()
@ -368,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 )
@ -424,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,
@ -563,6 +608,16 @@ namespace DepotDownloader
steamUser.SendMachineAuthResponse( authResponse );
}
private void LoginKeyCallback( SteamUser.LoginKeyCallback loginKey )
{
Console.WriteLine( "Accepted new login key for account {0}", logonDetails.Username );
ConfigStore.TheConfig.LoginKeys[ logonDetails.Username ] = loginKey.LoginKey;
ConfigStore.Save();
steamUser.AcceptNewLoginKey( loginKey );
}
}
}

2
README.md
Unescape Escape View File

@ -14,7 +14,9 @@ Optional Parameters:
-cellid <#> - the overridden CellID of the content server to download from.
-username <user> - the username of the account to login to for restricted content.
-password <pass> - the password of the account to login to for restricted content.
-remember-password - if set, remember the password for subsequent logins of this user.
-dir <installdir> - the directory in which to place downloaded files.
-os <os> - the operating system for which to download the game (windows, macos or linux, default: OS the program is currently running on)
-filelist <file.txt> - a list of files to download (from the manifest).
Can optionally use regex to download only certain files.
-all-platforms - downloads all platform-specific depots when -app is used.

Write Preview
Loading…
Cancel
Save