private bool ReauthConnection(CDNClient client, CDNClient.Server server, uint depotId, byte[] depotKey)
{
DebugLog.Assert(server.Type == "CDN" || steamSession.AppTickets[depotId] == null, "CDNClientPool", "Re-authing a CDN or anonymous connection");
String cdnAuthToken = null;
if (server.Type == "CDN")
{
steamSession.RequestCDNAuthToken(depotId, server.Host);
cdnAuthToken = steamSession.CDNAuthTokens[Tuple.Create(depotId, server.Host)].Token;
}
try
{
client.AuthenticateDepot(depotId, depotKey, cdnAuthToken);
activeClientAuthed[client] = Tuple.Create(depotId, server);
return(true);
}
catch (Exception ex)
{
Console.WriteLine("Failed to reauth to content server {0}: {1}", server, ex.Message);
}
return(false);
}
private CDNClient BuildConnection(uint depotId, byte[] depotKey, CDNClient.Server serverSeed, CancellationToken token)
{
CDNClient.Server server = null;
CDNClient client = null;
while (client == null)
{
// if we want to re-initialize a specific content server, try that one first
if (serverSeed != null)
{
server = serverSeed;
serverSeed = null;
}
else
{
if (availableServerEndpoints.Count < ServerEndpointMinimumSize)
{
populatePoolEvent.Set();
}
server = availableServerEndpoints.Take(token);
}
client = new CDNClient(steamSession.steamClient, steamSession.AppTickets[depotId]);
string cdnAuthToken = null;
if (server.Type == "CDN")
{
steamSession.RequestCDNAuthToken(depotId, server.Host);
cdnAuthToken = steamSession.CDNAuthTokens[Tuple.Create(depotId, server.Host)].Token;
}
try
{
client.Connect(server);
client.AuthenticateDepot(depotId, depotKey, cdnAuthToken);
}
catch (Exception ex)
{
client = null;
Console.WriteLine("Failed to connect to content server {0}: {1}", server, ex.Message);
int penalty = 0;
ConfigStore.TheConfig.ContentServerPenalty.TryGetValue(server.Host, out penalty);
ConfigStore.TheConfig.ContentServerPenalty[server.Host] = penalty + 1;
}
}
Console.WriteLine("Initialized connection to content server {0} with depot id {1}", server, depotId);
activeClientAuthed[client] = Tuple.Create(depotId, server);
return(client);
}
private bool ReauthConnection(CDNClient client, CDNClient.Server server, uint appId, uint depotId, byte[] depotKey)
{
DebugLog.Assert(server.Type == "CDN" || steamSession.AppTickets[depotId] == null, "CDNClientPool", "Re-authing a CDN or anonymous connection");
String cdnAuthToken = null;
try
{
if (server.Type == "CDN")
{
steamSession.RequestCDNAuthToken(appId, depotId, server.Host);
var cdnKey = string.Format("{0:D}:{1}", depotId, server.Host);
SteamApps.CDNAuthTokenCallback authTokenCallback;
if (steamSession.CDNAuthTokens.TryGetValue(cdnKey, out authTokenCallback))
{
cdnAuthToken = authTokenCallback.Token;
}
else
{
throw new Exception(String.Format("Failed to retrieve CDN token for server {0} depot {1}", server.Host, depotId));
}
}
client.AuthenticateDepot(depotId, depotKey, cdnAuthToken);
activeClientAuthed[client] = Tuple.Create(depotId, server);
return(true);
}
catch (Exception ex)
{
Console.WriteLine("Failed to reauth to content server {0}: {1}", server, ex.Message);
}
return(false);
}
async private void dataGridView1_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
{
if (e.RowIndex < 0)
{
return;
}
try
{
ConfigItem item = datagridConfigs.Rows[e.RowIndex].DataBoundItem as ConfigItem;
if (item != null)
{
if (item.URL == "")
{
var callback = await steamWorkshop.RequestInfo(241100, item.Details.publishedfileid);
var itemInfo = callback.Items.FirstOrDefault();
var ticket = await steamClient.GetHandler <SteamApps>().GetAppOwnershipTicket(241100);
var decryptKey = await steamClient.GetHandler <SteamApps>().GetDepotDecryptionKey(241100, 241100);
var cdn = new CDNClient(steamClient, ticket.Ticket);
var servers = cdn.FetchServerList();
cdn.Connect(servers.First());
cdn.AuthenticateDepot(241100, decryptKey.DepotKey);
var manifest = cdn.DownloadManifest(241100, itemInfo.ManifestID);
manifest.DecryptFilenames(decryptKey.DepotKey);
if (manifest.Files.First().TotalSize == 0)
{
MessageBox.Show("Steam Refused Download Request");
return;
}
var chunk = cdn.DownloadDepotChunk(241100, manifest.Files.First().Chunks.First());
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
using (var wc = new WebClient())
{
using (var io = saveFileDialog1.OpenFile())
{
io.Write(chunk.Data, 0, chunk.Data.Length);
MessageBox.Show("Download Done!");
}
}
}
}
else
{
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
using (var wc = new WebClient())
{
wc.DownloadFile(new Uri(item.URL), saveFileDialog1.FileName);
MessageBox.Show("Download Done!");
}
}
}
}
}
catch (TaskCanceledException)
{
MessageBox.Show("Timeout! This can happen if you're using anonymous account and trying to download.");
}
catch (Exception ex)
{
MessageBox.Show($"Error Downloading Config: {ex.ToString()}");
}
}
private static BlockingCollection <CDNClient> CollectCDNClientsForDepot(DepotDownloadInfo depot)
{
Console.WriteLine("Finding content servers...");
var cdnClients = new BlockingCollection <CDNClient>();
CDNClient initialClient = new CDNClient(steam3.steamClient, steam3.AppTickets[depot.id]);
List <CDNClient.Server> cdnServers = null;
while (true)
{
try
{
cdnServers = initialClient.FetchServerList(cellId: (uint)Config.CellID);
if (cdnServers != null)
{
break;
}
}
catch (WebException)
{
Console.WriteLine("\nFailed to retrieve content server list.");
Thread.Sleep(500);
}
}
if (cdnServers == null)
{
Console.WriteLine("\nUnable to query any content servers for depot {0} - {1}", depot.id, depot.contentName);
return(cdnClients);
}
var weightedCdnServers = cdnServers.Select(x =>
{
int penalty = 0;
ConfigStore.TheConfig.ContentServerPenalty.TryGetValue(x.Host, out penalty);
return(Tuple.Create(x, penalty));
}).OrderBy(x => x.Item2).ThenBy(x => x.Item1.WeightedLoad);
// Grab up to the first eight server in the allegedly best-to-worst order from Steam
Parallel.ForEach(weightedCdnServers, new ParallelOptions {
MaxDegreeOfParallelism = 2
}, (serverTuple, parallelLoop) =>
{
var server = serverTuple.Item1;
CDNClient c = new CDNClient(steam3.steamClient, steam3.AppTickets[depot.id]);
try
{
for (int i = 0; i < server.NumEntries; i++)
{
c.Connect(server);
string cdnAuthToken = null;
if (server.Type == "CDN")
{
steam3.RequestCDNAuthToken(depot.id, server.Host);
cdnAuthToken = steam3.CDNAuthTokens[Tuple.Create(depot.id, server.Host)].Token;
}
c.AuthenticateDepot(depot.id, depot.depotKey, cdnAuthToken);
cdnClients.Add(c);
}
if (cdnClients.Count >= Config.MaxServers)
{
parallelLoop.Stop();
}
}
catch (Exception ex)
{
int penalty = 0;
ConfigStore.TheConfig.ContentServerPenalty.TryGetValue(server.Host, out penalty);
ConfigStore.TheConfig.ContentServerPenalty[server.Host] = penalty + 1;
Console.WriteLine("\nFailed to connect to content server {0}: {1}", server, ex.Message);
}
});
if (cdnClients.Count == 0)
{
Console.WriteLine("\nUnable to find any content servers for depot {0} - {1}", depot.id, depot.contentName);
}
Config.MaxDownloads = Math.Min(Config.MaxDownloads, cdnClients.Count);
return(cdnClients);
}