/// <summary> /// Logs onto the Steam network as a persistent game server. /// The client should already have been connected at this point. /// Results are return in a <see cref="SteamUser.LoggedOnCallback"/>. /// </summary> /// <param name="details">The details to use for logging on.</param> /// <exception cref="ArgumentNullException">No logon details were provided.</exception> /// <exception cref="ArgumentException">Username or password are not set within <paramref name="details"/>.</exception> public void LogOn(LogOnDetails details) { if (details == null) { throw new ArgumentNullException("details"); } if (string.IsNullOrEmpty(details.Username) || string.IsNullOrEmpty(details.Password)) { throw new ArgumentException("LogOn requires a username and password to be set in 'details'."); } var logon = new ClientMsgProtobuf <CMsgClientLogon>(EMsg.ClientLogon); SteamID gsId = new SteamID(0, 0, Client.ConnectedUniverse, EAccountType.GameServer); logon.ProtoHeader.client_sessionid = 0; logon.ProtoHeader.steamid = gsId.ConvertToUInt64(); uint localIp = NetHelpers.GetIPAddress(this.Client.LocalIP); logon.Body.obfustucated_private_ip = localIp ^ MsgClientLogon.ObfuscationMask; logon.Body.protocol_version = MsgClientLogon.CurrentProtocol; logon.Body.client_os_type = ( uint )Utils.GetOSType(); logon.Body.game_server_app_id = ( int )details.AppID; logon.Body.machine_id = Utils.GenerateMachineID(); logon.Body.account_name = details.Username; logon.Body.password = details.Password; this.Client.Send(logon); }
/// <summary> /// Invites a user to a chat room. /// The results of this action will be available through the <see cref="ChatActionResultCallback"/> callback. /// </summary> /// <param name="steamIdUser">The SteamID of the user to invite.</param> /// <param name="steamIdChat">The SteamID of the chat room to invite the user to.</param> public void InviteUserToChat(SteamID steamIdUser, SteamID steamIdChat) { if (steamIdUser == null) { throw new ArgumentNullException(nameof(steamIdUser)); } if (steamIdChat == null) { throw new ArgumentNullException(nameof(steamIdChat)); } SteamID chatId = steamIdChat.ConvertToUInt64(); // copy the steamid so we don't modify it if (chatId.IsClanAccount) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = (uint)SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } var inviteMsg = new ClientMsgProtobuf <CMsgClientChatInvite>(EMsg.ClientChatInvite); inviteMsg.Body.steam_id_chat = chatId; inviteMsg.Body.steam_id_invited = steamIdUser; // steamclient also sends the steamid of the user that did the invitation // we'll mimic that behavior inviteMsg.Body.steam_id_patron = Client.SteamID ?? new SteamID(); this.Client.Send(inviteMsg); }
/// <summary> /// Logs onto the Steam network as a persistent game server. /// The client should already have been connected at this point. /// Results are return in a <see cref="SteamUser.LoggedOnCallback"/>. /// </summary> /// <param name="details">The details to use for logging on.</param> /// <exception cref="System.ArgumentNullException">No logon details were provided.</exception> /// <exception cref="System.ArgumentException">Username or password are not set within <paramref name="details"/>.</exception> public void LogOn( LogOnDetails details ) { if ( details == null ) { throw new ArgumentNullException( "details" ); } if ( string.IsNullOrEmpty( details.Username ) || string.IsNullOrEmpty( details.Password ) ) { throw new ArgumentException( "LogOn requires a username and password to be set in 'details'." ); } var logon = new ClientMsgProtobuf<CMsgClientLogon>( EMsg.ClientLogon ); SteamID gsId = new SteamID( 0, 0, Client.ConnectedUniverse, EAccountType.GameServer ); logon.ProtoHeader.client_sessionid = 0; logon.ProtoHeader.steamid = gsId.ConvertToUInt64(); uint localIp = NetHelpers.GetIPAddress( this.Client.LocalIP ); logon.Body.obfustucated_private_ip = localIp ^ MsgClientLogon.ObfuscationMask; logon.Body.protocol_version = MsgClientLogon.CurrentProtocol; logon.Body.client_os_type = ( uint )Utils.GetOSType(); logon.Body.game_server_app_id = ( int )details.AppID; logon.Body.machine_id = Utils.GenerateMachineID(); logon.Body.account_name = details.Username; logon.Body.password = details.Password; this.Client.Send( logon ); }
/// <summary> /// Logs the client into the Steam3 network as an anonymous user. /// The client should already have been connected at this point. /// Results are returned in a <see cref="LoggedOnCallback"/>. /// </summary> /// <param name="details">The details to use for logging on.</param> public void LogOnAnonymous(AnonymousLogOnDetails details) { if (details == null) { throw new ArgumentNullException(nameof(details)); } if (!this.Client.IsConnected) { this.Client.PostCallback(new LoggedOnCallback(EResult.NoConnection)); return; } var logon = new ClientMsgProtobuf <CMsgClientLogon>(EMsg.ClientLogon); SteamID auId = new SteamID(0, 0, Client.Universe, EAccountType.AnonUser); logon.ProtoHeader.client_sessionid = 0; logon.ProtoHeader.steamid = auId.ConvertToUInt64(); logon.Body.protocol_version = MsgClientLogon.CurrentProtocol; logon.Body.client_os_type = ( uint )details.ClientOSType; logon.Body.client_language = details.ClientLanguage; logon.Body.cell_id = details.CellID ?? Client.Configuration.CellID; logon.Body.machine_id = HardwareUtils.GetMachineID(Client.Configuration.MachineInfoProvider); this.Client.Send(logon); }
/// <summary> /// Sends a load theirs inventory request. /// </summary> public void LoadForeignInventory(SteamID backpackId, int appid, int contextid) { var service = string.Format(TradeURLAction, "foreigninventory"); var webRequest = CreateSteamRequest(service, LoginData); var fields = new NameValueCollection(); fields.Add("sessionid", LoginData.SessionId); fields.Add("steamid", backpackId.ConvertToUInt64().ToString()); fields.Add("appid", appid.ToString()); fields.Add("contextid", contextid.ToString()); var query = fields.ConstructQueryString(); var queryData = Encoding.ASCII.GetBytes(query); webRequest.ContentType = "application/x-www-form-urlencoded"; webRequest.ContentLength = queryData.Length; // Write the request using (Stream stream = webRequest.GetRequestStream()) { stream.Write(queryData, 0, queryData.Length); } // Perform the request var res = webRequest.BeginGetResponse( new AsyncCallback(ProcessForeignInventory), webRequest); }
/// <summary> /// Attempts to leave a chat room. /// </summary> /// <param name="steamId">The SteamID of the chat room.</param> public void LeaveChat(SteamID steamId) { if (steamId == null) { throw new ArgumentNullException(nameof(steamId)); } SteamID chatId = steamId.ConvertToUInt64(); // copy the steamid so we don't modify it var leaveChat = new ClientMsg <MsgClientChatMemberInfo>(); if (chatId.IsClanAccount) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = ( uint )SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } leaveChat.Body.SteamIdChat = chatId; leaveChat.Body.Type = EChatInfoType.StateChange; var localSteamID = Client.SteamID?.ConvertToUInt64() ?? default; // SteamID can be null if not connected - will be ultimately ignored in Client.Send. leaveChat.Write(localSteamID); // ChatterActedOn leaveChat.Write(( uint )EChatMemberStateChange.Left); // StateChange leaveChat.Write(localSteamID); // ChatterActedBy Client.Send(leaveChat); }
/// <summary> /// Sends a message to a chat room. /// </summary> /// <param name="steamIdChat">The SteamID of the chat room.</param> /// <param name="type">The message type.</param> /// <param name="message">The message.</param> public void SendChatRoomMessage(SteamID steamIdChat, EChatEntryType type, string message) { if (steamIdChat == null) { throw new ArgumentNullException(nameof(steamIdChat)); } if (message == null) { throw new ArgumentNullException(nameof(message)); } SteamID chatId = steamIdChat.ConvertToUInt64(); // copy the steamid so we don't modify it if (chatId.IsClanAccount) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = ( uint )SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } var chatMsg = new ClientMsg <MsgClientChatMsg>(); chatMsg.Body.ChatMsgType = type; chatMsg.Body.SteamIdChatRoom = chatId; chatMsg.Body.SteamIdChatter = Client.SteamID ?? new SteamID(); // Can be null if not connected - will ultimately be ignored in Client.Send. chatMsg.WriteNullTermString(message, Encoding.UTF8); this.Client.Send(chatMsg); }
/// <summary> /// Unbans the specified SteamID from the given chat room. /// </summary> /// <param name="steamIdChat">The SteamID of chat room to unban the member from.</param> /// <param name="steamIdMember">The SteamID of the member to unban from the chat.</param> public void UnbanChatMember(SteamID steamIdChat, SteamID steamIdMember) { if (steamIdChat == null) { throw new ArgumentNullException(nameof(steamIdChat)); } if (steamIdMember == null) { throw new ArgumentNullException(nameof(steamIdMember)); } SteamID chatId = steamIdChat.ConvertToUInt64(); // copy the steamid so we don't modify it var unbanMember = new ClientMsg <MsgClientChatAction>(); if (chatId.IsClanAccount) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = ( uint )SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } unbanMember.Body.SteamIdChat = chatId; unbanMember.Body.SteamIdUserToActOn = steamIdMember; unbanMember.Body.ChatAction = EChatAction.UnBan; this.Client.Send(unbanMember); }
/// <summary> /// Logs the client into the Steam3 network as an anonymous game server. /// The client should already have been connected at this point. /// Results are returned in a <see cref="SteamUser.LoggedOnCallback"/>. /// </summary> /// <param name="appId">The AppID served by this game server, or 0 for the default.</param> public void LogOnAnonymous(uint appId = 0) { if (!this.Client.IsConnected) { this.Client.PostCallback(new SteamUser.LoggedOnCallback(EResult.NoConnection)); return; } var logon = new ClientMsgProtobuf <CMsgClientLogon>(EMsg.ClientLogon); SteamID gsId = new SteamID(0, 0, Client.ConnectedUniverse, EAccountType.AnonGameServer); logon.ProtoHeader.client_sessionid = 0; logon.ProtoHeader.steamid = gsId.ConvertToUInt64(); uint localIp = NetHelpers.GetIPAddress(this.Client.LocalIP); logon.Body.obfustucated_private_ip = localIp ^ MsgClientLogon.ObfuscationMask; logon.Body.protocol_version = MsgClientLogon.CurrentProtocol; logon.Body.client_os_type = ( uint )Utils.GetOSType(); logon.Body.game_server_app_id = ( int )appId; logon.Body.machine_id = HardwareUtils.GetMachineID(); this.Client.Send(logon); }
public GenericInventory(SteamID steamId, SteamID botId, bool inTrade = false) { ConstructTask = Task.Factory.StartNew(() => { this.UserId = steamId; this.BotId = botId; string baseInventoryUrl = "http://steamcommunity.com/profiles/" + steamId.ConvertToUInt64() + "/inventory/"; string response = RetryWebRequest(baseInventoryUrl, botId); Regex reg = new Regex("var g_rgAppContextData = (.*?);"); Match m = reg.Match(response); if (m.Success) { try { string json = m.Groups[1].Value; var schemaResult = JsonConvert.DeserializeObject<Dictionary<int, InventoryApps>>(json); foreach (var app in schemaResult) { int appId = app.Key; InventoryTasks[appId] = new Dictionary<long, Task>(); foreach (var contextId in app.Value.RgContexts.Keys) { InventoryTasks[appId][contextId] = Task.Factory.StartNew(() => { string inventoryUrl = string.Format("http://steamcommunity.com/profiles/{0}/inventory/json/{1}/{2}/", steamId.ConvertToUInt64(), appId, contextId); var inventory = FetchInventory(inventoryUrl, steamId, botId, appId, contextId); if (!inventories.ContainsKey(appId)) inventories[appId] = new Dictionary<long, Inventory>(); if (inventory != null && !inventories[appId].ContainsKey(contextId)) inventories[appId].Add(contextId, inventory); }); } } } catch (Exception ex) { Success = false; Console.WriteLine(ex); } } else { Success = false; IsPrivate = true; } }); }
/// <summary> /// Logs the client into the Steam3 network. /// The client should already have been connected at this point. /// Results are returned in a <see cref="LoggedOnCallback"/>. /// </summary> /// <param name="details">The details to use for logging on.</param> /// <exception cref="ArgumentNullException">No logon details were provided.</exception> /// <exception cref="ArgumentException">Username or password are not set within <paramref name="details"/>.</exception> public void LogOn(LogOnDetails details) { if (details == null) { throw new ArgumentNullException("details"); } if (string.IsNullOrEmpty(details.Username) || string.IsNullOrEmpty(details.Password)) { throw new ArgumentException("LogOn requires a username and password to be set in 'details'."); } if (!this.Client.IsConnected) { this.Client.PostCallback(new LoggedOnCallback(EResult.NoConnection)); return; } var logon = new ClientMsgProtobuf <CMsgClientLogon>(EMsg.ClientLogon); SteamID steamId = new SteamID(details.AccountID, details.AccountInstance, Client.ConnectedUniverse, EAccountType.Individual); uint localIp = NetHelpers.GetIPAddress(this.Client.LocalIP); logon.ProtoHeader.client_sessionid = 0; logon.ProtoHeader.steamid = steamId.ConvertToUInt64(); logon.Body.obfustucated_private_ip = localIp ^ MsgClientLogon.ObfuscationMask; logon.Body.account_name = details.Username; logon.Body.password = details.Password; logon.Body.protocol_version = MsgClientLogon.CurrentProtocol; logon.Body.client_os_type = ( uint )Utils.GetOSType(); logon.Body.client_language = "english"; logon.Body.steam2_ticket_request = details.RequestSteam2Ticket; // we're now using the latest steamclient package version, this is required to get a proper sentry file for steam guard logon.Body.client_package_version = 1771; // todo: determine if this is still required // this is not a proper machine id that Steam accepts // but it's good enough for identifying a machine logon.Body.machine_id = Utils.GenerateMachineID(); // steam guard logon.Body.auth_code = details.AuthCode; logon.Body.two_factor_code = details.TwoFactorCode; logon.Body.sha_sentryfile = details.SentryFileHash; logon.Body.eresult_sentryfile = ( int )(details.SentryFileHash != null ? EResult.OK : EResult.FileNotFound); this.Client.Send(logon); }
public static SteamID ChatFromClan(SteamID clanId) { if (!clanId.IsClanAccount) throw new ArgumentException("clanId is not a clan account"); SteamID chatId = clanId.ConvertToUInt64(); chatId.AccountInstance = (uint)SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; return chatId; }
public static SteamID ClanFromChat(SteamID chatId) { if (!chatId.IsChatAccount) throw new ArgumentException("chatId is not a chat account"); SteamID clanId = chatId.ConvertToUInt64(); clanId.AccountInstance = 0; clanId.AccountType = EAccountType.Clan; return clanId; }
public static void OpenProfile( SteamID steamId ) { string friendUrl = string.Format( "http://www.steamcommunity.com/profiles/{0}", steamId.ConvertToUInt64() ); if ( Util.IsMono() ) { Process.Start( string.Format( "xdg-open {0:s}", friendUrl ) ); } else { Process.Start( friendUrl ); } }
/// <summary> /// Gets the inventory for the given Steam ID using the Steam Community website. /// </summary> /// <returns>The inventory for the given user. </returns> /// <param name='steamid'>The Steam identifier. </param> public static dynamic GetInventory(SteamID steamid) { string url = String.Format ( "http://steamcommunity.com/profiles/{0}/inventory/json/440/2/?trading=1", steamid.ConvertToUInt64 () ); try { string response = SteamWeb.Fetch (url, "GET", null, null, true); return JsonConvert.DeserializeObject (response); } catch (Exception) { return JsonConvert.DeserializeObject ("{\"success\":\"false\"}"); } }
/// <summary> /// Attempts to join a chat room. /// </summary> /// <param name="steamId">The SteamID of the chat room.</param> public void JoinChat(SteamID steamId) { SteamID chatId = steamId.ConvertToUInt64(); // copy the steamid so we don't modify it var joinChat = new ClientMsg <MsgClientJoinChat>(); if (chatId.IsClanAccount) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = ( uint )SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } joinChat.Body.SteamIdChat = chatId; Client.Send(joinChat); }
public void LongConstructorAndSetterGetterValid() { SteamID sid = new SteamID( 103582791432294076 ); Assert.Equal( 2772668u, sid.AccountID ); Assert.Equal( SteamID.AllInstances, sid.AccountInstance ); Assert.Equal( EUniverse.Public, sid.AccountUniverse ); Assert.Equal( EAccountType.Clan, sid.AccountType ); sid.SetFromUInt64( 157626004137848889 ); Assert.Equal( 12345u, sid.AccountID ); Assert.Equal( SteamID.WebInstance, sid.AccountInstance ); Assert.Equal( EUniverse.Beta, sid.AccountUniverse ); Assert.Equal( EAccountType.GameServer, sid.AccountType ); Assert.Equal( 157626004137848889ul, sid.ConvertToUInt64() ); }
/// <summary> /// Logs the client into the Steam3 network as an anonymous user. /// The client should already have been connected at this point. /// Results are returned in a <see cref="LoggedOnCallback"/>. /// </summary> public void LogOnAnonymous() { var logon = new ClientMsgProtobuf <CMsgClientLogon>(EMsg.ClientLogon); SteamID auId = new SteamID(0, 0, Client.ConnectedUniverse, EAccountType.AnonUser); logon.ProtoHeader.client_sessionid = 0; logon.ProtoHeader.steamid = auId.ConvertToUInt64(); logon.Body.protocol_version = MsgClientLogon.CurrentProtocol; logon.Body.client_os_type = ( uint )Utils.GetOSType(); // this is not a proper machine id that Steam accepts // but it's good enough for identifying a machine logon.Body.machine_id = Utils.GenerateMachineID(); this.Client.Send(logon); }
/// <summary> /// Attempts to join a chat room. /// </summary> /// <param name="steamId">The SteamID of the chat room.</param> public void JoinChat(SteamID steamId) { if (steamId == null) { throw new ArgumentNullException(nameof(steamId)); } SteamID chatId = steamId.ConvertToUInt64(); // copy the steamid so we don't modify it var joinChat = new ClientMsg <MsgClientJoinChat>(); if (chatId.IsClanAccount) { chatId = chatId.ToChatID(); } joinChat.Body.SteamIdChat = chatId; Client.Send(joinChat); }
public static bool isBotAdmin(SteamID steamid) { try { if(steamid.ConvertToUInt64() == Convert.ToUInt64(File.ReadAllText("admin.txt"))) { return true; } steamFriends.SendChatMessage(steamid, EChatEntryType.ChatMsg, "You Are Not A Bot Admin..."); Console.WriteLine(steamFriends.GetFriendPersonaName(steamid) + " are attempted to use as admin while not an admin!"); return false; } catch(Exception e) { Console.WriteLine(e.Message); return false; } }
/// <summary> /// Bans the specified chat member from the given chat room. /// </summary> /// <param name="steamIdChat">The SteamID of chat room to ban the member from.</param> /// <param name="steamIdMember">The SteamID of the member to ban from the chat.</param> public void BanChatMember( SteamID steamIdChat, SteamID steamIdMember ) { SteamID chatId = steamIdChat.ConvertToUInt64(); // copy the steamid so we don't modify it var banMember = new ClientMsg<MsgClientChatAction>(); if ( chatId.IsClanAccount ) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = ( uint )SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } banMember.Body.SteamIdChat = chatId; banMember.Body.SteamIdUserToActOn = steamIdMember; banMember.Body.ChatAction = EChatAction.Ban; this.Client.Send( banMember ); }
/// <summary> /// Bans the specified chat member from the given chat room. /// </summary> /// <param name="steamIdChat">The SteamID of chat room to ban the member from.</param> /// <param name="steamIdMember">The SteamID of the member to ban from the chat.</param> public void BanChatMember(SteamID steamIdChat, SteamID steamIdMember) { SteamID chatId = steamIdChat.ConvertToUInt64(); // copy the steamid so we don't modify it var banMember = new ClientMsg <MsgClientChatAction>(); if (chatId.IsClanAccount) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = ( uint )SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } banMember.Body.SteamIdChat = chatId; banMember.Body.SteamIdUserToActOn = steamIdMember; banMember.Body.ChatAction = EChatAction.Ban; this.Client.Send(banMember); }
/// <summary> /// Sends a message to a chat room. /// </summary> /// <param name="steamIdChat">The SteamID of the chat room.</param> /// <param name="type">The message type.</param> /// <param name="message">The message.</param> public void SendChatRoomMessage(SteamID steamIdChat, EChatEntryType type, string message) { SteamID chatId = steamIdChat.ConvertToUInt64(); // copy the steamid so we don't modify it if (chatId.IsClanAccount) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = ( uint )SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } var chatMsg = new ClientMsg <MsgClientChatMsg>(); chatMsg.Body.ChatMsgType = type; chatMsg.Body.SteamIdChatRoom = chatId; chatMsg.Body.SteamIdChatter = Client.SteamID; chatMsg.WriteNullTermString(message, Encoding.UTF8); this.Client.Send(chatMsg); }
/// <summary> /// Attempts to leave a chat room. /// </summary> /// <param name="steamId">The SteamID of the chat room.</param> public void LeaveChat(SteamID steamId) { SteamID chatId = steamId.ConvertToUInt64(); // copy the steamid so we don't modify it var leaveChat = new ClientMsg <MsgClientChatMemberInfo>(); if (chatId.IsClanAccount) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = ( uint )SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } leaveChat.Body.SteamIdChat = chatId; leaveChat.Body.Type = EChatInfoType.StateChange; leaveChat.Write(Client.SteamID.ConvertToUInt64()); // ChatterActedOn leaveChat.Write(( uint )EChatMemberStateChange.Left); // StateChange leaveChat.Write(Client.SteamID.ConvertToUInt64()); // ChatterActedBy Client.Send(leaveChat); }
public static ImmutableArray<byte> CreateServerTicket( SteamID id, ImmutableArray<byte> auth, byte[] ownershipTicket) { long size = 8 + // steam ID auth.Length + 4 + // length of ticket ownershipTicket.Length; MemoryStream stream = new MemoryStream(); using (var writer = new BinaryWriter(stream)) { writer.Write((ushort) size); writer.Write(id.ConvertToUInt64()); writer.Write(auth.ToArray()); writer.Write(ownershipTicket.Length); writer.Write(ownershipTicket); writer.Write(0); } return stream.ToArray().ToImmutableArray(); }
/// <summary> /// Initializes a trade session. /// </summary> public void Initialize() { if (LoginData.SessionId.Length == 0) { throw new Exception("Invalid Steam web session id cookie"); } // Clean up the session id. LoginData.SessionId = Uri.UnescapeDataString(LoginData.SessionId); TradeURL = string.Format(STEAM_TRADE_URL, OtherSteamId.ConvertToUInt64()); TradeURLAction = TradeURL + "/{0}/"; var webRequest = CreateSteamRequest(TradeURL, LoginData, "GET"); // Perform the request var res = webRequest.BeginGetResponse( new AsyncCallback(ProcessInitial), webRequest); StatusTimer = new Timer(new TimerCallback(HandleStatusTimer), null, Timeout.Infinite, Timeout.Infinite); }
/// <summary> /// Logs onto the Steam network as a persistent game server. /// The client should already have been connected at this point. /// Results are return in a <see cref="SteamUser.LoggedOnCallback"/>. /// </summary> /// <param name="details">The details to use for logging on.</param> /// <exception cref="System.ArgumentNullException">No logon details were provided.</exception> /// <exception cref="System.ArgumentException">Username or password are not set within <paramref name="details"/>.</exception> public void LogOn(LogOnDetails details) { if (details == null) { throw new ArgumentNullException("details"); } if (string.IsNullOrEmpty(details.Token)) { throw new ArgumentException("LogOn requires a game server token to be set in 'details'."); } if (!this.Client.IsConnected) { this.Client.PostCallback(new SteamUser.LoggedOnCallback(EResult.NoConnection)); return; } var logon = new ClientMsgProtobuf <CMsgClientLogon>(EMsg.ClientLogonGameServer); SteamID gsId = new SteamID(0, 0, Client.Universe, EAccountType.GameServer); logon.ProtoHeader.client_sessionid = 0; logon.ProtoHeader.steamid = gsId.ConvertToUInt64(); uint localIp = NetHelpers.GetIPAddress(this.Client.LocalIP); logon.Body.obfustucated_private_ip = localIp ^ MsgClientLogon.ObfuscationMask; logon.Body.protocol_version = MsgClientLogon.CurrentProtocol; logon.Body.client_os_type = ( uint )Utils.GetOSType(); logon.Body.game_server_app_id = ( int )details.AppID; logon.Body.machine_id = HardwareUtils.GetMachineID(); logon.Body.game_server_token = details.Token; this.Client.Send(logon); }
/// <summary> /// Logs the client into the Steam3 network as an anonymous user. /// The client should already have been connected at this point. /// Results are returned in a <see cref="LoggedOnCallback"/>. /// </summary> /// <param name="details">The details to use for logging on.</param> public void LogOnAnonymous(AnonymousLogOnDetails details) { if (!this.Client.IsConnected) { this.Client.PostCallback(new LoggedOnCallback(EResult.NoConnection)); return; } var logon = new ClientMsgProtobuf <CMsgClientLogon>(EMsg.ClientLogon); SteamID auId = new SteamID(0, 0, Client.ConnectedUniverse, EAccountType.AnonUser); logon.ProtoHeader.client_sessionid = 0; logon.ProtoHeader.steamid = auId.ConvertToUInt64(); logon.Body.protocol_version = MsgClientLogon.CurrentProtocol; logon.Body.client_os_type = ( uint )details.ClientOSType; logon.Body.client_language = details.ClientLanguage; logon.Body.cell_id = details.CellID; logon.Body.machine_id = MachineIdUtils.GenerateMachineID(); this.Client.Send(logon); }
/// <summary> /// Attempts to join a chat room. /// </summary> /// <param name="steamId">The SteamID of the chat room.</param> public void JoinChat( SteamID steamId ) { SteamID chatId = steamId.ConvertToUInt64(); // copy the steamid so we don't modify it var joinChat = new ClientMsg<MsgClientJoinChat>(); if ( chatId.IsClanAccount ) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = ( uint )SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } joinChat.Body.SteamIdChat = chatId; Client.Send( joinChat ); }
private dynamic getInventory (SteamID steamid) { var request = CreateSteamRequest(String.Format("http://steamcommunity.com/profiles/{0}/inventory/json/440/2/?trading=1",steamid.ConvertToUInt64()),"GET"); HttpWebResponse resp = request.GetResponse() as HttpWebResponse; Stream str = resp.GetResponseStream(); StreamReader reader = new StreamReader(str); string res = reader.ReadToEnd(); dynamic json = JsonConvert.DeserializeObject(res); return json; }
public void initTrade (SteamID me, SteamID other, CookieCollection cookies) { //Cleanup again cleanTrade(); //Setup meSID = me; otherSID = other; version = 1; logpos = 0; WebCookies = cookies; sessionid = cookies[0].Value; baseTradeURL = String.Format (STEAM_TRADE_URL, otherSID.ConvertToUInt64 ()); this.WebCookies = cookies; printConsole ("[TradeSystem] Init Trade with " + otherSID, ConsoleColor.DarkGreen); try { //poll? poll. poll (); } catch (Exception) { printConsole ("[TradeSystem][ERROR] Failed to connect to Steam!", ConsoleColor.Red); //Send a message on steam MainClass.steamFriends.SendChatMessage(otherSID,EChatEntryType.ChatMsg,"Sorry, There was a problem connecting to Steam Trading. Try again in a few minutes."); cleanTrade(); } printConsole ("[TradeSystem] Getting Player Inventories...", ConsoleColor.Yellow); int good = 0; OtherItems = getInventory (otherSID); if (OtherItems.success=="true") { printConsole ("[TradeSystem] Got Other player's inventory!", ConsoleColor.Green); good++; } else { } MyItems = getInventory (meSID); if (MyItems.success=="true") { printConsole ("[TradeSystem] Got the bot's inventory!", ConsoleColor.Green); good++; } if (good == 2) { printConsole ("[TradeSystem] All is a go! Starting to Poll!", ConsoleColor.Green); //Timer pollTimer = new System.Threading.Timer (TimerCallback, null, 0, 1000); //Send MOTD sendChat ("Welcome to SteamBot!"); } else { printConsole ("[TradeSystem][ERROR] status was not good! ABORT ABORT ABORT!", ConsoleColor.Red); //Poll once to send an error message poll (); //send error sendChat("SteamBot has an error! Please try trading the bot again in a few minutes. This is Steam's fault NOT mine."); //Poll again so they can read it poll (); } /* * How to Loop through the inventory: foreach(var child in OtherItems.rgInventory.Children()) { Console.WriteLine("Item ID: {0}", child.First.id); } */ }
/// <summary> /// Logs the client into the Steam3 network as an anonymous user. /// The client should already have been connected at this point. /// Results are returned in a <see cref="LoggedOnCallback"/>. /// </summary> /// <param name="details">The details to use for logging on.</param> public void LogOnAnonymous( AnonymousLogOnDetails details ) { if ( !this.Client.IsConnected ) { this.Client.PostCallback( new LoggedOnCallback( EResult.NoConnection ) ); return; } var logon = new ClientMsgProtobuf<CMsgClientLogon>( EMsg.ClientLogon ); SteamID auId = new SteamID( 0, 0, Client.ConnectedUniverse, EAccountType.AnonUser ); logon.ProtoHeader.client_sessionid = 0; logon.ProtoHeader.steamid = auId.ConvertToUInt64(); logon.Body.protocol_version = MsgClientLogon.CurrentProtocol; logon.Body.client_os_type = ( uint )details.ClientOSType; logon.Body.client_language = details.ClientLanguage; logon.Body.cell_id = details.CellID; logon.Body.machine_id = HardwareUtils.GetMachineID(); this.Client.Send( logon ); }
public static string GetCalculatorURL(SteamID steamID) { return new Uri(Settings.Current.BaseURL, string.Format("/calculator/?player={0}", steamID.ConvertToUInt64())).AbsoluteUri; }
/// <summary> /// Invites a user to a chat room. /// The results of this action will be available through the <see cref="ChatActionResultCallback"/> callback. /// </summary> /// <param name="steamIdUser">The SteamID of the user to invite.</param> /// <param name="steamIdChat">The SteamID of the chat room to invite the user to.</param> public void InviteUserToChat( SteamID steamIdUser, SteamID steamIdChat ) { SteamID chatId = steamIdChat.ConvertToUInt64(); // copy the steamid so we don't modify it if ( chatId.IsClanAccount ) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = (uint)SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } var inviteMsg = new ClientMsgProtobuf<CMsgClientChatInvite>( EMsg.ClientChatInvite ); inviteMsg.Body.steam_id_chat = chatId; inviteMsg.Body.steam_id_invited = steamIdUser; // steamclient also sends the steamid of the user that did the invitation // we'll mimic that behavior inviteMsg.Body.steam_id_patron = Client.SteamID; this.Client.Send( inviteMsg ); }
/// <summary> /// Fetchs the inventories of both the bot and the other user as well as the TF2 item schema. /// </summary> /// <param name='me'> /// The <see cref="SteamID"/> of the bot. /// </param> /// <param name='other'> /// The <see cref="SteamID"/> of the other trade partner. /// </param> /// <remarks> /// This should be done anytime a new user is traded with or the inventories are out of date. It should /// be done sometime before calling <see cref="CreateTrade"/>. /// </remarks> public void InitializeTrade(SteamID me, SteamID other) { // fetch other player's inventory from the Steam API. otherInventoryTask = Task.Factory.StartNew(() => Inventory.FetchInventory(other.ConvertToUInt64(), ApiKey, SteamWeb)); //if (OtherInventory == null) //{ // throw new InventoryFetchException (other); //} // fetch our inventory from the Steam API. myInventoryTask = Task.Factory.StartNew(() => Inventory.FetchInventory(me.ConvertToUInt64(), ApiKey, SteamWeb)); // check that the schema was already successfully fetched if (Trade.CurrentSchema == null) Trade.CurrentSchema = Schema.FetchSchema (ApiKey); if (Trade.CurrentSchema == null) throw new TradeException ("Could not download the latest item schema."); }
/// <summary> /// Accepts the invite to a Steam Group /// </summary> /// <param name="group">SteamID of the group to accept the invite from.</param> private void AcceptGroupInvite(SteamID group) { var acceptMsg = new ClientMsg<CMsgGroupInviteAction>((int)EMsg.ClientAcknowledgeClanInvite); acceptMsg.Body.GroupID = group.ConvertToUInt64(); acceptMsg.Body.AcceptInvite = true; SteamClient.Send(acceptMsg); Log.Success("Accepted group invite to {0}.", group.ToString()); }
/// <summary> /// Connects this instance to the server. /// </summary> /// <returns><c>true</c> if the connection was a success; otherwise, <c>false</c>.</returns> public bool Connect() { byte[] encryptedKey = null; // TODO: handle other universes? byte[] universeKey = KeyDictionary.GetPublicKey(EUniverse.Public); using (var rsa = new RSACrypto(universeKey)) { encryptedKey = rsa.Encrypt(sessionKey); } string payload; if (appTicket == null) { payload = String.Format("sessionkey={0}&anonymoususer=1&steamid={1}", WebHelpers.UrlEncode(encryptedKey), steamID.ConvertToUInt64()); } else { byte[] encryptedTicket = CryptoHelper.SymmetricEncrypt(appTicket, sessionKey); payload = String.Format("sessionkey={0}&appticket={1}", WebHelpers.UrlEncode(encryptedKey), WebHelpers.UrlEncode(encryptedTicket)); } webClient.Headers.Clear(); webClient.Headers.Add("Content-Type", "application/x-www-form-urlencoded"); string response; try { response = webClient.UploadString(BuildCommand(endPoint, "initsession"), payload); } catch (WebException e) { LogWebException("Connect", e); return(false); } var responsekv = KeyValue.LoadFromString(response); var sessionidn = responsekv.Children.Where(c => c.Name == "sessionid").First(); var reqcountern = responsekv.Children.Where(c => c.Name == "req-counter").First(); sessionID = (ulong)(sessionidn.AsLong(0)); reqcounter = reqcountern.AsLong(0); try { AuthDepot(); } catch (WebException e) { LogWebException("AuthDepot", e); return(false); } return(true); }
/// <summary> /// Accepts the invite to a Steam Group /// </summary> /// <param name="group">SteamID of the group to accept the invite from.</param> private void AcceptGroupInvite(SteamID group) { var AcceptInvite = new ClientMsg<CMsgGroupInviteAction>((int)EMsg.ClientAcknowledgeClanInvite); AcceptInvite.Body.GroupID = group.ConvertToUInt64(); AcceptInvite.Body.AcceptInvite = true; this.SteamClient.Send(AcceptInvite); }
/// <summary> /// Declines the invite to a Steam Group /// </summary> /// <param name="group">SteamID of the group to decline the invite from.</param> private void DeclineGroupInvite(SteamID group) { var DeclineInvite = new ClientMsg<CMsgGroupInviteAction>((int)EMsg.ClientAcknowledgeClanInvite); DeclineInvite.Body.GroupID = group.ConvertToUInt64(); DeclineInvite.Body.AcceptInvite = false; this.SteamClient.Send(DeclineInvite); }
/// <summary> /// Invites a use to the specified Steam Group /// </summary> /// <param name="user">SteamID of the user to invite.</param> /// <param name="groupId">SteamID of the group to invite the user to.</param> public void InviteUserToGroup(SteamID user, SteamID groupId) { var InviteUser = new ClientMsg<CMsgInviteUserToGroup>((int)EMsg.ClientInviteUserToClan); InviteUser.Body.GroupID = groupId.ConvertToUInt64(); InviteUser.Body.Invitee = user.ConvertToUInt64(); InviteUser.Body.UnknownInfo = true; this.SteamClient.Send(InviteUser); }
bool HandleTradeSessionStart(SteamID other) { if (CurrentTrade != null) return false; try { tradeManager.InitializeTrade(SteamUser.SteamID, other); CurrentTrade = tradeManager.StartTrade (SteamUser.SteamID, other); } catch (SteamTrade.Exceptions.InventoryFetchException ie) { // we shouldn't get here because the inv checks are also // done in the TradeProposedCallback handler. string response = String.Empty; if (ie.FailingSteamId.ConvertToUInt64() == other.ConvertToUInt64()) { response = "Trade failed. Could not correctly fetch your backpack. Either the inventory is inaccessible or your backpack is private."; } else { response = "Trade failed. Could not correctly fetch my backpack."; } SteamFriends.SendChatMessage(other, EChatEntryType.ChatMsg, response); log.Info ("Bot sent other: " + response); CurrentTrade = null; return false; } CurrentTrade.OnClose += CloseTrade; SubscribeTrade (CurrentTrade, GetUserHandler (other)); return true; }
UserHandler GetUserHandler(SteamID sid) { if (!userHandlers.ContainsKey (sid)) { userHandlers [sid.ConvertToUInt64 ()] = CreateHandler (this, sid); } return userHandlers [sid.ConvertToUInt64 ()]; }
/// <summary> /// Attempts to leave a chat room. /// </summary> /// <param name="steamId">The SteamID of the chat room.</param> public void LeaveChat( SteamID steamId ) { SteamID chatId = steamId.ConvertToUInt64(); // copy the steamid so we don't modify it var leaveChat = new ClientMsg<MsgClientChatMemberInfo>(); if ( chatId.IsClanAccount ) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = ( uint )SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } leaveChat.Body.SteamIdChat = chatId; leaveChat.Body.Type = EChatInfoType.StateChange; leaveChat.Write( Client.SteamID.ConvertToUInt64() ); // ChatterActedOn leaveChat.Write( ( uint )EChatMemberStateChange.Left ); // StateChange leaveChat.Write( Client.SteamID.ConvertToUInt64() ); // ChatterActedBy Client.Send( leaveChat ); }
private bool Respond(SteamID toID, SteamID userID, string message, bool room) { bool messageSent = false; CheckIfDBExists(userID); Dictionary<ulong, DB> db = Options.NotificationOptions.DB; db[userID].userID = userID.ConvertToUInt64(); db[userID].seen = DateTime.Now; db[userID].name = Bot.steamFriends.GetFriendPersonaName(userID); string[] query = StripCommand(message, Options.NotificationOptions.SeenCommand); if (query != null && query.Length == 2) { if (!db.ContainsKey(Convert.ToUInt64(query[1])) || db[Convert.ToUInt64(query[1])] == null) { SendMessageAfterDelay(toID, "The user " + query[1] + " was not found.", room); messageSent = true; } else { SendMessageAfterDelay(toID, string.Format("I last saw {0} on {1} at {2}", db[Convert.ToUInt64(query[1])].name, db[Convert.ToUInt64(query[1])].seen.ToShortDateString(), db[Convert.ToUInt64(query[1])].seen.ToShortTimeString()), room); messageSent = true; } } query = StripCommand(message, Options.NotificationOptions.APICommand); if(query != null && userID != toID) { SendMessageAfterDelay(toID, "This command will only work in private to protect privacy.", room); messageSent = true; } else if(query != null && query.Length == 2 && userID == toID) { CheckIfDBExists(userID); string api = query[1]; db[userID.ConvertToUInt64()].pb.apikey = api; PushbulletClient client = new PushbulletClient(api); PushNoteRequest note = new PushNoteRequest() { Title = "Test note", Body = "This is a test. If you receive this then you have successfully registered an API key with the bot." }; PushResponse response = client.PushNote(note); if(response == null) { SendMessageAfterDelay(toID, "Your push failed. Most likely your API key is incorrect.", room); messageSent = true; } else { SendMessageAfterDelay(toID, "Your push was a success.", room); messageSent = true; } } query = StripCommand(message, Options.NotificationOptions.FilterCommand); if(query != null && query.Length == 1) { SendMessageAfterDelay(toID, "Available sub commands: add, list, clear, delete", room); messageSent = true; } else if(query != null && query.Length >= 2) { if(query[1] == "add" && query.Length >= 3) { List<string> words = new List<string>(); words = db[userID].pb.filter; // !filter add banshee test 1 2 3 for (int i = 2; i < query.Length; i++) { words.Add(query[i]); } db[userID].pb.filter = words; SendMessageAfterDelay(toID, "Your filter has been successfully modified.", room); messageSent = true; } else if(query[1] == "list" && query.Length == 2) { if (db[userID].pb.filter.Count > 0) { string words = string.Join(", ", db[userID].pb.filter); SendMessageAfterDelay(userID, "Your filter: " + words, false); messageSent = true; } else { SendMessageAfterDelay(userID, "Your filter is empty. Use \"!filter add <words>\" to add to your filter", false); messageSent = true; } } else if(query[1] == "clear" && query.Length == 2) { db[userID].pb.filter.Clear(); SendMessageAfterDelay(toID, "Your filter has been cleared", room); messageSent = true; } else if(query[1] == "delete" && query.Length == 3) { db[userID].pb.filter.Remove(query[2]); SendMessageAfterDelay(toID, "The filter \"" + query[2] + "\" has been removed", room); messageSent = true; } } query = StripCommand(message, Options.NotificationOptions.ClearCommand); if(query != null) { db[userID] = null; SendMessageAfterDelay(toID, "Your database file has been cleared.", room); messageSent = true; } foreach (DB d in db.Values) { if (d == null || d.pb == null || d.pb.filter == null || d.pb.filter.Count == 0) { return false; } foreach (string word in d.pb.filter) { if (message.ToLower().Contains(word.ToLower()) && userID.ConvertToUInt64() != d.userID) { if (d.pb.apikey != null && d.pb.apikey != "") { PushbulletClient client = new PushbulletClient(d.pb.apikey); PushNoteRequest note = new PushNoteRequest(); note.Title = string.Format("Steam message from {0}/{1} in {2}", db[userID.ConvertToUInt64()].name, userID.ConvertToUInt64(), toID.ConvertToUInt64()); note.Body = message; client.PushNote(note); Log.Instance.Verbose("{0}/{1}: Sending pushbullet for {2}/{3}", Bot.username, Name, db[d.userID].name, db[d.userID].userID); return true; } } } } return messageSent; }
/// <summary> /// Sends a message to a chat room. /// </summary> /// <param name="steamIdChat">The SteamID of the chat room.</param> /// <param name="type">The message type.</param> /// <param name="message">The message.</param> public void SendChatRoomMessage( SteamID steamIdChat, EChatEntryType type, string message ) { SteamID chatId = steamIdChat.ConvertToUInt64(); // copy the steamid so we don't modify it if ( chatId.IsClanAccount ) { // this steamid is incorrect, so we'll fix it up chatId.AccountInstance = ( uint )SteamID.ChatInstanceFlags.Clan; chatId.AccountType = EAccountType.Chat; } var chatMsg = new ClientMsg<MsgClientChatMsg>(); chatMsg.Body.ChatMsgType = type; chatMsg.Body.SteamIdChatRoom = chatId; chatMsg.Body.SteamIdChatter = Client.SteamID; chatMsg.WriteNullTermString( message, Encoding.UTF8 ); this.Client.Send( chatMsg ); }
/// <summary> /// Logs the client into the Steam3 network. /// The client should already have been connected at this point. /// Results are returned in a <see cref="LoggedOnCallback"/>. /// </summary> /// <param name="details">The details to use for logging on.</param> /// <exception cref="ArgumentNullException">No logon details were provided.</exception> /// <exception cref="ArgumentException">Username or password are not set within <paramref name="details"/>.</exception> public void LogOn( LogOnDetails details ) { if ( details == null ) { throw new ArgumentNullException( "details" ); } if ( string.IsNullOrEmpty( details.Username ) || ( string.IsNullOrEmpty( details.Password ) && string.IsNullOrEmpty( details.LoginKey ) ) ) { throw new ArgumentException( "LogOn requires a username and password to be set in 'details'." ); } if ( !string.IsNullOrEmpty( details.LoginKey ) && !details.ShouldRememberPassword ) { // Prevent consumers from screwing this up. // If should_remember_password is false, the login_key is ignored server-side. // The inverse is not applicable (you can log in with should_remember_password and no login_key). throw new ArgumentException( "ShouldRememberPassword is required to be set to true in order to use LoginKey." ); } if ( !this.Client.IsConnected ) { this.Client.PostCallback( new LoggedOnCallback( EResult.NoConnection ) ); return; } var logon = new ClientMsgProtobuf<CMsgClientLogon>( EMsg.ClientLogon ); SteamID steamId = new SteamID( details.AccountID, details.AccountInstance, Client.ConnectedUniverse, EAccountType.Individual ); if ( details.LoginID.HasValue ) { logon.Body.obfustucated_private_ip = details.LoginID.Value; } else { uint localIp = NetHelpers.GetIPAddress( this.Client.LocalIP ); logon.Body.obfustucated_private_ip = localIp ^ MsgClientLogon.ObfuscationMask; } logon.ProtoHeader.client_sessionid = 0; logon.ProtoHeader.steamid = steamId.ConvertToUInt64(); logon.Body.account_name = details.Username; logon.Body.password = details.Password; logon.Body.should_remember_password = details.ShouldRememberPassword; logon.Body.protocol_version = MsgClientLogon.CurrentProtocol; logon.Body.client_os_type = ( uint )details.ClientOSType; logon.Body.client_language = details.ClientLanguage; logon.Body.cell_id = details.CellID; logon.Body.steam2_ticket_request = details.RequestSteam2Ticket; // we're now using the latest steamclient package version, this is required to get a proper sentry file for steam guard logon.Body.client_package_version = 1771; // todo: determine if this is still required logon.Body.machine_id = HardwareUtils.GetMachineID(); // steam guard logon.Body.auth_code = details.AuthCode; logon.Body.two_factor_code = details.TwoFactorCode; logon.Body.login_key = details.LoginKey; logon.Body.sha_sentryfile = details.SentryFileHash; logon.Body.eresult_sentryfile = ( int )( details.SentryFileHash != null ? EResult.OK : EResult.FileNotFound ); this.Client.Send( logon ); }
public bool load(ulong appid,List<uint> types, SteamID steamid) { dynamic invResponse; Item tmpItemData; ItemDescription tmpDescription; loaded = false; try { for (int i = 0; i < types.Count; i++) { string response = SteamWeb.Fetch(string.Format("http://steamcommunity.com/profiles/{0}/inventory/json/{1}/{2}/?trading=1", steamid.ConvertToUInt64(),appid, types[i]), "GET", null, null, true); invResponse = JsonConvert.DeserializeObject(response); if (invResponse.success == false) { errors.Add("Fail to open backpack: " + invResponse.Error); return false; } //rgInventory = Items on Steam Inventory foreach (var item in invResponse.rgInventory) { foreach (var itemId in item) { tmpItemData = new Item(); tmpItemData.id = itemId.id; tmpItemData.classid = itemId.classid; items.Add((ulong)itemId.id, tmpItemData); break; } } // rgDescriptions = Item Schema (sort of) foreach (var description in invResponse.rgDescriptions) { foreach (var classid_instanceid in description)// classid + '_' + instenceid { tmpDescription = new ItemDescription(); tmpDescription.name = classid_instanceid.name; tmpDescription.type = classid_instanceid.type; tmpDescription.marketable = (bool) classid_instanceid.marketable; tmpDescription.tradable = (bool) classid_instanceid.marketable; tmpDescription.metadata = classid_instanceid.descriptions; descriptions.Add((ulong)classid_instanceid.classid, tmpDescription); break; } } }//end for (inventory type) }//end try catch (Exception e) { Console.WriteLine(e.Message); errors.Add("Exception: " + e.Message); return false; } loaded = true; return true; }
/// <summary> /// Declines the invite to a Steam Group /// </summary> /// <param name="group">SteamID of the group to decline the invite from.</param> private void DeclineGroupInvite(SteamID group) { var declineMsg = new ClientMsg<CMsgGroupInviteAction>((int)EMsg.ClientAcknowledgeClanInvite); declineMsg.Body.GroupID = group.ConvertToUInt64(); declineMsg.Body.AcceptInvite = false; SteamClient.Send(declineMsg); Log.Info("Declined group invite to {0}.", group.ToString()); }
/// <summary> /// Logs the client into the Steam3 network. /// The client should already have been connected at this point. /// Results are returned in a <see cref="LoggedOnCallback"/>. /// </summary> /// <param name="details">The details to use for logging on.</param> /// <exception cref="ArgumentNullException">No logon details were provided.</exception> /// <exception cref="ArgumentException">Username or password are not set within <paramref name="details"/>.</exception> public void LogOn(LogOnDetails details) { if (details == null) { throw new ArgumentNullException("details"); } if (string.IsNullOrEmpty(details.Username) || (string.IsNullOrEmpty(details.Password) && string.IsNullOrEmpty(details.LoginKey))) { throw new ArgumentException("LogOn requires a username and password to be set in 'details'."); } if (!string.IsNullOrEmpty(details.LoginKey) && !details.ShouldRememberPassword) { // Prevent consumers from screwing this up. // If should_remember_password is false, the login_key is ignored server-side. // The inverse is not applicable (you can log in with should_remember_password and no login_key). throw new ArgumentException("ShouldRememberPassword is required to be set to true in order to use LoginKey."); } if (!this.Client.IsConnected) { this.Client.PostCallback(new LoggedOnCallback(EResult.NoConnection)); return; } var logon = new ClientMsgProtobuf <CMsgClientLogon>(EMsg.ClientLogon); SteamID steamId = new SteamID(details.AccountID, details.AccountInstance, Client.ConnectedUniverse, EAccountType.Individual); if (details.LoginID.HasValue) { logon.Body.obfustucated_private_ip = details.LoginID.Value; } else { uint localIp = NetHelpers.GetIPAddress(this.Client.LocalIP); logon.Body.obfustucated_private_ip = localIp ^ MsgClientLogon.ObfuscationMask; } logon.ProtoHeader.client_sessionid = 0; logon.ProtoHeader.steamid = steamId.ConvertToUInt64(); logon.Body.account_name = details.Username; logon.Body.password = details.Password; logon.Body.should_remember_password = details.ShouldRememberPassword; logon.Body.protocol_version = MsgClientLogon.CurrentProtocol; logon.Body.client_os_type = ( uint )details.ClientOSType; logon.Body.client_language = details.ClientLanguage; logon.Body.cell_id = details.CellID; logon.Body.steam2_ticket_request = details.RequestSteam2Ticket; // we're now using the latest steamclient package version, this is required to get a proper sentry file for steam guard logon.Body.client_package_version = 1771; // todo: determine if this is still required logon.Body.machine_id = HardwareUtils.GetMachineID(); // steam guard logon.Body.auth_code = details.AuthCode; logon.Body.two_factor_code = details.TwoFactorCode; logon.Body.login_key = details.LoginKey; logon.Body.sha_sentryfile = details.SentryFileHash; logon.Body.eresult_sentryfile = ( int )(details.SentryFileHash != null ? EResult.OK : EResult.FileNotFound); this.Client.Send(logon); }
private void CheckIfDBExists(SteamID userID) { if (!Options.NotificationOptions.DB.ContainsKey(userID)) { Options.NotificationOptions.DB.Add(userID.ConvertToUInt64(), new DB()); Options.NotificationOptions.DB[userID.ConvertToUInt64()].pb = new PushBullet(); } if (Options.NotificationOptions.DB[userID].pb.filter == null) { Options.NotificationOptions.DB[userID].pb.filter = new List<string>(); } }