private static void UnobservedTaskExceptionHandler(object sender, UnobservedTaskExceptionEventArgs args)
{
if (args?.Exception == null)
{
Logging.LogNullError(nameof(args) + " || " + nameof(args.Exception));
return;
}
Logging.LogFatalException(args.Exception);
}
private async Task <HttpResponseMessage> UrlHeadToResponse(string request, string referer = null)
{
if (!string.IsNullOrEmpty(request))
{
return(await UrlRequest(request, HttpMethod.Head, null, referer).ConfigureAwait(false));
}
Logging.LogNullError(nameof(request), Identifier);
return(null);
}
private static void UnobservedTaskExceptionHandler(object sender, UnobservedTaskExceptionEventArgs args)
{
if ((sender == null) || (args == null) || (args.Exception == null))
{
Logging.LogNullError(nameof(sender) + " || " + nameof(args) + " || " + nameof(args.Exception));
return;
}
Logging.LogGenericException(args.Exception);
}
private static void UnhandledExceptionHandler(object sender, UnhandledExceptionEventArgs args)
{
if (args?.ExceptionObject == null)
{
Logging.LogNullError(nameof(args) + " || " + nameof(args.ExceptionObject));
return;
}
Logging.LogFatalException((Exception)args.ExceptionObject);
}
internal static void SetEncryptionKey(string key)
{
if (string.IsNullOrEmpty(key))
{
Logging.LogNullError(nameof(key));
return;
}
EncryptionKey = Encoding.UTF8.GetBytes(key);
}
private static void UnhandledExceptionHandler(object sender, UnhandledExceptionEventArgs args)
{
if ((sender == null) || (args == null) || (args.ExceptionObject == null))
{
Logging.LogNullError(nameof(sender) + " || " + nameof(args) + " || " + nameof(args.ExceptionObject));
return;
}
Logging.LogGenericException((Exception)args.ExceptionObject);
}
internal static Task SleepAsync(int miliseconds)
{
if (miliseconds >= 0)
{
return(Task.Delay(miliseconds));
}
Logging.LogNullError(nameof(miliseconds));
return(Task.FromResult(true));
}
internal static Task ForEachAsync <T>(this IEnumerable <T> sequence, Func <T, Task> action)
{
if (action != null)
{
return(Task.WhenAll(sequence.Select(action)));
}
Logging.LogNullError(nameof(action));
return(Task.FromResult(true));
}
private async Task <HttpResponseMessage> UrlPostToResponse(string request, Dictionary <string, string> data = null, string referer = null)
{
if (!string.IsNullOrEmpty(request))
{
return(await UrlRequest(request, HttpMethod.Post, data, referer).ConfigureAwait(false));
}
Logging.LogNullError(nameof(request));
return(null);
}
private async Task <HttpResponseMessage> UrlPostToResponse(string request, IEnumerable <KeyValuePair <string, string> > data = null, string referer = null)
{
if (!string.IsNullOrEmpty(request))
{
return(await UrlRequest(request, HttpMethod.Post, data, referer).ConfigureAwait(false));
}
Logging.LogNullError(nameof(request), Identifier);
return(null);
}
internal void CorrectDeviceID(string deviceID)
{
if (string.IsNullOrEmpty(deviceID))
{
Logging.LogNullError(nameof(deviceID), Bot.BotName);
return;
}
DeviceID = deviceID;
}
private bool FarmHours(ConcurrentHashSet <Game> games)
{
if ((games == null) || (games.Count == 0))
{
Logging.LogNullError(nameof(games), Bot.BotName);
return(false);
}
float maxHour = games.Max(game => game.HoursPlayed);
if (maxHour < 0)
{
Logging.LogNullError(nameof(maxHour), Bot.BotName);
return(false);
}
if (maxHour >= 2)
{
Logging.LogGenericError("Received request for past-2h games!", Bot.BotName);
return(true);
}
Bot.ArchiHandler.PlayGames(games.Select(game => game.AppID), Bot.BotConfig.CustomGamePlayedWhileFarming);
bool success = true;
while (maxHour < 2)
{
Logging.LogGenericInfo("Still farming: " + string.Join(", ", games.Select(game => game.AppID)), Bot.BotName);
DateTime startFarmingPeriod = DateTime.Now;
if (FarmResetEvent.Wait(60 * 1000 * Program.GlobalConfig.FarmingDelay))
{
FarmResetEvent.Reset();
success = KeepFarming;
}
// Don't forget to update our GamesToFarm hours
float timePlayed = (float)DateTime.Now.Subtract(startFarmingPeriod).TotalHours;
foreach (Game game in games)
{
game.HoursPlayed += timePlayed;
}
if (!success)
{
break;
}
maxHour += timePlayed;
}
Logging.LogGenericInfo("Stopped farming: " + string.Join(", ", games.Select(game => game.AppID)), Bot.BotName);
return(success);
}
private static bool ParseItems(Dictionary <ulong, Tuple <uint, Steam.Item.EType> > descriptions, List <KeyValue> input, HashSet <Steam.Item> output)
{
if ((descriptions == null) || (input == null) || (input.Count == 0) || (output == null))
{
Logging.LogNullError(nameof(descriptions) + " || " + nameof(input) + " || " + nameof(output));
return(false);
}
foreach (KeyValue item in input)
{
uint appID = item["appid"].AsUnsignedInteger();
if (appID == 0)
{
Logging.LogNullError(nameof(appID));
return(false);
}
ulong contextID = item["contextid"].AsUnsignedLong();
if (contextID == 0)
{
Logging.LogNullError(nameof(contextID));
return(false);
}
ulong classID = item["classid"].AsUnsignedLong();
if (classID == 0)
{
Logging.LogNullError(nameof(classID));
return(false);
}
uint amount = item["amount"].AsUnsignedInteger();
if (amount == 0)
{
Logging.LogNullError(nameof(amount));
return(false);
}
uint realAppID = 0;
Steam.Item.EType type = Steam.Item.EType.Unknown;
Tuple <uint, Steam.Item.EType> description;
if (descriptions.TryGetValue(classID, out description))
{
realAppID = description.Item1;
type = description.Item2;
}
Steam.Item steamItem = new Steam.Item(appID, contextID, classID, amount, realAppID, type);
output.Add(steamItem);
}
return(true);
}
internal async Task <Dictionary <uint, string> > GetOwnedGames()
{
if (!await RefreshSessionIfNeeded().ConfigureAwait(false))
{
return(null);
}
string request = SteamCommunityURL + "/my/games/?xml=1";
XmlDocument response = await WebBrowser.UrlGetToXMLRetry(request).ConfigureAwait(false);
if (response == null)
{
return(null);
}
XmlNodeList xmlNodeList = response.SelectNodes("gamesList/games/game");
if ((xmlNodeList == null) || (xmlNodeList.Count == 0))
{
return(null);
}
Dictionary <uint, string> result = new Dictionary <uint, string>(xmlNodeList.Count);
foreach (XmlNode xmlNode in xmlNodeList)
{
XmlNode appNode = xmlNode.SelectSingleNode("appID");
if (appNode == null)
{
Logging.LogNullError(nameof(appNode), Bot.BotName);
continue;
}
uint appID;
if (!uint.TryParse(appNode.InnerText, out appID))
{
Logging.LogNullError(nameof(appID), Bot.BotName);
continue;
}
XmlNode nameNode = xmlNode.SelectSingleNode("name");
if (nameNode == null)
{
Logging.LogNullError(nameof(nameNode), Bot.BotName);
continue;
}
result[appID] = nameNode.InnerText;
}
return(result);
}
private async Task <bool> UrlPost(string request, Dictionary <string, string> data = null, string referer = null)
{
if (string.IsNullOrEmpty(request))
{
Logging.LogNullError(nameof(request));
return(false);
}
using (HttpResponseMessage response = await UrlPostToResponse(request, data, referer).ConfigureAwait(false)) {
return(response != null);
}
}
internal async Task <string> GenerateToken()
{
uint time = await GetSteamTime().ConfigureAwait(false);
if (time != 0)
{
return(GenerateTokenForTime(time));
}
Logging.LogNullError(nameof(time), Bot.BotName);
return(null);
}
private async Task <bool> UrlHead(string request, string referer = null)
{
if (string.IsNullOrEmpty(request))
{
Logging.LogNullError(nameof(request));
return(false);
}
using (HttpResponseMessage response = await UrlHeadToResponse(request, referer).ConfigureAwait(false)) {
return(response != null);
}
}
private void HandleSharedLibraryLockStatus(IPacketMsg packetMsg)
{
if (packetMsg == null)
{
Logging.LogNullError(nameof(packetMsg), Bot.BotName);
return;
}
ClientMsgProtobuf <CMsgClientSharedLibraryLockStatus> response = new ClientMsgProtobuf <CMsgClientSharedLibraryLockStatus>(packetMsg);
Client.PostCallback(new SharedLibraryLockStatusCallback(packetMsg.TargetJobID, response.Body));
}
private async Task <bool> UrlPost(string request, IEnumerable <KeyValuePair <string, string> > data = null, string referer = null)
{
if (string.IsNullOrEmpty(request))
{
Logging.LogNullError(nameof(request), Identifier);
return(false);
}
using (HttpResponseMessage response = await UrlPostToResponse(request, data, referer).ConfigureAwait(false)) {
return(response != null);
}
}
private void HandleUserNotifications(IPacketMsg packetMsg)
{
if (packetMsg == null)
{
Logging.LogNullError(nameof(packetMsg), Bot.BotName);
return;
}
ClientMsgProtobuf <CMsgClientUserNotifications> response = new ClientMsgProtobuf <CMsgClientUserNotifications>(packetMsg);
Client.PostCallback(new NotificationsCallback(packetMsg.TargetJobID, response.Body));
}
private void HandlePlayingSessionState(IPacketMsg packetMsg)
{
if (packetMsg == null)
{
Logging.LogNullError(nameof(packetMsg), Bot.BotName);
return;
}
ClientMsgProtobuf <CMsgClientPlayingSessionState> response = new ClientMsgProtobuf <CMsgClientPlayingSessionState>(packetMsg);
Client.PostCallback(new PlayingSessionStateCallback(packetMsg.TargetJobID, response.Body));
}
private void HandleRedeemGuestPassResponse(IPacketMsg packetMsg)
{
if (packetMsg == null)
{
Logging.LogNullError(nameof(packetMsg), Bot.BotName);
return;
}
ClientMsgProtobuf <CMsgClientRedeemGuestPassResponse> response = new ClientMsgProtobuf <CMsgClientRedeemGuestPassResponse>(packetMsg);
Client.PostCallback(new RedeemGuestPassResponseCallback(packetMsg.TargetJobID, response.Body));
}
private static void OnRenamed(object sender, RenamedEventArgs e)
{
if ((sender == null) || (e == null))
{
Logging.LogNullError(nameof(sender) + " || " + nameof(e));
return;
}
Bot bot = GetBotFromConfigFileName(e.OldName);
bot?.OnNewConfigLoaded(new BotConfigEventArgs()).Forget();
}
private void HandleFSOfflineMessageNotification(IPacketMsg packetMsg)
{
if (packetMsg == null)
{
Logging.LogNullError(nameof(packetMsg), Bot.BotName);
return;
}
ClientMsgProtobuf <CMsgClientOfflineMessageNotification> response = new ClientMsgProtobuf <CMsgClientOfflineMessageNotification>(packetMsg);
Client.PostCallback(new OfflineMessageCallback(packetMsg.TargetJobID, response.Body));
}
private async Task <Uri> UrlHeadToUri(string request, string referer = null)
{
if (string.IsNullOrEmpty(request))
{
Logging.LogNullError(nameof(request), Identifier);
return(null);
}
using (HttpResponseMessage response = await UrlHeadToResponse(request, referer).ConfigureAwait(false)) {
return(response?.RequestMessage.RequestUri);
}
}
internal PurchaseResponseCallback(JobID jobID, CMsgClientPurchaseResponse msg)
{
if ((jobID == null) || (msg == null))
{
throw new ArgumentNullException(nameof(jobID) + " || " + nameof(msg));
}
JobID = jobID;
PurchaseResult = (EPurchaseResult)msg.purchase_result_details;
if (msg.purchase_receipt_info == null)
{
return;
}
KeyValue receiptInfo = new KeyValue();
using (MemoryStream ms = new MemoryStream(msg.purchase_receipt_info)) {
if (!receiptInfo.TryReadAsBinary(ms))
{
Logging.LogNullError(nameof(ms));
return;
}
}
List <KeyValue> lineItems = receiptInfo["lineitems"].Children;
if (lineItems.Count == 0)
{
return;
}
Items = new Dictionary <uint, string>(lineItems.Count);
foreach (KeyValue lineItem in lineItems)
{
uint packageID = lineItem["PackageID"].AsUnsignedInteger();
if (packageID == 0)
{
Logging.LogNullError(nameof(packageID));
return;
}
string gameName = lineItem["ItemDescription"].Value;
if (string.IsNullOrEmpty(gameName))
{
Logging.LogNullError(nameof(gameName));
return;
}
gameName = WebUtility.HtmlDecode(gameName); // Apparently steam expects client to decode sent HTML
Items[packageID] = WebUtility.HtmlDecode(gameName);
}
}
private static Version GetNetVersion()
{
uint release;
using (RegistryKey registryKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey("SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v4\\Full\\")) {
if (registryKey == null)
{
Logging.LogNullError(nameof(registryKey));
return(null);
}
object releaseObj = registryKey.GetValue("Release");
if (releaseObj == null)
{
Logging.LogNullError(nameof(releaseObj));
return(null);
}
if (!uint.TryParse(releaseObj.ToString(), out release) || (release == 0))
{
Logging.LogNullError(nameof(release));
return(null);
}
}
if (release >= 394747)
{
return(new Version(4, 6, 2));
}
if (release >= 394254)
{
return(new Version(4, 6, 1));
}
if (release >= 393295)
{
return(new Version(4, 6));
}
if (release >= 379893)
{
return(new Version(4, 5, 2));
}
if (release >= 378675)
{
return(new Version(4, 5, 1));
}
return(release >= 378389 ? new Version(4, 5) : null);
}
private static void ParseArgs(IEnumerable <string> args)
{
if (args == null)
{
Logging.LogNullError(nameof(args));
return;
}
foreach (string arg in args)
{
switch (arg)
{
case "":
break;
case "--client":
Mode = EMode.Client;
break;
case "--server":
Mode = EMode.Server;
WCF.StartServer();
break;
default:
if (arg.StartsWith("--", StringComparison.Ordinal))
{
Logging.LogGenericWarning("Unrecognized parameter: " + arg);
continue;
}
if (Mode != EMode.Client)
{
Logging.LogGenericWarning("Ignoring command because --client wasn't specified: " + arg);
continue;
}
Logging.LogGenericInfo("Command sent: " + arg);
// We intentionally execute this async block synchronously
Logging.LogGenericInfo("Response received: " + WCF.SendCommand(arg));
/*
* Task.Run(async () => {
* Logging.LogGenericNotice("WCF", "Response received: " + await WCF.SendCommand(arg).ConfigureAwait(false));
* }).Wait();
*/
break;
}
}
}
internal static BotConfig Load(string filePath)
{
if (string.IsNullOrEmpty(filePath))
{
Logging.LogNullError(nameof(filePath));
return(null);
}
if (!File.Exists(filePath))
{
return(null);
}
BotConfig botConfig;
try {
botConfig = JsonConvert.DeserializeObject <BotConfig>(File.ReadAllText(filePath));
} catch (Exception e) {
Logging.LogGenericException(e);
return(null);
}
if (botConfig == null)
{
Logging.LogNullError(nameof(botConfig));
return(null);
}
// Support encrypted passwords
if ((botConfig.PasswordFormat != CryptoHelper.ECryptoMethod.PlainText) && !string.IsNullOrEmpty(botConfig.SteamPassword))
{
// In worst case password will result in null, which will have to be corrected by user during runtime
botConfig.SteamPassword = CryptoHelper.Decrypt(botConfig.PasswordFormat, botConfig.SteamPassword);
}
// User might not know what he's doing
// Ensure that he can't screw core ASF variables
if (botConfig.GamesPlayedWhileIdle.Count <= CardsFarmer.MaxGamesPlayedConcurrently)
{
return(botConfig);
}
Logging.LogGenericWarning("Playing more than " + CardsFarmer.MaxGamesPlayedConcurrently + " games concurrently is not possible, only first " + CardsFarmer.MaxGamesPlayedConcurrently + " entries from GamesPlayedWhileIdle will be used");
HashSet <uint> validGames = new HashSet <uint>(botConfig.GamesPlayedWhileIdle.Take(CardsFarmer.MaxGamesPlayedConcurrently));
botConfig.GamesPlayedWhileIdle.IntersectWith(validGames);
botConfig.GamesPlayedWhileIdle.TrimExcess();
return(botConfig);
}
internal Dictionary <uint, string> GetOwnedGames(ulong steamID)
{
if ((steamID == 0) || string.IsNullOrEmpty(Bot.BotConfig.SteamApiKey))
{
// TODO: Correct this when Mono 4.4+ will be a latest stable one | https://bugzilla.xamarin.com/show_bug.cgi?id=39455
Logging.LogNullError("steamID || SteamApiKey", Bot.BotName);
//Logging.LogNullError(nameof(steamID) + " || " + nameof(Bot.BotConfig.SteamApiKey), Bot.BotName);
return(null);
}
KeyValue response = null;
using (dynamic iPlayerService = WebAPI.GetInterface("IPlayerService", Bot.BotConfig.SteamApiKey)) {
iPlayerService.Timeout = Timeout;
for (byte i = 0; (i < WebBrowser.MaxRetries) && (response == null); i++)
{
try {
response = iPlayerService.GetOwnedGames(
steamid: steamID,
include_appinfo: 1,
secure: !Program.GlobalConfig.ForceHttp
);
} catch (Exception e) {
Logging.LogGenericException(e, Bot.BotName);
}
}
}
if (response == null)
{
Logging.LogGenericWTF("Request failed even after " + WebBrowser.MaxRetries + " tries", Bot.BotName);
return(null);
}
Dictionary <uint, string> result = new Dictionary <uint, string>(response["games"].Children.Count);
foreach (KeyValue game in response["games"].Children)
{
uint appID = (uint)game["appid"].AsUnsignedLong();
if (appID == 0)
{
Logging.LogNullError(nameof(appID));
continue;
}
result[appID] = game["name"].Value;
}
return(result);
}
