5 seconds seems good for now

Random Number for delayed connecting bots

ArchiSteamFarm/ArchiHandler.cs

@@ -24,6 +24,8 @@
 
 using SteamKit2;
 using SteamKit2.Internal;
+using System.Collections.Generic;
+using System.IO;
 
 namespace ArchiSteamFarm {
 	internal sealed class ArchiHandler : ClientMsgHandler {
@@ -33,21 +35,29 @@ namespace ArchiSteamFarm {
 				Unknown = -1,
 				OK = 0,
 				AlreadyOwned = 9,
+				RegionLockedKey = 13,
 				InvalidKey = 14,
 				DuplicatedKey = 15,
+				BaseGameRequired = 24,
 				OnCooldown = 53
 			}
 
 			internal EResult Result { get; private set; }
 			internal EPurchaseResult PurchaseResult { get; private set; }
-			internal int ErrorCode { get; private set; }
+			internal KeyValue ReceiptInfo { get; private set; } = new KeyValue();
-			internal byte[] ReceiptInfo { get; private set; }
+			internal Dictionary<uint, string> Items { get; private set; } = new Dictionary<uint, string>();
 
 			internal PurchaseResponseCallback(CMsgClientPurchaseResponse body) {
 				Result = (EResult) body.eresult;
-				ErrorCode = body.purchase_result_details;
+				PurchaseResult = (EPurchaseResult) body.purchase_result_details;
-				ReceiptInfo = body.purchase_receipt_info;
+
-				PurchaseResult = (EPurchaseResult) ErrorCode;
+				using (MemoryStream ms = new MemoryStream(body.purchase_receipt_info)) {
+					if (ReceiptInfo.TryReadAsBinary(ms)) {
+						foreach (KeyValue lineItem in ReceiptInfo["lineitems"].Children) {
+							Items.Add((uint) lineItem["PackageID"].AsUnsignedLong(), lineItem["ItemDescription"].AsString());
+						}
+					}
+				}
 			}
 		}
 

ArchiSteamFarm/ArchiSteamFarm.csproj

@@ -51,11 +51,21 @@
     </DocumentationFile>
     <Prefer32Bit>true</Prefer32Bit>
   </PropertyGroup>
+  <PropertyGroup>
+    <ApplicationIcon>cirno.ico</ApplicationIcon>
+  </PropertyGroup>
+  <PropertyGroup>
+    <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="HtmlAgilityPack, Version=1.4.9.0, Culture=neutral, PublicKeyToken=bd319b19eaf3b43a, processorArchitecture=MSIL">
       <HintPath>..\packages\HtmlAgilityPack.1.4.9\lib\Net45\HtmlAgilityPack.dll</HintPath>
       <Private>True</Private>
     </Reference>
+    <Reference Include="Newtonsoft.Json, Version=8.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\packages\Newtonsoft.Json.8.0.1-beta1\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="protobuf-net, Version=2.0.0.668, Culture=neutral, PublicKeyToken=257b51d87d2e4d67, processorArchitecture=MSIL">
       <HintPath>..\packages\protobuf-net.2.0.0.668\lib\net40\protobuf-net.dll</HintPath>
       <Private>True</Private>
@@ -79,6 +89,7 @@
     <Compile Include="Bot.cs" />
     <Compile Include="CardsFarmer.cs" />
     <Compile Include="CMsgClientClanInviteAction.cs" />
+    <Compile Include="Debugging.cs" />
     <Compile Include="Logging.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -103,7 +114,25 @@
       <Install>false</Install>
     </BootstrapperPackage>
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="cirno.ico" />
+    <Content Include="config\example.xml">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>
+    </PreBuildEvent>
+  </PropertyGroup>
+  <PropertyGroup>
+    <PostBuildEvent Condition=" '$(OS)' != 'Unix' ">if $(ConfigurationName) == Release (
+    mkdir "$(TargetDir)out" "$(TargetDir)out\config"
+    copy "$(TargetDir)config\example.xml" "$(TargetDir)out\config"
+    "$(SolutionDir)tools\ILMerge.exe" /out:"$(TargetDir)out\ASF.exe" "$(TargetDir)$(TargetName).exe" "$(TargetDir)*.dll" /target:exe /targetplatform:v4,C:\Windows\Microsoft.NET\Framework64\v4.0.30319 /wildcards
+    del "$(TargetDir)out\ASF.pdb"
+)</PostBuildEvent>
+  </PropertyGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">

ArchiSteamFarm/ArchiWebHandler.cs

@@ -28,6 +28,7 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Net;
+using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -47,8 +48,9 @@ namespace ArchiSteamFarm {
 				return "http://steamcommunity.com/id/" + VanityURL + "/home_process";
 			} else if (SteamID != 0) {
 				return "http://steamcommunity.com/profiles/" + SteamID + "/home_process";
+			} else {
+				return null;
 			}
-			return null;
 		}
 
 		internal ArchiWebHandler(Bot bot, string apiKey) {
@@ -56,12 +58,10 @@ namespace ArchiSteamFarm {
 
 			if (!string.IsNullOrEmpty(apiKey) && !apiKey.Equals("null")) {
 				ApiKey = apiKey;
-			} else {
-				ApiKey = null;
 			}
 		}
 
-		internal void Init(SteamClient steamClient, string webAPIUserNonce, string vanityURL) {
+		internal async Task Init(SteamClient steamClient, string webAPIUserNonce, string vanityURL, string parentalPin) {
 			if (steamClient == null || steamClient.SteamID == null || string.IsNullOrEmpty(webAPIUserNonce)) {
 				return;
 			}
@@ -124,6 +124,30 @@ namespace ArchiSteamFarm {
 			SteamCookieDictionary.Add("steamLoginSecure", steamLoginSecure);
 			SteamCookieDictionary.Add("birthtime", "-473356799"); // ( ͡° ͜ʖ ͡°)
 
+			if (!string.IsNullOrEmpty(parentalPin) && !parentalPin.Equals("0")) {
+				Logging.LogGenericInfo(Bot.BotName, "Unlocking parental account...");
+				Dictionary<string, string> postData = new Dictionary<string, string>() {
+					{"pin", parentalPin}
+				};
+
+				HttpResponseMessage response = await Utilities.UrlPostRequestWithResponse("https://steamcommunity.com/parental/ajaxunlock", postData, SteamCookieDictionary, "https://steamcommunity.com/").ConfigureAwait(false);
+				if (response != null && response.IsSuccessStatusCode) {
+					Logging.LogGenericInfo(Bot.BotName, "Success!");
+
+					var setCookieValues = response.Headers.GetValues("Set-Cookie");
+					foreach (string setCookieValue in setCookieValues) {
+						if (setCookieValue.Contains("steamparental=")) {
+							string setCookie = setCookieValue.Substring(setCookieValue.IndexOf("steamparental=") + 14);
+							setCookie = setCookie.Substring(0, setCookie.IndexOf(';'));
+							SteamCookieDictionary.Add("steamparental", setCookie);
+							break;
+						}
+					}
+				} else {
+					Logging.LogGenericInfo(Bot.BotName, "Failed!");
+				}
+			}
+
 			Bot.Trading.CheckTrades();
 		}
 
@@ -195,9 +219,49 @@ namespace ArchiSteamFarm {
 				}
 				result.Add(tradeOffer);
 			}
+
 			return result;
 		}
 
+		internal async Task JoinClan(ulong clanID) {
+			if (clanID == 0) {
+				return;
+			}
+
+			string sessionID;
+			if (!SteamCookieDictionary.TryGetValue("sessionid", out sessionID)) {
+				return;
+			}
+
+			string request = "http://steamcommunity.com/gid/" + clanID;
+
+			Dictionary<string, string> postData = new Dictionary<string, string>() {
+				{"sessionID", sessionID},
+				{"action", "join"}
+			};
+
+			await Utilities.UrlPostRequest(request, postData, SteamCookieDictionary).ConfigureAwait(false);
+		}
+
+		internal async Task LeaveClan(ulong clanID) {
+			if (clanID == 0) {
+				return;
+			}
+
+			string sessionID;
+			if (!SteamCookieDictionary.TryGetValue("sessionid", out sessionID)) {
+				return;
+			}
+
+			string request = GetHomeProcess();
+			Dictionary<string, string> postData = new Dictionary<string, string>() {
+				{"sessionID", sessionID},
+				{"action", "leaveGroup"},
+				{"groupId", clanID.ToString()}
+			};
+			await Utilities.UrlPostRequest(request, postData, SteamCookieDictionary).ConfigureAwait(false);
+		}
+
 		internal async Task<bool> AcceptTradeOffer(ulong tradeID) {
 			if (tradeID == 0) {
 				return false;
@@ -217,7 +281,21 @@ namespace ArchiSteamFarm {
 				{"tradeofferid", tradeID.ToString()}
 			};
 
-			return await Utilities.UrlPostRequest(request, postData, SteamCookieDictionary, referer).ConfigureAwait(false);
+			HttpResponseMessage result = await Utilities.UrlPostRequestWithResponse(request, postData, SteamCookieDictionary, referer).ConfigureAwait(false);
+			bool success = result.IsSuccessStatusCode;
+
+			if (!success) {
+				Logging.LogGenericWarning(Bot.BotName, "Request failed, reason: " + result.ReasonPhrase);
+				switch (result.StatusCode) {
+					case HttpStatusCode.InternalServerError:
+						Logging.LogGenericWarning(Bot.BotName, "That might be caused by 7-days trade lock from new device");
+						Logging.LogGenericWarning(Bot.BotName, "Try again in 7 days, declining that offer for now");
+						DeclineTradeOffer(tradeID);
+						break;
+				}
+			}
+
+			return success;
 		}
 
 		internal bool DeclineTradeOffer(ulong tradeID) {
@@ -250,39 +328,20 @@ namespace ArchiSteamFarm {
 			return response != null; // Steam API doesn't respond with any error code, assume any response is a success
 		}
 
-		internal async Task LeaveClan(ulong clanID) {
-			if (clanID == 0) {
-				return;
-			}
-
-			string sessionID;
-			if (!SteamCookieDictionary.TryGetValue("sessionid", out sessionID)) {
-				return;
-			}
-
-			string request = GetHomeProcess();
-			Dictionary<string, string> postData = new Dictionary<string, string>() {
-				{"sessionID", sessionID},
-				{"action", "leaveGroup"},
-				{"groupId", clanID.ToString()}
-			};
-			await Utilities.UrlPostRequest(request, postData, SteamCookieDictionary).ConfigureAwait(false);
-		}
-
 		internal async Task<HtmlDocument> GetBadgePage(int page) {
-			HtmlDocument result = null;
+			if (SteamID == 0 || page == 0) {
-			if (SteamID != 0 && page != 0) {
+				return null;
-				result = await Utilities.UrlToHtmlDocument("http://steamcommunity.com/profiles/" + SteamID + "/badges?p=" + page, SteamCookieDictionary).ConfigureAwait(false);
 			}
-			return result;
+
+			return await Utilities.UrlToHtmlDocument("http://steamcommunity.com/profiles/" + SteamID + "/badges?p=" + page, SteamCookieDictionary).ConfigureAwait(false);
 		}
 
 		internal async Task<HtmlDocument> GetGameCardsPage(ulong appID) {
-			HtmlDocument result = null;
+			if (SteamID == 0 || appID == 0) {
-			if (SteamID != 0 && appID != 0) {
+				return null;
-				result = await Utilities.UrlToHtmlDocument("http://steamcommunity.com/profiles/" + SteamID + "/gamecards/" + appID, SteamCookieDictionary).ConfigureAwait(false);
 			}
-			return result;
+
+			return await Utilities.UrlToHtmlDocument("http://steamcommunity.com/profiles/" + SteamID + "/gamecards/" + appID, SteamCookieDictionary).ConfigureAwait(false);
 		}
 	}
 }

ArchiSteamFarm/Bot.cs

@@ -27,7 +27,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Security.Cryptography;
-using System.Threading;
 using System.Threading.Tasks;
 using System.Xml;
 
@@ -35,77 +34,79 @@ namespace ArchiSteamFarm {
 	internal class Bot {
 		private const ushort CallbackSleep = 500; // In miliseconds
 
-		private readonly Dictionary<string, string> Config = new Dictionary<string, string>();
+		private static readonly Dictionary<string, Bot> Bots = new Dictionary<string, Bot>();
 
-		internal readonly string BotName;
 		private readonly string ConfigFile;
 		private readonly string SentryFile;
 
-		private readonly CardsFarmer CardsFarmer;
+		private bool IsRunning = false;
-
-		internal ulong BotID { get; private set; }
 		private string AuthCode, TwoFactorAuth;
 
+		internal readonly string BotName;
+
 		internal ArchiHandler ArchiHandler { get; private set; }
 		internal ArchiWebHandler ArchiWebHandler { get; private set; }
 		internal CallbackManager CallbackManager { get; private set; }
+		internal CardsFarmer CardsFarmer { get; private set; }
 		internal SteamClient SteamClient { get; private set; }
 		internal SteamFriends SteamFriends { get; private set; }
 		internal SteamUser SteamUser { get; private set; }
 		internal Trading Trading { get; private set; }
 
 		// Config variables
-		private bool Enabled { get { return bool.Parse(Config["Enabled"]); } }
+		internal bool Enabled { get; private set; } = false;
-		private string SteamLogin { get { return Config["SteamLogin"]; } }
+		internal string SteamLogin { get; private set; } = "null";
-		private string SteamPassword { get { return Config["SteamPassword"]; } }
+		internal string SteamPassword { get; private set; } = "null";
-		private string SteamNickname { get { return Config["SteamNickname"]; } }
+		internal string SteamNickname { get; private set; } = "null";
-		private string SteamApiKey { get { return Config["SteamApiKey"]; } }
+		internal string SteamApiKey { get; private set; } = "null";
-		internal ulong SteamMasterID { get { return ulong.Parse(Config["SteamMasterID"]); } }
+		internal string SteamParentalPIN { get; private set; } = "0";
-		private ulong SteamMasterClanID { get { return ulong.Parse(Config["SteamMasterClanID"]); } }
+		internal ulong SteamMasterID { get; private set; } = 0;
+		internal ulong SteamMasterClanID { get; private set; } = 0;
+		internal bool ShutdownOnFarmingFinished { get; private set; } = false;
+		internal HashSet<uint> Blacklist { get; private set; } = new HashSet<uint> { 303700, 335590, 368020 };
+		internal bool Statistics { get; private set; } = true;
+
+		internal static int GetRunningBotsCount() {
+			int result;
+			lock (Bots) {
+				result = Bots.Count;
+			}
+			return result;
+		}
+
+		internal static async Task ShutdownAllBots() {
+			List<Task> tasks = new List<Task>();
+			lock (Bots) {
+				foreach (Bot bot in Bots.Values) {
+					tasks.Add(Task.Run(async () => await bot.Shutdown().ConfigureAwait(false)));
+				}
+			}
+			await Task.WhenAll(tasks).ConfigureAwait(false);
+		}
 
 		internal Bot(string botName) {
+			if (Bots.ContainsKey(botName)) {
+				return;
+			}
+
 			BotName = botName;
-			CardsFarmer = new CardsFarmer(this);
 
 			ConfigFile = Path.Combine(Program.ConfigDirectoryPath, BotName + ".xml");
 			SentryFile = Path.Combine(Program.ConfigDirectoryPath, BotName + ".bin");
 
-			ReadConfig();
+			if (!ReadConfig()) {
+				return;
+			}
 
 			if (!Enabled) {
 				return;
 			}
 
-			Start();
+			lock (Bots) {
-		}
+				Bots.Add(BotName, this);
-
-		private void ReadConfig() {
-			using (XmlReader reader = XmlReader.Create(ConfigFile)) {
-				while (reader.Read()) {
-					if (reader.NodeType != XmlNodeType.Element) {
-						continue;
-					}
-
-					string key = reader.Name;
-					if (string.IsNullOrEmpty(key)) {
-						continue;
-					}
-
-					string value = reader.GetAttribute("value");
-					if (string.IsNullOrEmpty(value)) {
-						continue;
-					}
-
-					Config.Add(key, value);
-				}
-			}
-		}
-
-		internal void Start() {
-			if (SteamClient != null) {
-				return;
 			}
 
+			// Initialize
 			SteamClient = new SteamClient();
 
 			ArchiHandler = new ArchiHandler();
@@ -118,6 +119,7 @@ namespace ArchiSteamFarm {
 			SteamFriends = SteamClient.GetHandler<SteamFriends>();
 			CallbackManager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList);
 			CallbackManager.Subscribe<SteamFriends.FriendMsgCallback>(OnFriendMsg);
+			CallbackManager.Subscribe<SteamFriends.PersonaStateCallback>(OnPersonaState);
 
 			SteamUser = SteamClient.GetHandler<SteamUser>();
 			CallbackManager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo);
@@ -129,20 +131,134 @@ namespace ArchiSteamFarm {
 			CallbackManager.Subscribe<ArchiHandler.PurchaseResponseCallback>(OnPurchaseResponse);
 
 			ArchiWebHandler = new ArchiWebHandler(this, SteamApiKey);
+			CardsFarmer = new CardsFarmer(this);
 			Trading = new Trading(this);
 
-			SteamClient.Connect();
+			// Start
-			Task.Run(() => HandleCallbacks());
+			var fireAndForget = Task.Run(async () => await Start().ConfigureAwait(false));
 		}
 
-		internal void Stop() {
+		private bool ReadConfig() {
-			if (SteamClient == null) {
+			if (!File.Exists(ConfigFile)) {
+				return false;
+			}
+
+			try {
+				using (XmlReader reader = XmlReader.Create(ConfigFile)) {
+					while (reader.Read()) {
+						if (reader.NodeType != XmlNodeType.Element) {
+							continue;
+						}
+
+						string key = reader.Name;
+						if (string.IsNullOrEmpty(key)) {
+							continue;
+						}
+
+						string value = reader.GetAttribute("value");
+						if (string.IsNullOrEmpty(value)) {
+							continue;
+						}
+
+						switch (key) {
+							case "Enabled":
+								Enabled = bool.Parse(value);
+								break;
+							case "SteamLogin":
+								SteamLogin = value;
+								break;
+							case "SteamPassword":
+								SteamPassword = value;
+								break;
+							case "SteamNickname":
+								SteamNickname = value;
+								break;
+							case "SteamApiKey":
+								SteamApiKey = value;
+								break;
+							case "SteamParentalPIN":
+								SteamParentalPIN = value;
+								break;
+							case "SteamMasterID":
+								SteamMasterID = ulong.Parse(value);
+								break;
+							case "SteamMasterClanID":
+								SteamMasterClanID = ulong.Parse(value);
+								break;
+							case "ShutdownOnFarmingFinished":
+								ShutdownOnFarmingFinished = bool.Parse(value);
+								break;
+							case "Blacklist":
+								Blacklist.Clear();
+								foreach (string appID in value.Split(',')) {
+									Blacklist.Add(uint.Parse(appID));
+								}
+								break;
+							case "Statistics":
+								Statistics = bool.Parse(value);
+								break;
+							default:
+								Logging.LogGenericWarning(BotName, "Unrecognized config value: " + key + "=" + value);
+								break;
+						}
+					}
+				}
+			} catch (XmlException e) {
+				Logging.LogGenericException(BotName, e);
+				Logging.LogGenericError(BotName, "Your config for this bot instance is invalid, it won't run!");
+				return false;
+			}
+
+			return true;
+		}
+
+		internal async Task Start() {
+			if (IsRunning) {
 				return;
 			}
 
+			IsRunning = true;
+
+			Logging.LogGenericInfo(BotName, "Starting...");
+			await Program.LimitSteamRequestsAsync().ConfigureAwait(false);
+			SteamClient.Connect();
+
+			var fireAndForget = Task.Run(() => HandleCallbacks());
+		}
+
+		internal async Task Stop() {
+			if (!IsRunning) {
+				return;
+			}
+
+			await CardsFarmer.StopFarming().ConfigureAwait(false);
+			IsRunning = false;
 			SteamClient.Disconnect();
-			SteamClient = null;
+		}
-			CallbackManager = null;
+
+		private async Task<bool> Shutdown(string botNameToShutdown) {
+			Bot botToShutdown;
+			if (!Bots.TryGetValue(botNameToShutdown, out botToShutdown)) {
+				return false;
+			}
+
+			await botToShutdown.Stop().ConfigureAwait(false);
+			lock (Bots) {
+				Bots.Remove(botNameToShutdown);
+			}
+
+			Program.OnBotShutdown(botToShutdown);
+			return true;
+		}
+
+		internal async Task<bool> Shutdown() {
+			return await Shutdown(BotName).ConfigureAwait(false);
+		}
+
+		internal async Task OnFarmingFinished() {
+			if (ShutdownOnFarmingFinished) {
+				await Shutdown().ConfigureAwait(false);
+			}
 		}
 
 		internal void PlayGame(params ulong[] gameIDs) {
@@ -151,11 +267,68 @@ namespace ArchiSteamFarm {
 
 		private void HandleCallbacks() {
 			TimeSpan timeSpan = TimeSpan.FromMilliseconds(CallbackSleep);
-			while (CallbackManager != null) {
+			while (IsRunning) {
 				CallbackManager.RunWaitCallbacks(timeSpan);
 			}
 		}
 
+		private void SendMessageToUser(ulong steamID, string message) {
+			if (steamID == 0 || string.IsNullOrEmpty(message)) {
+				return;
+			}
+
+			SteamFriends.SendChatMessage(steamID, EChatEntryType.ChatMsg, message);
+		}
+
+
+
+		private void ResponseStatus(ulong steamID) {
+			if (steamID == 0) {
+				return;
+			}
+
+			SendMessageToUser(steamID, "Currently " + Bots.Count + " bots are running");
+		}
+
+		private void ResponseStart(ulong steamID, string botNameToStart) {
+			if (steamID == 0 || string.IsNullOrEmpty(botNameToStart)) {
+				return;
+			}
+
+			if (Bots.ContainsKey(botNameToStart)) {
+				SendMessageToUser(steamID, "That bot instance is already running!");
+				return;
+			}
+
+			new Bot(botNameToStart);
+			if (Bots.ContainsKey(botNameToStart)) {
+				SendMessageToUser(steamID, "Done!");
+			} else {
+				SendMessageToUser(steamID, "That bot instance failed to start, make sure that " + botNameToStart + ".xml config exists and bot is active!");
+			}
+		}
+
+		private async Task ResponseStop(ulong steamID, string botNameToShutdown) {
+			if (steamID == 0 || string.IsNullOrEmpty(botNameToShutdown)) {
+				return;
+			}
+
+			if (!Bots.ContainsKey(botNameToShutdown)) {
+				SendMessageToUser(steamID, "That bot instance is already inactive!");
+				return;
+			}
+
+			if (await Shutdown(botNameToShutdown).ConfigureAwait(false)) {
+				SendMessageToUser(steamID, "Done!");
+			} else {
+				SendMessageToUser(steamID, "That bot instance failed to shutdown!");
+			}
+		}
+
+
+
+
+
 		private void OnConnected(SteamClient.ConnectedCallback callback) {
 			if (callback == null) {
 				return;
@@ -174,6 +347,14 @@ namespace ArchiSteamFarm {
 				sentryHash = CryptoHelper.SHAHash(sentryFileContent);
 			}
 
+			if (SteamLogin.Equals("null")) {
+				SteamLogin = Program.GetUserInput(BotName, Program.EUserInputType.Login);
+			}
+
+			if (SteamPassword.Equals("null")) {
+				SteamPassword = Program.GetUserInput(BotName, Program.EUserInputType.Password);
+			}
+
 			SteamUser.LogOn(new SteamUser.LogOnDetails {
 				Username = SteamLogin,
 				Password = SteamPassword,
@@ -183,16 +364,21 @@ namespace ArchiSteamFarm {
 			});
 		}
 
-		private void OnDisconnected(SteamClient.DisconnectedCallback callback) {
+		private async void OnDisconnected(SteamClient.DisconnectedCallback callback) {
 			if (callback == null) {
 				return;
 			}
+
+			if (!IsRunning) {
+				return;
+			}
+
 			if (SteamClient == null) {
 				return;
 			}
 
 			Logging.LogGenericWarning(BotName, "Disconnected from Steam, reconnecting...");
-			Thread.Sleep(TimeSpan.FromMilliseconds(CallbackSleep));
+			await Program.LimitSteamRequestsAsync().ConfigureAwait(false);
 			SteamClient.Connect();
 		}
 
@@ -222,7 +408,7 @@ namespace ArchiSteamFarm {
 			}
 		}
 
-		private void OnFriendMsg(SteamFriends.FriendMsgCallback callback) {
+		private async void OnFriendMsg(SteamFriends.FriendMsgCallback callback) {
 			if (callback == null) {
 				return;
 			}
@@ -243,7 +429,55 @@ namespace ArchiSteamFarm {
 
 			if (message.Length == 17 && message[5] == '-' && message[11] == '-') {
 				ArchiHandler.RedeemKey(message);
+				return;
 			}
+
+			if (!message.StartsWith("!")) {
+				return;
+			}
+
+			if (!message.Contains(" ")) {
+				switch (message) {
+					case "!exit":
+						await ShutdownAllBots().ConfigureAwait(false);
+						break;
+					case "!farm":
+						await CardsFarmer.StartFarming().ConfigureAwait(false);
+						SendMessageToUser(steamID, "Done!");
+						break;
+					case "!restart":
+						await Program.Restart().ConfigureAwait(false);
+						break;
+					case "!status":
+						ResponseStatus(steamID);
+						break;
+					case "!stop":
+						await Shutdown().ConfigureAwait(false);
+						break;
+				}
+			} else {
+				string[] args = message.Split(' ');
+				switch (args[0]) {
+					case "!start":
+						ResponseStart(steamID, args[1]);
+						break;
+					case "!stop":
+						await ResponseStop(steamID, args[1]).ConfigureAwait(false);
+						break;
+				}
+			}
+		}
+
+		private void OnPersonaState(SteamFriends.PersonaStateCallback callback) {
+			if (callback == null) {
+				return;
+			}
+
+			SteamID steamID = callback.FriendID;
+			SteamID sourceSteamID = callback.SourceSteamID;
+			string steamNickname = callback.Name;
+			EPersonaState personaState = callback.State;
+			EClanRank clanRank = (EClanRank) callback.ClanRank;
 		}
 
 		private void OnAccountInfo(SteamUser.AccountInfoCallback callback) {
@@ -267,45 +501,48 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			if (callback.ClientSteamID != 0) {
-				BotID = callback.ClientSteamID;
-			}
-
 			EResult result = callback.Result;
 			switch (result) {
 				case EResult.AccountLogonDenied:
-					AuthCode = Program.GetSteamGuardCode(SteamLogin, false);
+					AuthCode = Program.GetUserInput(SteamLogin, Program.EUserInputType.SteamGuard);
 					break;
 				case EResult.AccountLoginDeniedNeedTwoFactor:
-					TwoFactorAuth = Program.GetSteamGuardCode(SteamLogin, true);
+					TwoFactorAuth = Program.GetUserInput(SteamLogin, Program.EUserInputType.TwoFactorAuthentication);
 					break;
 				case EResult.OK:
 					Logging.LogGenericInfo(BotName, "Successfully logged on!");
 
-					string steamNickname = SteamNickname;
+					if (!SteamNickname.Equals("null")) {
-					if (!string.IsNullOrEmpty(steamNickname) && !steamNickname.Equals("null")) {
+						SteamFriends.SetPersonaName(SteamNickname);
-						SteamFriends.SetPersonaName(steamNickname);
 					}
 
-					ArchiWebHandler.Init(SteamClient, callback.WebAPIUserNonce, callback.VanityURL);
+					if (SteamParentalPIN.Equals("null")) {
+						SteamParentalPIN = Program.GetUserInput(BotName, Program.EUserInputType.SteamParentalPIN);
+					}
+
+					await ArchiWebHandler.Init(SteamClient, callback.WebAPIUserNonce, callback.VanityURL, SteamParentalPIN).ConfigureAwait(false);
 
 					ulong clanID = SteamMasterClanID;
 					if (clanID != 0) {
 						SteamFriends.JoinChat(clanID);
 					}
 
+					if (Statistics) {
+						SteamFriends.JoinChat(Program.ArchiSCFarmGroup);
+						await ArchiWebHandler.JoinClan(Program.ArchiSCFarmGroup).ConfigureAwait(false);
+					}
+
 					await CardsFarmer.StartFarming().ConfigureAwait(false);
 					break;
 				case EResult.Timeout:
 				case EResult.TryAnotherCM:
 					Logging.LogGenericWarning(BotName, "Unable to login to Steam: " + callback.Result + " / " + callback.ExtendedResult + ", retrying...");
-					Stop();
+					await Stop().ConfigureAwait(false);
-					Thread.Sleep(5000);
+					await Start().ConfigureAwait(false);
-					Start();
 					break;
 				default:
 					Logging.LogGenericWarning(BotName, "Unable to login to Steam: " + callback.Result + " / " + callback.ExtendedResult);
-					Stop();
+					await Shutdown().ConfigureAwait(false);
 					break;
 			}
 		}
@@ -366,7 +603,8 @@ namespace ArchiSteamFarm {
 			}
 
 			var purchaseResult = callback.PurchaseResult;
-			SteamFriends.SendChatMessage(SteamMasterID, EChatEntryType.ChatMsg, "Status: " + purchaseResult);
+			var items = callback.Items;
+			SendMessageToUser(SteamMasterID, "Status: " + purchaseResult + " | Items: " + string.Join("", items));
 
 			if (purchaseResult == ArchiHandler.PurchaseResponseCallback.EPurchaseResult.OK) {
 				await CardsFarmer.StartFarming().ConfigureAwait(false);

ArchiSteamFarm/CardsFarmer.cs

@@ -31,20 +31,33 @@ namespace ArchiSteamFarm {
 	internal class CardsFarmer {
 		private const byte StatusCheckSleep = 5; // In minutes, how long to wait before checking the appID again
 
+		private readonly ManualResetEvent FarmResetEvent = new ManualResetEvent(false);
+		private readonly SemaphoreSlim Semaphore = new SemaphoreSlim(1);
 		private readonly Bot Bot;
-		private bool NowFarming;
+
-		private readonly AutoResetEvent AutoResetEvent = new AutoResetEvent(false);
+		private volatile bool NowFarming = false;
 
 		internal CardsFarmer(Bot bot) {
 			Bot = bot;
 		}
 
 		internal async Task StartFarming() {
+			await StopFarming().ConfigureAwait(false);
+
+			await Semaphore.WaitAsync().ConfigureAwait(false);
+
+			if (NowFarming) {
+				Semaphore.Release();
+				return;
+			}
+
 			Logging.LogGenericInfo(Bot.BotName, "Checking badges...");
+
 			// Find the number of badge pages
 			HtmlDocument badgesDocument = await Bot.ArchiWebHandler.GetBadgePage(1).ConfigureAwait(false);
 			if (badgesDocument == null) {
 				Logging.LogGenericWarning(Bot.BotName, "Could not get badges information, farming is stopped!");
+				Semaphore.Release();
 				return;
 			}
 
@@ -74,13 +87,17 @@ namespace ArchiSteamFarm {
 				foreach (HtmlNode badgesPageNode in badgesPageNodes) {
 					string steamLink = badgesPageNode.GetAttributeValue("href", null);
 					if (steamLink == null) {
-						Logging.LogGenericWarning(Bot.BotName, "Couldn't get steamLink for one of the games: " + badgesPageNode.OuterHtml);
+						Logging.LogGenericError(Bot.BotName, "Couldn't get steamLink for one of the games: " + badgesPageNode.OuterHtml);
 						continue;
 					}
 
 					uint appID = (uint) Utilities.OnlyNumbers(steamLink);
 					if (appID == 0) {
-						Logging.LogGenericWarning(Bot.BotName, "Couldn't get appID for one of the games: " + badgesPageNode.OuterHtml);
+						Logging.LogGenericError(Bot.BotName, "Couldn't get appID for one of the games: " + badgesPageNode.OuterHtml);
+						continue;
+					}
+
+					if (Bot.Blacklist.Contains(appID)) {
 						continue;
 					}
 
@@ -95,11 +112,31 @@ namespace ArchiSteamFarm {
 				if (await Farm(appID).ConfigureAwait(false)) {
 					appIDs.Remove(appID);
 				} else {
-					break;
+					return;
 				}
 			}
 
 			Logging.LogGenericInfo(Bot.BotName, "Farming finished!");
+			await Bot.OnFarmingFinished().ConfigureAwait(false);
+		}
+
+		internal async Task StopFarming() {
+			await Semaphore.WaitAsync().ConfigureAwait(false);
+
+			if (!NowFarming) {
+				Semaphore.Release();
+				return;
+			}
+
+			Logging.LogGenericInfo(Bot.BotName, "Sending signal to stop farming");
+			FarmResetEvent.Set();
+			while (NowFarming) {
+				Logging.LogGenericInfo(Bot.BotName, "Waiting for reaction...");
+				await Utilities.SleepAsync(1000).ConfigureAwait(false);
+			}
+			FarmResetEvent.Reset();
+			Logging.LogGenericInfo(Bot.BotName, "Farming stopped!");
+			Semaphore.Release();
 		}
 
 		private async Task<bool?> ShouldFarm(ulong appID) {
@@ -115,12 +152,6 @@ namespace ArchiSteamFarm {
 		}
 
 		private async Task<bool> Farm(ulong appID) {
-			if (NowFarming) {
-				AutoResetEvent.Set();
-				Thread.Sleep(1000);
-				AutoResetEvent.Reset();
-			}
-
 			bool success = true;
 			bool? keepFarming = await ShouldFarm(appID).ConfigureAwait(false);
 			while (keepFarming == null || keepFarming.Value) {
@@ -128,17 +159,20 @@ namespace ArchiSteamFarm {
 					NowFarming = true;
 					Logging.LogGenericInfo(Bot.BotName, "Now farming: " + appID);
 					Bot.PlayGame(appID);
+					Semaphore.Release(); // We're farming, allow other tasks to shut us down
+				} else {
+					Logging.LogGenericInfo(Bot.BotName, "Still farming: " + appID);
 				}
-				if (AutoResetEvent.WaitOne(1000 * 60 * StatusCheckSleep)) {
+				if (FarmResetEvent.WaitOne(1000 * 60 * StatusCheckSleep)) {
 					success = false;
 					break;
 				}
 				keepFarming = await ShouldFarm(appID).ConfigureAwait(false);
 			}
 
-			Logging.LogGenericInfo(Bot.BotName, "Stopped farming: " + appID);
 			Bot.PlayGame(0);
 			NowFarming = false;
+			Logging.LogGenericInfo(Bot.BotName, "Stopped farming: " + appID);
 			return success;
 		}
 	}

ArchiSteamFarm/Debugging.cs

@@ -0,0 +1,41 @@
+/*
+    _                _      _  ____   _                           _____
+   / \    _ __  ___ | |__  (_)/ ___| | |_  ___   __ _  _ __ ___  |  ___|__ _  _ __  _ __ ___
+  / _ \  | '__|/ __|| '_ \ | |\___ \ | __|/ _ \ / _` || '_ ` _ \ | |_  / _` || '__|| '_ ` _ \
+ / ___ \ | |  | (__ | | | || | ___) || |_|  __/| (_| || | | | | ||  _|| (_| || |   | | | | | |
+/_/   \_\|_|   \___||_| |_||_||____/  \__|\___| \__,_||_| |_| |_||_|   \__,_||_|   |_| |_| |_|
+
+ Copyright 2015 Łukasz "JustArchi" Domeradzki
+ Contact: JustArchi@JustArchi.net
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+					
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+*/
+
+using System.Diagnostics;
+
+namespace ArchiSteamFarm {
+	internal static class Debugging {
+		internal static bool IsDebugBuild { get; private set; } = false;
+		internal static bool IsReleaseBuild { get { return !IsDebugBuild; } }
+
+		static Debugging() {
+			MarkIfDebug();
+		}
+
+		[Conditional("DEBUG")]
+		private static void MarkIfDebug() {
+			IsDebugBuild = true;
+		}
+	}
+}

ArchiSteamFarm/Logging.cs

@@ -50,6 +50,10 @@ namespace ArchiSteamFarm {
 			Log("[*] INFO: " + previousMethodName + "() <" + botName + "> " + message);
 		}
 
+		internal static void LogGenericNotice(string botName, string message, [CallerMemberName] string previousMethodName = "") {
+			Log("[*] NOTICE: " + previousMethodName + "() <" + botName + "> " + message);
+		}
+
 		[Conditional("DEBUG")]
 		internal static void LogGenericDebug(string botName, string message, [CallerMemberName] string previousMethodName = "") {
 			Log("[#] DEBUG: " + previousMethodName + "() <" + botName + "> " + message);

ArchiSteamFarm/Program.cs

@@ -22,64 +22,148 @@
 
 */
 
+using Newtonsoft.Json.Linq;
 using System;
-using System.Collections.Generic;
 using System.IO;
+using System.Reflection;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace ArchiSteamFarm {
 	internal static class Program {
-		internal const string ConfigDirectoryPath = "config";
+		internal enum EUserInputType {
-		private static readonly HashSet<Bot> Bots = new HashSet<Bot>();
+			Login,
-		internal static readonly object ConsoleLock = new object();
+			Password,
+			SteamGuard,
+			SteamParentalPIN,
+			TwoFactorAuthentication,
+		}
 
-		internal static void Exit(int exitCode = 0) {
+		internal const ulong ArchiSCFarmGroup = 103582791440160998;
-			ShutdownAllBots();
+		internal const string ConfigDirectoryPath = "config";
+		private const string LatestGithubReleaseURL = "https://api.github.com/repos/JustArchi/ArchiSteamFarm/releases/latest";
+
+		internal static readonly object ConsoleLock = new object();
+		private static readonly SemaphoreSlim SteamSemaphore = new SemaphoreSlim(1);
+		private static readonly ManualResetEvent ShutdownResetEvent = new ManualResetEvent(false);
+		private static readonly Assembly Assembly = Assembly.GetExecutingAssembly();
+		private static readonly string ExecutablePath = Assembly.Location;
+		private static readonly AssemblyName AssemblyName = Assembly.GetName();
+		private static readonly string ExeName = AssemblyName.Name + ".exe";
+		private static readonly string Version = AssemblyName.Version.ToString();
+
+		private static async Task CheckForUpdate() {
+			JObject response = await Utilities.UrlToJObject(LatestGithubReleaseURL).ConfigureAwait(false);
+			if (response == null) {
+				return;
+			}
+
+			string remoteVersion = response["tag_name"].ToString();
+			if (string.IsNullOrEmpty(remoteVersion)) {
+				return;
+			}
+
+			string localVersion = Version;
+
+			Logging.LogGenericNotice("", "Local version: " + localVersion);
+			Logging.LogGenericNotice("", "Remote version: " + remoteVersion);
+
+			int comparisonResult = localVersion.CompareTo(remoteVersion);
+			if (localVersion.CompareTo(remoteVersion) < 0) {
+				Logging.LogGenericNotice("", "New version is available!");
+				Logging.LogGenericNotice("", "Consider updating yourself!");
+				await Utilities.SleepAsync(5000).ConfigureAwait(false);
+			} else if (localVersion.CompareTo(remoteVersion) > 0) {
+				Logging.LogGenericNotice("", "You're currently using pre-release version!");
+				Logging.LogGenericNotice("", "Be careful!");
+			}
+		}
+
+		internal static async Task Exit(int exitCode = 0) {
+			await Bot.ShutdownAllBots().ConfigureAwait(false);
 			Environment.Exit(exitCode);
 		}
 
-		internal static string GetSteamGuardCode(string botLogin, bool twoFactorAuthentication) {
+		internal static async Task Restart() {
+			await Bot.ShutdownAllBots().ConfigureAwait(false);
+			System.Diagnostics.Process.Start(ExecutablePath);
+			Environment.Exit(0);
+		}
+
+		internal static async Task LimitSteamRequestsAsync() {
+			await SteamSemaphore.WaitAsync().ConfigureAwait(false);
+			await Utilities.SleepAsync(5 * 1000).ConfigureAwait(false); // We must add some delay to not get caught by Steam anty-DoS
+			SteamSemaphore.Release();
+		}
+
+		internal static string GetUserInput(string botLogin, EUserInputType userInputType) {
 			string result;
 			lock (ConsoleLock) {
-				if (twoFactorAuthentication) {
+				switch (userInputType) {
-					Console.Write("<" + botLogin + "> Please enter your 2 factor auth code from your authenticator app: ");
+					case EUserInputType.Login:
-				} else {
+						Console.Write("<" + botLogin + "> Please enter your login: ");
-					Console.Write("<" + botLogin + "> Please enter the auth code sent to your email : ");
+						break;
+					case EUserInputType.Password:
+						Console.Write("<" + botLogin + "> Please enter your password: ");
+						break;
+					case EUserInputType.SteamGuard:
+						Console.Write("<" + botLogin + "> Please enter the auth code sent to your email: ");
+						break;
+					case EUserInputType.SteamParentalPIN:
+						Console.Write("<" + botLogin + "> Please enter steam parental PIN: ");
+						break;
+					case EUserInputType.TwoFactorAuthentication:
+						Console.Write("<" + botLogin + "> Please enter your 2 factor auth code from your authenticator app: ");
+						break;
 				}
 				result = Console.ReadLine();
+				Console.Clear(); // For security purposes
 			}
+			result = result.Trim(); // Get rid of all whitespace characters
 			return result;
 		}
 
-		private static void ShutdownAllBots() {
+		internal static async void OnBotShutdown(Bot bot) {
-			lock (Bots) {
+			if (Bot.GetRunningBotsCount() == 0) {
-				foreach (Bot bot in Bots) {
+				Logging.LogGenericInfo("Main", "No bots are running, exiting");
-					bot.Stop();
+				await Utilities.SleepAsync(5000).ConfigureAwait(false); // This might be the only message user gets, consider giving him some time
-				}
+				ShutdownResetEvent.Set();
-				Bots.Clear();
 			}
 		}
 
 		private static void Main(string[] args) {
-			// Config directory may not be in the same directory as the .exe, check maximum of 3 levels lower
+			Logging.LogGenericInfo("Main", "Archi's Steam Farm, version " + Version);
-			for (var i = 0; i < 4 && !Directory.Exists(ConfigDirectoryPath); i++) {
+
-				Directory.SetCurrentDirectory("..");
+			Task.Run(async () => await CheckForUpdate().ConfigureAwait(false)).Wait();
+
+			// Allow loading configs from source tree if it's a debug build
+			if (Debugging.IsDebugBuild) {
+				for (var i = 0; i < 4; i++) {
+					Directory.SetCurrentDirectory("..");
+					if (Directory.Exists(ConfigDirectoryPath)) {
+						break;
+					}
+				}
 			}
 
 			if (!Directory.Exists(ConfigDirectoryPath)) {
 				Logging.LogGenericError("Main", "Config directory doesn't exist!");
 				Console.ReadLine();
-				Exit(1);
+				Task.Run(async () => await Exit(1).ConfigureAwait(false)).Wait();
 			}
 
-			lock (Bots) {
+			foreach (var configFile in Directory.EnumerateFiles(ConfigDirectoryPath, "*.xml")) {
-				foreach (var configFile in Directory.EnumerateFiles(ConfigDirectoryPath, "*.xml")) {
+				string botName = Path.GetFileNameWithoutExtension(configFile);
-					string botName = Path.GetFileNameWithoutExtension(configFile);
+				Bot bot = new Bot(botName);
-					Bots.Add(new Bot(botName));
+				if (!bot.Enabled) {
+					Logging.LogGenericInfo(botName, "Not starting this instance because it's disabled in config file");
 				}
 			}
 
-			Thread.Sleep(Timeout.Infinite);
+			// Check if we got any bots running
+			OnBotShutdown(null);
+
+			ShutdownResetEvent.WaitOne();
 		}
 	}
 }

ArchiSteamFarm/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyVersion("0.6.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("0.6.0.0")]

ArchiSteamFarm/SteamTradeOffer.cs

@@ -55,9 +55,14 @@ namespace ArchiSteamFarm {
 		internal bool from_real_time_trade { get; set; }
 
 		// Extra
+		private ulong _OtherSteamID64 = 0;
 		internal ulong OtherSteamID64 {
 			get {
-				return new SteamID((uint) accountid_other, EUniverse.Public, EAccountType.Individual).ConvertToUInt64();
+				if (_OtherSteamID64 == 0 && accountid_other != 0) {
+					_OtherSteamID64 = new SteamID((uint) accountid_other, EUniverse.Public, EAccountType.Individual).ConvertToUInt64();
+				}
+
+				return _OtherSteamID64;
 			}
 		}
 	}

ArchiSteamFarm/Trading.cs

@@ -28,42 +28,40 @@ using System.Threading.Tasks;
 
 namespace ArchiSteamFarm {
 	internal sealed class Trading {
-		private Bot Bot;
+		private readonly Bot Bot;
+		private readonly SemaphoreSlim Semaphore = new SemaphoreSlim(1);
 		private volatile byte ParsingTasks = 0;
-		private SemaphoreSlim semaphore = new SemaphoreSlim(1);
 
 		internal Trading(Bot bot) {
 			Bot = bot;
 		}
 
-		internal void CheckTrades() {
+		internal async void CheckTrades() {
-			Logging.LogGenericDebug("");
 			if (ParsingTasks < 2) {
 				ParsingTasks++;
-				Task.Run(() => ParseActiveTrades());
+
+				await Semaphore.WaitAsync().ConfigureAwait(false);
+				await ParseActiveTrades().ConfigureAwait(false);
+				Semaphore.Release();
+
+				ParsingTasks--;
 			}
 		}
 
 		private async Task ParseActiveTrades() {
-			await semaphore.WaitAsync().ConfigureAwait(false);
-
 			List<SteamTradeOffer> tradeOffers = Bot.ArchiWebHandler.GetTradeOffers();
-			if (tradeOffers != null) {
+			if (tradeOffers == null) {
-				List<Task> tasks = new List<Task>();
+				return;
-				foreach (SteamTradeOffer tradeOffer in tradeOffers) {
-					if (tradeOffer.trade_offer_state == SteamTradeOffer.ETradeOfferState.Active) {
-						Task task = Task.Run(async () => {
-							await ParseTrade(tradeOffer).ConfigureAwait(false);
-						});
-						tasks.Add(task);
-					}
-				}
-
-				await Task.WhenAll(tasks).ConfigureAwait(false);
 			}
 
-			ParsingTasks--;
+			List<Task> tasks = new List<Task>();
-			semaphore.Release();
+			foreach (SteamTradeOffer tradeOffer in tradeOffers) {
+				if (tradeOffer.trade_offer_state == SteamTradeOffer.ETradeOfferState.Active) {
+					tasks.Add(Task.Run(async () => await ParseTrade(tradeOffer).ConfigureAwait(false)));
+				}
+			}
+
+			await Task.WhenAll(tasks).ConfigureAwait(false);
 		}
 
 		private async Task ParseTrade(SteamTradeOffer tradeOffer) {
@@ -76,21 +74,17 @@ namespace ArchiSteamFarm {
 				return;
 			}
 
-			ulong steamID = tradeOffer.OtherSteamID64;
+			ulong otherSteamID = tradeOffer.OtherSteamID64;
 			bool success = false;
 			bool tradeAccepted = false;
 
-			if (tradeOffer.items_to_give.Count == 0 || steamID == Bot.SteamMasterID) {
+			if (tradeOffer.items_to_give.Count == 0 || otherSteamID == Bot.SteamMasterID) {
 				tradeAccepted = true;
 				success = await Bot.ArchiWebHandler.AcceptTradeOffer(tradeID).ConfigureAwait(false);
 			} else {
 				success = Bot.ArchiWebHandler.DeclineTradeOffer(tradeID);
 			}
 
-			if (!success) {
-				Logging.LogGenericWarning(Bot.BotName, "Response <accept: " + tradeAccepted + "> to trade " + tradeID + " failed!");
-			}
-
 			if (tradeAccepted && success) {
 				// Do whatever we want with success
 			}

ArchiSteamFarm/Utilities.cs

@@ -23,6 +23,7 @@
 */
 
 using HtmlAgilityPack;
+using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
 using System.Globalization;
@@ -34,6 +35,12 @@ using System.Threading.Tasks;
 
 namespace ArchiSteamFarm {
 	internal static class Utilities {
+		private static readonly Random Random = new Random();
+
+		internal static async Task SleepAsync(int miliseconds) {
+			await Task.Delay(miliseconds).ConfigureAwait(false);
+		}
+
 		internal static ulong OnlyNumbers(string inputString) {
 			if (string.IsNullOrEmpty(inputString)) {
 				return 0;
@@ -48,89 +55,162 @@ namespace ArchiSteamFarm {
 				return 0;
 			}
 
-			ulong result = ulong.Parse(resultString, CultureInfo.InvariantCulture);
+			return ulong.Parse(resultString, CultureInfo.InvariantCulture);
-			return result;
 		}
 
 		internal static async Task<HttpResponseMessage> UrlToHttpResponse(string websiteAddress, Dictionary<string, string> cookieVariables = null) {
+			if (string.IsNullOrEmpty(websiteAddress)) {
+				return null;
+			}
+
 			HttpResponseMessage result = null;
-			if (!string.IsNullOrEmpty(websiteAddress)) {
+
-				try {
+			try {
-					using (HttpClientHandler clientHandler = new HttpClientHandler { UseCookies = false }) {
+				using (HttpClientHandler clientHandler = new HttpClientHandler { UseCookies = false }) {
-						using (HttpClient client = new HttpClient(clientHandler)) {
+					using (HttpClient client = new HttpClient(clientHandler)) {
-							client.Timeout = TimeSpan.FromSeconds(10);
+						client.Timeout = TimeSpan.FromSeconds(10);
-							HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, websiteAddress);
+						client.DefaultRequestHeaders.UserAgent.ParseAdd("ArchiSteamFarm/1.0");
-							if (cookieVariables != null) {
+						HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, websiteAddress);
-								StringBuilder cookie = new StringBuilder();
+						if (cookieVariables != null) {
-								foreach (KeyValuePair<string, string> cookieVariable in cookieVariables) {
+							StringBuilder cookie = new StringBuilder();
-									cookie.Append(cookieVariable.Key + "=" + cookieVariable.Value + ";");
+							foreach (KeyValuePair<string, string> cookieVariable in cookieVariables) {
-								}
+								cookie.Append(cookieVariable.Key + "=" + cookieVariable.Value + ";");
-								requestMessage.Headers.Add("Cookie", cookie.ToString());
-							}
-							HttpResponseMessage responseMessage = await client.SendAsync(requestMessage).ConfigureAwait(false);
-							if (responseMessage != null) {
-								responseMessage.EnsureSuccessStatusCode();
-								result = responseMessage;
 							}
+							requestMessage.Headers.Add("Cookie", cookie.ToString());
+						}
+						HttpResponseMessage responseMessage = await client.SendAsync(requestMessage).ConfigureAwait(false);
+						if (responseMessage != null) {
+							responseMessage.EnsureSuccessStatusCode();
+							result = responseMessage;
 						}
 					}
-				} catch {
 				}
+			} catch (Exception e) {
+				Logging.LogGenericException("Utilities", e);
 			}
+
 			return result;
 		}
 
-		internal static async Task<HttpResponseMessage> UrlToHttpResponse(string websiteAddress) {
-			return await UrlToHttpResponse(websiteAddress, null).ConfigureAwait(false);
-		}
-
 		internal static async Task<HtmlDocument> UrlToHtmlDocument(string websiteAddress, Dictionary<string, string> cookieVariables = null) {
-			HtmlDocument result = null;
+			if (string.IsNullOrEmpty(websiteAddress)) {
-			if (!string.IsNullOrEmpty(websiteAddress)) {
+				return null;
-				try {
-					HttpResponseMessage responseMessage = await UrlToHttpResponse(websiteAddress, cookieVariables).ConfigureAwait(false);
-					if (responseMessage != null) {
-						string source = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
-						if (!string.IsNullOrEmpty(source)) {
-							source = WebUtility.HtmlDecode(source);
-							result = new HtmlDocument();
-							result.LoadHtml(source);
-						}
-					}
-				} catch {
-				}
 			}
+
+			HtmlDocument result = null;
+
+			try {
+				HttpResponseMessage responseMessage = await UrlToHttpResponse(websiteAddress, cookieVariables).ConfigureAwait(false);
+				if (responseMessage != null) {
+					string source = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
+					if (!string.IsNullOrEmpty(source)) {
+						source = WebUtility.HtmlDecode(source);
+						result = new HtmlDocument();
+						result.LoadHtml(source);
+					}
+				}
+			} catch (Exception e) {
+				Logging.LogGenericException("Utilities", e);
+			}
+
 			return result;
 		}
 
 		internal static async Task<bool> UrlPostRequest(string request, Dictionary<string, string> postData, Dictionary<string, string> cookieVariables = null, string referer = null) {
+			if (string.IsNullOrEmpty(request) || postData == null) {
+				return false;
+			}
+
 			bool result = false;
-			if (!string.IsNullOrEmpty(request)) {
+
-				try {
+			try {
-					using (HttpClientHandler clientHandler = new HttpClientHandler { UseCookies = false }) {
+				using (HttpClientHandler clientHandler = new HttpClientHandler { UseCookies = false }) {
-						using (HttpClient client = new HttpClient(clientHandler)) {
+					using (HttpClient client = new HttpClient(clientHandler)) {
-							client.Timeout = TimeSpan.FromSeconds(15);
+						client.Timeout = TimeSpan.FromSeconds(10);
-							HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Post, request);
+						client.DefaultRequestHeaders.UserAgent.ParseAdd("ArchiSteamFarm/1.0");
-							requestMessage.Content = new FormUrlEncodedContent(postData);
+						HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Post, request);
-							if (cookieVariables != null && cookieVariables.Count > 0) {
+						requestMessage.Content = new FormUrlEncodedContent(postData);
-								StringBuilder cookie = new StringBuilder();
+						if (cookieVariables != null && cookieVariables.Count > 0) {
-								foreach (KeyValuePair<string, string> cookieVariable in cookieVariables) {
+							StringBuilder cookie = new StringBuilder();
-									cookie.Append(cookieVariable.Key + "=" + cookieVariable.Value + ";");
+							foreach (KeyValuePair<string, string> cookieVariable in cookieVariables) {
-								}
+								cookie.Append(cookieVariable.Key + "=" + cookieVariable.Value + ";");
-								requestMessage.Headers.Add("Cookie", cookie.ToString());
-							}
-							if (referer != null) {
-								requestMessage.Headers.Referrer = new Uri(referer);
-							}
-							HttpResponseMessage responseMessage = await client.SendAsync(requestMessage).ConfigureAwait(false);
-							if (responseMessage != null) {
-								result = responseMessage.IsSuccessStatusCode;
 							}
+							requestMessage.Headers.Add("Cookie", cookie.ToString());
+						}
+						if (referer != null) {
+							requestMessage.Headers.Referrer = new Uri(referer);
+						}
+						HttpResponseMessage responseMessage = await client.SendAsync(requestMessage).ConfigureAwait(false);
+						if (responseMessage != null) {
+							result = responseMessage.IsSuccessStatusCode;
 						}
 					}
-				} catch {
 				}
+			} catch (Exception e) {
+				Logging.LogGenericException("Utilities", e);
 			}
+
+			return result;
+		}
+
+		internal static async Task<HttpResponseMessage> UrlPostRequestWithResponse(string request, Dictionary<string, string> postData, Dictionary<string, string> cookieVariables = null, string referer = null) {
+			if (string.IsNullOrEmpty(request) || postData == null) {
+				return null;
+			}
+
+			HttpResponseMessage result = null;
+
+			try {
+				using (HttpClientHandler clientHandler = new HttpClientHandler { UseCookies = false }) {
+					using (HttpClient client = new HttpClient(clientHandler)) {
+						client.Timeout = TimeSpan.FromSeconds(10);
+						client.DefaultRequestHeaders.UserAgent.ParseAdd("ArchiSteamFarm/1.0");
+						HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Post, request);
+						requestMessage.Content = new FormUrlEncodedContent(postData);
+						if (cookieVariables != null && cookieVariables.Count > 0) {
+							StringBuilder cookie = new StringBuilder();
+							foreach (KeyValuePair<string, string> cookieVariable in cookieVariables) {
+								cookie.Append(cookieVariable.Key + "=" + cookieVariable.Value + ";");
+							}
+							requestMessage.Headers.Add("Cookie", cookie.ToString());
+						}
+						if (referer != null) {
+							requestMessage.Headers.Referrer = new Uri(referer);
+						}
+						HttpResponseMessage responseMessage = await client.SendAsync(requestMessage).ConfigureAwait(false);
+						if (responseMessage != null) {
+							result = responseMessage;
+						}
+					}
+				}
+			} catch (Exception e) {
+				Logging.LogGenericException("Utilities", e);
+			}
+
+			return result;
+		}
+
+		internal static async Task<JObject> UrlToJObject(string request) {
+			if (string.IsNullOrEmpty(request)) {
+				return null;
+			}
+
+			HttpResponseMessage httpResponseMessage = await UrlToHttpResponse(request, null).ConfigureAwait(false);
+			if (httpResponseMessage == null) {
+				return null;
+			}
+
+			string source = await httpResponseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
+			if (string.IsNullOrEmpty(source)) {
+				return null;
+			}
+
+			JObject result = null;
+			try {
+				result = JObject.Parse(source);
+			} catch {
+			}
+
 			return result;
 		}
 	}

ArchiSteamFarm/config/example.xml

@@ -1,27 +1,62 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8" ?>
 <configuration>
 
-<!-- Every bot should have it's own unique .xml configuration file, this is example on which you can base on -->
+	<!-- Every bot should have it's own unique .xml configuration file, this is example on which you can base on -->
 
- <!-- Master switch to turn account on and off, set to "true" after you're done -->
+	<!-- Notice, if you use special characters reserved for XML, you should escape them -->
-<Enabled type="bool" value="false"/>
+	<!-- Escape table: [& - &amp;] | [" - &quot;] | [' - &apos;] | [< - &lt;] | [> - &gt;] -->
+	<!-- So e.g. if your SteamPassword is "foo&" you should write value="foo&amp;" -->
 
-<!-- This is your steam login, the one you use for logging in to steam -->
+	<!-- Master switch to turn account on and off, set to "true" after you're done -->
-<SteamLogin type="string" value="Foo"/>
+	<!-- TIP: This bot instance won't run unless below switch is set to "true" -->
+	<Enabled type="bool" value="false"/>
 
-<!-- This is your steam password, the one you use for logging in to steam -->
+	<!-- This is your steam login, the one you use for logging in to steam -->
-<SteamPassword type="string" value="Bar"/>
+	<!-- TIP: You can use "null" if you wish to enter login on every startup -->
+	<SteamLogin type="string" value="null"/>
 
-<!-- This is steam nickname, the one you want to use for bot. Can be anything up to 32 characters -->
+	<!-- This is your steam password, the one you use for logging in to steam -->
-<SteamNickname type="string" value="null"/>
+	<!-- TIP: You can use "null" if you wish to enter password on every startup -->
+	<SteamPassword type="string" value="null"/>
 
-<!-- Get one at https://steamcommunity.com/dev/apikey while logged in as bot, domain doesn't matter. You can also use "null", but that will disable many API functions, e.g. trading -->
+	<!-- This is steam nickname, the one you want to use for bot. Can be anything up to 32 characters -->
-<SteamApiKey type="string" value="null"/>
+	<!-- TIP: You can use "null" if you wish to preserve your actual nickname -->
+	<SteamNickname type="string" value="null"/>
 
-<!-- This is steamID of the bot-master - you, in steamID64 format -->
+	<!-- This is your bot's API key, get one at https://steamcommunity.com/dev/apikey while logged in as bot, domain doesn't matter -->
-<SteamMasterID type="ulong" value="76561198006963719"/>
+	<!-- TIP: You can use "null", but it will disable all API-based functionalities such as trading -->
+	<SteamApiKey type="string" value="null"/>
 
-<!-- If you want from the bot to join particular chat of given clan, set it here, otherwise leave at 0 -->
+	<!-- This is your parental PIN if you use steam parental functionality -->
-<SteamMasterClanID type="ulong" value="0"/>
+	<!-- TIP: Most likely you don't want to change it. You can use "null" if you wish to enter PIN on every startup, 0 means there is no PIN -->
+	<SteamParentalPIN type="string" value="0"/>
+
+	<!-- This is steamID64 of the bot-master - you, [Example: 76561198006963719] -->
+	<!-- TIP: You can use "0", but bot won't accept steam cd-keys or trades from anybody" -->
+	<SteamMasterID type="ulong" value="0"/>
+
+	<!-- This defines clan of the master, bot will join chatroom of that clan automatically after logging in if set -->
+	<!-- SteamMasterClanID could be found by visiting your group-page  -->
+	<!-- [Example: http://steamcommunity.com/groups/hellokitty/] -->
+	<!-- Adding "memberslistxml/?xml=1" to the end of this url so it looks like -->
+	<!-- [Example: http://steamcommunity.com/groups/hellokitty/memberslistxml/?xml=1] -->
+	<!-- Finally replace the SteamMasterClanID value with groupID64 you got from your groups xml-file -->
+	<!-- TIP: Most likely you don't want to change it -->
+	<SteamMasterClanID type="ulong" value="0"/>
+
+	<!-- This switch defines if bot should disconnect once farming is finished -->
+	<!-- When no bots are active, ASF will shutdown as well -->
+	<!-- Some people may want to keep their bots 24/7, other disconnect them after job is done -->
+	<!-- Choose yourself what you prefer -->
+	<ShutdownOnFarmingFinished type="bool" value="false"/>
+
+	<!-- Comma-separated list of IDs that should not be considered for farming -->
+	<!-- TIP: Most likely you don't want to change it -->
+	<Blacklist type="HashSet(uint)" value="303700,335590,368020"/>
+
+	<!-- This enables statistics for me - bot will join Archi's SC Farm group and chat -->
+	<!-- Consider leaving it at "true", this way I can check how many running bots are active -->
+	<!-- TIP: Group link is http://steamcommunity.com/groups/ascfarm -->
+	<Statistics type="bool" value="true"/>
 
 </configuration>

ArchiSteamFarm/packages.config

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-	<package id="HtmlAgilityPack" version="1.4.9" targetFramework="net45" />
+  <package id="HtmlAgilityPack" version="1.4.9" targetFramework="net45" />
-	<package id="protobuf-net" version="2.0.0.668" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="8.0.1-beta1" targetFramework="net45" />
-	<package id="SteamKit2" version="1.6.5" targetFramework="net45" />
+  <package id="protobuf-net" version="2.0.0.668" targetFramework="net45" />
+  <package id="SteamKit2" version="1.6.5" targetFramework="net45" />
 </packages>

README.md

@@ -1,26 +1,39 @@
-# ArchiSteamFarm
+ArchiSteamFarm
+===================
 
-Big work-in-progress
+Big work-in-progress. This bot allows you to farm steam cards using multiple accounts simultaneously. Each account is defined by it's own XML config in `config` directory and you don´t need any steam-client running in the background.
 
-Allows you to farm steam cards using multiple accounts simultaneously.
+**Current functions:**
 
-Each account is defined by it's own XML config in "config" directory.
+ - Automatically farm steam cards using any number of active accounts
+ - Automatically accept friend requests sent from master
+ - Automatically accept all trades coming from master
+ - Automatically accept all steam cd-keys sent via chat from master
+ - SteamGuard / 2-factor-authentication support
+ - Full Mono support, tested on Debian "9.0" Stretch (testing)
 
-Current functions:
+**Current Commands:**
-- Does not need Steam client running, or even a GUI. Fully based on SteamKit2 and reverse-engineered Steam protocol.
-- Automatically farm steam cards using any number of active accounts
-- Automatically accept friend requests sent from master
-- Automatically accept all trades coming from master
-- Automatically accept all steam cd-keys sent via chat from master
-- SteamGuard / 2-factor-authentication support
-- Full Mono support, tested on Debian "9.0" Stretch (testing)
 
-TODO:
+ - `!farm` Restarts the bot and starts card-farming (again)
-- Smart multi-games farming till every game reaches 2 hours, then one-by-one (similar to Idle Master) - Backend code is already here, just missing the logic and tests.
+ - `!exit` Stops the bot
-- Possible integration with SteamTradeMatcher, bot can detect dupes and trade them automatically. Again, backend code is already here, just missing actual implementation.
+
-- Automatic sending of steam trades to master, after game is fully farmed.
+> You can use chat-commands in group-chat or private-chat with your bot.
+> The MasterID has to be set for this specific bot / config-file.
+
+**Supported / Tested Operating-Systems:**
+
+ - Windows 10 Enterprise Edition
+ - Debian 9.0 Stretch (Mono)
+ - Debian 8.1 Jessie (Mono)
+
+**TODO**:
+
+- Smart Multi-Game-Farming
+- Possible integration with SteamTradeMatcher, bot can detect dupes and trade them automatically. Backend-code is already here, just missing actual implementation.
+- Automatic sending of steamtrades to master(after game is fully farmed)
 - Probably much more
 
-This is big WIP, so feel free to send pull requests if you wish.
 
-I'll release some releases later, when everything is tested and code cleaned up.
+> This is big WIP, so feel free to send pull requests if you wish. I'll
+> release some releases later, when everything is tested and code
+> cleaned up.

packages/Newtonsoft.Json.8.0.1-beta1/tools/install.ps1

@@ -0,0 +1,116 @@
+param($installPath, $toolsPath, $package, $project)
+
+# open json.net splash page on package install
+# don't open if json.net is installed as a dependency
+
+try
+{
+  $url = "http://www.newtonsoft.com/json/install?version=" + $package.Version
+  $dte2 = Get-Interface $dte ([EnvDTE80.DTE2])
+
+  if ($dte2.ActiveWindow.Caption -eq "Package Manager Console")
+  {
+    # user is installing from VS NuGet console
+    # get reference to the window, the console host and the input history
+    # show webpage if "install-package newtonsoft.json" was last input
+
+    $consoleWindow = $(Get-VSComponentModel).GetService([NuGetConsole.IPowerConsoleWindow])
+
+    $props = $consoleWindow.GetType().GetProperties([System.Reflection.BindingFlags]::Instance -bor `
+      [System.Reflection.BindingFlags]::NonPublic)
+
+    $prop = $props | ? { $_.Name -eq "ActiveHostInfo" } | select -first 1
+    if ($prop -eq $null) { return }
+  
+    $hostInfo = $prop.GetValue($consoleWindow)
+    if ($hostInfo -eq $null) { return }
+
+    $history = $hostInfo.WpfConsole.InputHistory.History
+
+    $lastCommand = $history | select -last 1
+
+    if ($lastCommand)
+    {
+      $lastCommand = $lastCommand.Trim().ToLower()
+      if ($lastCommand.StartsWith("install-package") -and $lastCommand.Contains("newtonsoft.json"))
+      {
+        $dte2.ItemOperations.Navigate($url) | Out-Null
+      }
+    }
+  }
+  else
+  {
+    # user is installing from VS NuGet dialog
+    # get reference to the window, then smart output console provider
+    # show webpage if messages in buffered console contains "installing...newtonsoft.json" in last operation
+
+    $instanceField = [NuGet.Dialog.PackageManagerWindow].GetField("CurrentInstance", [System.Reflection.BindingFlags]::Static -bor `
+      [System.Reflection.BindingFlags]::NonPublic)
+
+    $consoleField = [NuGet.Dialog.PackageManagerWindow].GetField("_smartOutputConsoleProvider", [System.Reflection.BindingFlags]::Instance -bor `
+      [System.Reflection.BindingFlags]::NonPublic)
+
+    if ($instanceField -eq $null -or $consoleField -eq $null) { return }
+
+    $instance = $instanceField.GetValue($null)
+
+    if ($instance -eq $null) { return }
+
+    $consoleProvider = $consoleField.GetValue($instance)
+    if ($consoleProvider -eq $null) { return }
+
+    $console = $consoleProvider.CreateOutputConsole($false)
+
+    $messagesField = $console.GetType().GetField("_messages", [System.Reflection.BindingFlags]::Instance -bor `
+      [System.Reflection.BindingFlags]::NonPublic)
+    if ($messagesField -eq $null) { return }
+
+    $messages = $messagesField.GetValue($console)
+    if ($messages -eq $null) { return }
+
+    $operations = $messages -split "=============================="
+
+    $lastOperation = $operations | select -last 1
+
+    if ($lastOperation)
+    {
+      $lastOperation = $lastOperation.ToLower()
+
+      $lines = $lastOperation -split "`r`n"
+
+      $installMatch = $lines | ? { $_.StartsWith("------- installing...newtonsoft.json ") } | select -first 1
+
+      if ($installMatch)
+      {
+        $dte2.ItemOperations.Navigate($url) | Out-Null
+      }
+    }
+  }
+}
+catch
+{
+  try
+  {
+    $pmPane = $dte2.ToolWindows.OutputWindow.OutputWindowPanes.Item("Package Manager")
+
+    $selection = $pmPane.TextDocument.Selection
+    $selection.StartOfDocument($false)
+    $selection.EndOfDocument($true)
+
+    if ($selection.Text.StartsWith("Attempting to gather dependencies information for package 'Newtonsoft.Json." + $package.Version + "'"))
+    {
+      # don't show on upgrade
+      if (!$selection.Text.Contains("Removed package"))
+      {
+        $dte2.ItemOperations.Navigate($url) | Out-Null
+      }
+    }
+  }
+  catch
+  {
+    # stop potential errors from bubbling up
+    # worst case the splash page won't open  
+  }
+}
+
+# still yolo