public SteamBot(string newUser, string newPass) { // Bot user and password user = newUser; pass = newPass; // create our steamclient instance steamClient = new SteamClient( System.Net.Sockets.ProtocolType.Tcp ); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // get the steam friends handler, which is used for interacting with friends on the network after logging on steamFriends = steamClient.GetHandler<SteamFriends>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); // we use the following callbacks for friends related activities new Callback<SteamUser.AccountInfoCallback>( OnAccountInfo, manager ); new Callback<SteamFriends.FriendsListCallback>( OnFriendsList, manager ); new Callback<SteamFriends.FriendMsgCallback> (OnFriendMessage, manager); // initiate the connection steamClient.Connect(); // Make sure the main loop runs isRunning = true; }
public Bot(Configuration.BotInfo config, string apiKey, bool debug = false) { sql = new Sql(); Username = config.Username; Password = config.Password; DisplayName = config.DisplayName; Admins = config.Admins; id = config.Id; this.apiKey = apiKey; TradeListener = new ScrapTrade(this); TradeListenerInternal = new ExchangeTrade(this); TradeListenerAdmin = new AdminTrade(this); List<object[]> result = sql.query("SELECT text, response FROM responses"); foreach (object[] row in result) { responses.Add(((string) row[0]).ToLower(), (string) row[1]); } // Hacking around https ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate; SteamClient = new SteamClient(); SteamTrade = SteamClient.GetHandler<SteamTrading>(); SteamUser = SteamClient.GetHandler<SteamUser>(); SteamFriends = SteamClient.GetHandler<SteamFriends>(); queueHandler = new QueueHandler(this); SteamClient.Connect(); while (true) { Update(); } }
static void LogIn() { steamClient = new SteamClient(); callbackManager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler<SteamUser>(); steamFriends = steamClient.GetHandler<SteamFriends>(); steamTrading = steamClient.GetHandler<SteamTrading>(); new Callback<SteamClient.ConnectedCallback>(OnConnect,callbackManager); new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, callbackManager); new Callback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth, callbackManager); new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, callbackManager); new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, callbackManager); new Callback<SteamFriends.FriendMsgCallback>(OnChatMessage, callbackManager); new Callback<SteamFriends.FriendsListCallback>(OnFriendInvite, callbackManager); new Callback<SteamTrading.TradeProposedCallback>(OnTradeOffer, callbackManager); new Callback<SteamTrading.SessionStartCallback>(OnTradeWindow, callbackManager); new Callback<SteamTrading.TradeResultCallback>(OnTradeResult, callbackManager); isRunning = true; Console.WriteLine("Attempting to connect to steam..."); steamClient.Connect(); while(isRunning) { callbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } Console.ReadKey(); }
public static void OnMarketingMessage(SteamUser.MarketingMessageCallback callback) { foreach (var message in callback.Messages) { // TODO: Move this query outside this loop using (MySqlDataReader Reader = DbWorker.ExecuteReader("SELECT `ID` FROM `MarketingMessages` WHERE `ID` = @ID", new MySqlParameter("ID", message.ID))) { if (Reader.Read()) { continue; } } if (message.Flags == EMarketingMessageFlags.None) { IRC.SendMain("New marketing message:{0} {1}", Colors.DARK_BLUE, message.URL); } else { IRC.SendMain("New marketing message:{0} {1} {2}({3})", Colors.DARK_BLUE, message.URL, Colors.DARK_GRAY, message.Flags.ToString().Replace("Platform", string.Empty)); } DbWorker.ExecuteNonQuery("INSERT INTO `MarketingMessages` (`ID`, `Flags`) VALUES (@ID, @Flags)", new MySqlParameter("@ID", message.ID), new MySqlParameter("@Flags", message.Flags) ); } }
private static void Login() { steamClient = new SteamClient(); callBackManager = new CallbackManager(steamClient); steamFriends = steamClient.GetHandler<SteamFriends>(); steamUser = steamClient.GetHandler<SteamUser>(); callBackManager.Subscribe<SteamClient.ConnectedCallback>(OnConnected); callBackManager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedIn); callBackManager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); callBackManager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected); callBackManager.Subscribe<SteamFriends.FriendMsgCallback>(OnMsgRecieved); callBackManager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo); callBackManager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList); callBackManager.Subscribe<SteamFriends.FriendAddedCallback>(OnFriendAdded); callBackManager.Subscribe<SteamFriends.PersonaStateCallback>(OnFriendPersonaChange); SteamDirectory.Initialize().Wait(); steamClient.Connect(); isRunning = true; while (isRunning) { callBackManager.RunWaitCallbacks(TimeSpan.FromSeconds(0.5)); } Console.ReadKey(); }
public void LogIn(string username, string password) { Username = username; Password = password; client = new SK.SteamClient(); CurrentUser = new SteamUser(); manager = new SK.CallbackManager(client); steamUser = client.GetHandler <SK.SteamUser>(); community = client.GetHandler <SK.SteamFriends>(); manager.Subscribe <SK.SteamClient.ConnectedCallback>(OnConnected); manager.Subscribe <SK.SteamClient.DisconnectedCallback>(OnDisconnected); manager.Subscribe <SK.SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe <SK.SteamUser.LoggedOffCallback>(OnLoggedOff); manager.Subscribe <SK.SteamUser.AccountInfoCallback>(OnAccountInfo); manager.Subscribe <SK.SteamFriends.FriendsListCallback>(OnCommunityLoaded); manager.Subscribe <SK.SteamFriends.PersonaStateCallback>(OnPersonaState); manager.Subscribe <SK.SteamFriends.FriendAddedCallback>(OnFriendAdded); IsConnected = true; client.Connect(); Task.Run(() => { while (IsConnected) { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }); }
/// <summary> /// Setup a new bot with some details. /// </summary> /// <param name="details"></param> /// <param name="extensions">any extensions you want on the state machine.</param> public LobbyBot(SteamUser.LogOnDetails details, params IExtension<States, Events>[] extensions) { reconnect = true; this.details = details; log = LogManager.GetLogger("LobbyBot " + details.Username); log.Debug("Initializing a new LobbyBot, username: " + details.Username); reconnectTimer.Elapsed += (sender, args) => { reconnectTimer.Stop(); fsm.Fire(Events.AttemptReconnect); }; fsm = new ActiveStateMachine<States, Events>(); foreach (var ext in extensions) fsm.AddExtension(ext); fsm.DefineHierarchyOn(States.Connecting) .WithHistoryType(HistoryType.None); fsm.DefineHierarchyOn(States.Connected) .WithHistoryType(HistoryType.None) .WithInitialSubState(States.Dota); fsm.DefineHierarchyOn(States.Dota) .WithHistoryType(HistoryType.None) .WithInitialSubState(States.DotaConnect) .WithSubState(States.DotaMenu) .WithSubState(States.DotaLobby); fsm.DefineHierarchyOn(States.Disconnected) .WithHistoryType(HistoryType.None) .WithInitialSubState(States.DisconnectNoRetry) .WithSubState(States.DisconnectRetry); fsm.DefineHierarchyOn(States.DotaLobby) .WithHistoryType(HistoryType.None); fsm.In(States.Connecting) .ExecuteOnEntry(InitAndConnect) .On(Events.Connected).Goto(States.Connected) .On(Events.Disconnected).Goto(States.DisconnectRetry) .On(Events.LogonFailSteamDown).Execute(SteamIsDown) .On(Events.LogonFailSteamGuard).Goto(States.DisconnectNoRetry) //.Execute(() => reconnect = false) .On(Events.LogonFailBadCreds).Goto(States.DisconnectNoRetry); fsm.In(States.Connected) .ExecuteOnExit(DisconnectAndCleanup) .On(Events.Disconnected).If(ShouldReconnect).Goto(States.Connecting) .Otherwise().Goto(States.Disconnected); fsm.In(States.Disconnected) .ExecuteOnEntry(DisconnectAndCleanup) .ExecuteOnExit(ClearReconnectTimer) .On(Events.AttemptReconnect).Goto(States.Connecting); fsm.In(States.DisconnectRetry) .ExecuteOnEntry(StartReconnectTimer); fsm.In(States.Dota) .ExecuteOnExit(DisconnectDota); fsm.In(States.DotaConnect) .ExecuteOnEntry(ConnectDota) .On(Events.DotaGCReady).Goto(States.DotaMenu); fsm.In(States.DotaMenu) .ExecuteOnEntry(SetOnlinePresence); fsm.In(States.DotaLobby) .ExecuteOnEntry(EnterLobbyChat) .ExecuteOnEntry(EnterBroadcastChannel) .On(Events.DotaLeftLobby).Goto(States.DotaMenu).Execute(LeaveChatChannel); fsm.Initialize(States.Connecting); }
private static void OnAccountInfo(SteamUser.AccountInfoCallback callback) { Steam.Instance.Friends.SetPersonaState(EPersonaState.Busy); foreach (var chatRoom in Settings.Current.ChatRooms) { Steam.Instance.Friends.JoinChat(chatRoom); } }
public static void Initialize( bool useUdp ) { Console.WriteLine ("Server now running on: "); SteamClient = new SteamClient( useUdp ? ProtocolType.Udp : ProtocolType.Tcp ); SteamFriends = SteamClient.GetHandler<SteamFriends>(); SteamUser = SteamClient.GetHandler<SteamUser>(); }
public SteamConnection(IntPtr ic) { this.ic = ic; client = new SteamClient(); friends = client.GetHandler<SteamFriends>(); user = client.GetHandler<SteamUser>(); }
static void Main( string[] args ) { // install our debug listeners for this example // install an instance of our custom listener DebugLog.AddListener( new MyListener() ); // install a listener as an anonymous method // this call is commented as it would be redundant to install a second listener that also displays messages to the console // DebugLog.AddListener( ( category, msg ) => Console.WriteLine( "AnonymousMethod - {0}: {1}", category, msg ) ); // Enable DebugLog in release builds DebugLog.Enabled = true; if ( args.Length < 2 ) { Console.WriteLine( "Sample4: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient(); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect(); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
static void Main(string[] args) { // Print program information. Console.WriteLine("SteamIdler, 'run' games without steam.\n(C) No STEAMGUARD Support"); // Check for username and password arguments from stdin. if (args.Length < 3) { // Print usage and quit. Console.WriteLine("usage: <username> <password> <appID> [...]"); return; } // Set username and password from stdin. Username = args[0]; Password = args[1]; // Add all game application IDs to list. foreach (string GameAppID in args) { int AppID; if (int.TryParse(GameAppID, out AppID)) { AppIDs.Add(Convert.ToInt32(GameAppID)); } } // Create SteamClient interface and CallbackManager. steamClient = new SteamClient(System.Net.Sockets.ProtocolType.Tcp); manager = new CallbackManager(steamClient); // Get the steamuser handler, which is used for logging on after successfully connecting. steamUser = steamClient.GetHandler<SteamUser>(); // Get the steam friends handler, which is used for interacting with friends on the network after logging on. steamFriends = steamClient.GetHandler<SteamFriends>(); // Register Steam callbacks. new Callback<SteamClient.ConnectedCallback>(OnConnected, manager); new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, manager); new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, manager); new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff, manager); new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, manager); // Set the program as running. Console.WriteLine(":: Connecting to Steam.."); isRunning = true; // Connect to Steam. steamClient.Connect(); // Create our callback handling loop. while (isRunning) { // In order for the callbacks to get routed, they need to be handled by the manager. manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
public Bot(Configuration.BotInfo config, string apiKey, bool debug = false) { Username = config.Username; Password = config.Password; DisplayName = config.DisplayName; ChatResponse = config.ChatResponse; Admins = config.Admins; this.apiKey = apiKey; AuthCode = null; TradeListener = new TradeEnterTradeListener(this); // Hacking around https ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate; SteamClient = new SteamClient(); SteamTrade = SteamClient.GetHandler<SteamTrading>(); SteamUser = SteamClient.GetHandler<SteamUser>(); SteamFriends = SteamClient.GetHandler<SteamFriends>(); SteamClient.Connect(); Thread CallbackThread = new Thread(() => // Callback Handling { while (true) { CallbackMsg msg = SteamClient.WaitForCallback (true); HandleSteamMessage (msg); } }); new Thread(() => // Trade Polling if needed { while (true) { Thread.Sleep (800); if (CurrentTrade != null) { try { CurrentTrade.Poll (); } catch (Exception e) { Console.Write ("Error polling the trade: "); Console.WriteLine (e); } } } }).Start (); CallbackThread.Start(); CallbackThread.Join(); }
private void OnLoggedOn(SteamUser.LoggedOnCallback callback) { if (callback.Result != EResult.OK) { return; } WebAPIUserNonce = callback.WebAPIUserNonce; TaskManager.Run(() => AuthenticateUser()); }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample8: No username and password specified!" ); return; } // save our logon details user = args[0]; pass = args[1]; // create our steamclient instance steamClient = new SteamClient(); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // get the steam unified messages handler, which is used for sending and receiving responses from the unified service api steamUnifiedMessages = steamClient.GetHandler<SteamUnifiedMessages>(); // we also want to create our local service interface, which will help us build requests to the unified api playerService = steamUnifiedMessages.CreateService<IPlayer>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified manager.Subscribe<SteamClient.ConnectedCallback>( OnConnected ); manager.Subscribe<SteamClient.DisconnectedCallback>( OnDisconnected ); manager.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn ); manager.Subscribe<SteamUser.LoggedOffCallback>( OnLoggedOff ); // we use the following callbacks for unified service responses manager.Subscribe<SteamUnifiedMessages.ServiceMethodResponse>( OnMethodResponse ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect(); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
static void Main(string[] args) { Logger.filename = "RelayBot.log"; log = Logger.GetLogger(); steamClient = new SteamClient(System.Net.Sockets.ProtocolType.Tcp); manager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler<SteamUser>(); steamFriends = steamClient.GetHandler<SteamFriends>(); bot = new Bot(steamUser, steamFriends, steamClient); manager.Subscribe<SteamClient.ConnectedCallback>(bot.OnConnected); manager.Subscribe<SteamClient.DisconnectedCallback>(bot.OnDisconnected); manager.Subscribe<SteamUser.LoggedOnCallback>(bot.OnLoggedOn); manager.Subscribe<SteamUser.LoggedOffCallback>(bot.OnLoggedOff); manager.Subscribe<SteamUser.AccountInfoCallback>(bot.OnAccountInfo); manager.Subscribe<SteamFriends.FriendsListCallback>(bot.OnFriendsList); manager.Subscribe<SteamFriends.FriendAddedCallback>(bot.OnFriendAdded); manager.Subscribe<SteamFriends.ChatInviteCallback>(bot.OnChatInvite); manager.Subscribe<SteamFriends.ChatEnterCallback>(bot.OnChatEnter); manager.Subscribe<SteamFriends.FriendMsgCallback>(bot.OnFriendMessage); manager.Subscribe<SteamFriends.ChatMsgCallback>(bot.OnChatroomMessage); manager.Subscribe<SteamFriends.ChatMemberInfoCallback>(bot.OnMemberInfo); manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(bot.OnMachineAuth); bot.isRunning = true; log.Info("Connecting to Steam..."); steamClient.Connect(); //callback loop while (bot.isRunning) { try { manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } catch (Exception e) { Logger.filename = "RelayBot.log"; log.Error(String.Format("Caught exception: {0}\nMessage: {1}\nStack trace: {2}", e.GetType().ToString(), e.Message, e.StackTrace)); } } }
public Steam3Session( SteamUser.LogOnDetails details ) { this.logonDetails = details; this.authenticatedUser = details.Username != null; this.credentials = new Credentials(); this.bConnected = false; this.bConnecting = false; this.bAborted = false; this.seq = 0; this.AppTickets = new Dictionary<uint, byte[]>(); this.AppTokens = new Dictionary<uint, ulong>(); this.DepotKeys = new Dictionary<uint, byte[]>(); this.CDNAuthTokens = new Dictionary<Tuple<uint, string>, SteamApps.CDNAuthTokenCallback>(); this.AppInfo = new Dictionary<uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>(); this.PackageInfo = new Dictionary<uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>(); this.steamClient = new SteamClient(); this.steamUser = this.steamClient.GetHandler<SteamUser>(); this.steamApps = this.steamClient.GetHandler<SteamApps>(); this.callbacks = new CallbackManager(this.steamClient); this.callbacks.Subscribe<SteamClient.ConnectedCallback>(ConnectedCallback); this.callbacks.Subscribe<SteamClient.DisconnectedCallback>(DisconnectedCallback); this.callbacks.Subscribe<SteamUser.LoggedOnCallback>(LogOnCallback); this.callbacks.Subscribe<SteamUser.SessionTokenCallback>(SessionTokenCallback); this.callbacks.Subscribe<SteamApps.LicenseListCallback>(LicenseListCallback); this.callbacks.Subscribe<SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback); Console.Write( "Connecting to Steam3..." ); if ( authenticatedUser ) { FileInfo fi = new FileInfo(String.Format("{0}.sentryFile", logonDetails.Username)); if (ConfigStore.TheConfig.SentryData != null && ConfigStore.TheConfig.SentryData.ContainsKey(logonDetails.Username)) { logonDetails.SentryFileHash = Util.SHAHash(ConfigStore.TheConfig.SentryData[logonDetails.Username]); } else if (fi.Exists && fi.Length > 0) { var sentryData = File.ReadAllBytes(fi.FullName); logonDetails.SentryFileHash = Util.SHAHash(sentryData); ConfigStore.TheConfig.SentryData[logonDetails.Username] = sentryData; ConfigStore.Save(); } } Connect(); }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample3: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient(); // add our custom handler to our steamclient steamClient.AddHandler( new MyHandler() ); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // now get an instance of our custom handler myHandler = steamClient.GetHandler<MyHandler>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); // handle our own custom callback new Callback<MyHandler.MyCallback>( OnMyCallback, manager ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect(); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample9: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient(); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // get our steamapps handler, we'll use this as an example of how async jobs can be handled steamApps = steamClient.GetHandler<SteamApps>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified manager.Subscribe<SteamClient.ConnectedCallback>( OnConnected ); manager.Subscribe<SteamClient.DisconnectedCallback>( OnDisconnected ); manager.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn ); manager.Subscribe<SteamUser.LoggedOffCallback>( OnLoggedOff ); // notice that we're not subscribing to the SteamApps.PICSProductInfoCallback callback here (or other SteamApps callbacks) // since this sample is using the async job directly, we no longer need to subscribe to the callback. // however, if we still wish to use callbacks (or have existing code which subscribes to callbacks, they will // continue to operate alongside direct async job handling. (i.e.: steamclient will still post callbacks for // any async jobs that are completed) isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect(); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
private void OnWebAPIUserNonce(SteamUser.WebAPIUserNonceCallback callback) { if (callback.Result != EResult.OK) { Log.WriteWarn("WebAuth", "Unable to get user nonce: {0}", callback.Result); // TODO: Should keep trying? return; } WebAPIUserNonce = callback.Nonce; }
void OnLoginKey(SteamUser.LoginKeyCallback callback) { string SessionID = WebHelpers.EncodeBase64(callback.UniqueID.ToString()); using (dynamic userAuth = WebAPI.GetInterface("ISteamUserAuth")) { // generate an AES session key var sessionKey = CryptoHelper.GenerateRandomBlock(32); // rsa encrypt it with the public key for the universe we're on byte[] cryptedSessionKey = null; using (var rsa = new RSACrypto(KeyDictionary.GetPublicKey(Client.ConnectedUniverse))) { cryptedSessionKey = rsa.Encrypt(sessionKey); } byte[] loginKey = new byte[20]; Array.Copy(Encoding.ASCII.GetBytes(callback.LoginKey), loginKey, callback.LoginKey.Length); // AES encrypt the loginkey with our session key. byte[] cryptedLoginKey = CryptoHelper.SymmetricEncrypt(loginKey, sessionKey); KeyValue authResult = null; EResult result = EResult.OK; try { authResult = userAuth.AuthenticateUser( steamid: Client.SteamID.ConvertToUInt64(), sessionkey: WebHelpers.UrlEncode(cryptedSessionKey), encrypted_loginkey: WebHelpers.UrlEncode(cryptedLoginKey), method: "POST" ); } catch (Exception) { result = EResult.Fail; } Login.SessionId = SessionID; if (authResult != null) Login.Token = authResult["token"].AsString(); this.Client.PostCallback(new WebLoggedOnCallback() { Result = result, Login = Login }); } }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample5: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient( System.Net.Sockets.ProtocolType.Tcp ); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // get the steam friends handler, which is used for interacting with friends on the network after logging on steamFriends = steamClient.GetHandler<SteamFriends>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); // we use the following callbacks for friends related activities new Callback<SteamUser.AccountInfoCallback>( OnAccountInfo, manager ); new Callback<SteamFriends.FriendsListCallback>( OnFriendsList, manager ); new Callback<SteamFriends.PersonaStateCallback>( OnPersonaState, manager ); new Callback<SteamFriends.FriendAddedCallback>( OnFriendAdded, manager ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect( false ); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
protected override void OnLoggedOn( SteamUser.LoggedOnCallback callback ) { base.OnLoggedOn( callback ); if ( callback.Result != EResult.OK ) { Log.WriteWarn( "MasterMonitor", "Unable to logon to Steam: {0}", callback.Result ); return; } Log.WriteInfo( "MasterMonitor", "Logged onto Steam!" ); Connect( DateTime.Now + TimeSpan.FromMinutes( 30 ) ); }
static void Main( string[] args ) { if ( args.Length < 2 ) { Console.WriteLine( "Sample5: No username and password specified!" ); return; } // save our logon details user = args[ 0 ]; pass = args[ 1 ]; // create our steamclient instance steamClient = new SteamClient(); // create the callback manager which will route callbacks to function calls manager = new CallbackManager( steamClient ); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // get the steam friends handler, which is used for interacting with friends on the network after logging on steamFriends = steamClient.GetHandler<SteamFriends>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified new Callback<SteamClient.ConnectedCallback>( OnConnected, manager ); new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager ); new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager ); new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager ); // this callback is triggered when the steam servers wish for the client to store the sentry file new JobCallback<SteamUser.UpdateMachineAuthCallback>( OnMachineAuth, manager ); isRunning = true; Console.WriteLine( "Connecting to Steam..." ); // initiate the connection steamClient.Connect(); // create our callback handling loop while ( isRunning ) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) ); } }
public SteamNerd() { SteamClient = new SteamClient(); CallbackManager = new CallbackManager(SteamClient); ModuleManager = new ModuleManager(this); UserManager = new UserManager(this, "admins.txt"); ChatRoomManager = new ChatRoomManager(this, "chats.txt"); SteamUser = SteamClient.GetHandler<SteamUser>(); SteamFriends = SteamClient.GetHandler<SteamFriends>(); SubscribeCallbacks(); _login = new Login(this, CallbackManager); }
public SteamInterface(String username, String password, String ssfn, SteamID channel) { lastRefresh = DateTime.Now; this.channel = channel; logon = new SteamUser.LogOnDetails() { Username = username, Password = password, SentryFileHash = SHA1.Create().ComputeHash((File.ReadAllBytes(ssfn))) }; admins = new List<SteamID>(); client = new SteamClient(System.Net.Sockets.ProtocolType.Tcp); manager = new CallbackManager(client); message = new Message() { MessageString = SteamInterface.NoCommand }; user = client.GetHandler<SteamUser>(); friends = client.GetHandler<SteamFriends>(); new Callback<SteamClient.ConnectedCallback>(this.OnConnected, manager); new Callback<SteamClient.DisconnectedCallback>(this.OnDisconnected, manager); new Callback<SteamUser.LoggedOnCallback>(this.OnLoggedOn, manager); new Callback<SteamUser.LoggedOffCallback>(this.OnLoggedOff, manager); new Callback<SteamFriends.ChatMsgCallback>(this.OnChatMessage, manager); }
// static string toptlb; // public static string steamgg(string code) // { // return code; // } public static void Enter_(string us, string pa, ToolStripLabel tlb_) { user = us; pass = pa; tlb = tlb_; if ((user.Length < 2) || (pass.Length < 2)) { tlb.Text = "No username and password specified!"; return; } // create our steamclient instance steamClient = new SteamClient(); // create the callback manager which will route callbacks to function calls manager = new CallbackManager(steamClient); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler<SteamUser>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified manager.Subscribe<SteamClient.ConnectedCallback>(OnConnected); manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected); manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff); // this callback is triggered when the steam servers wish for the client to store the sentry file //manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); isRunning = true; tlb.Text = "Connecting to Steam..."; // initiate the connection steamClient.Connect(); // create our callback handling loop while (isRunning) { // in order for the callbacks to get routed, they need to be handled by the manager manager.RunWaitCallbacks(TimeSpan.FromSeconds(1)); } }
public SteamWrappedClient() { Client = new SteamClient(); CallbackManager = new CallbackManager(Client); User = Client.GetHandler<SteamUser>(); TradingHandler = Client.GetHandler<SteamTrading>(); CallbackManager.Subscribe<SteamClient.ConnectedCallback>(OnConnect); CallbackManager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnect); CallbackManager.Subscribe<SteamUser.LoggedOnCallback>(OnLogon); CallbackManager.Subscribe<SteamUser.LoggedOffCallback>(OnLogoff); CallbackManager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); RegisterOtherCallbacks(); }
public SteamKit(ARKUpdater p, AutoResetEvent r) { this._Parent = p; this._ResetEvent = r; this.Ready = false; this.Failed = false; this._ThreadRunning = true; this._Client = new SteamClient(); this._CManager = new CallbackManager(this._Client); this._User = this._Client.GetHandler<SteamUser>(); this._Apps = this._Client.GetHandler<SteamApps>(); this.SubscribeCallbacks(); this._Client.Connect(); }
public GCIdler(uint appID, string username, string password) { Username = username; Password = password; AppID = appID; Client = new SteamClient(); User = Client.GetHandler<SteamUser>(); Friends = Client.GetHandler<SteamFriends>(); CallbackManager = new CallbackManager(Client); CallbackManager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected)); CallbackManager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected)); CallbackManager.Register(new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo)); CallbackManager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn)); GameCoordinator = new GameCoordinator(AppID, Client, CallbackManager); }
public Steam3Session( SteamUser.LogOnDetails details ) { this.logonDetails = details; this.authenticatedUser = details.Username != null; this.credentials = new Credentials(); this.bConnected = false; this.bAborted = false; this.AppTickets = new Dictionary<uint, byte[]>(); this.AppTokens = new Dictionary<uint, ulong>(); this.DepotKeys = new Dictionary<uint, byte[]>(); this.AppInfo = new Dictionary<uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>(); this.PackageInfo = new Dictionary<uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>(); this.AppInfoOverridesCDR = new Dictionary<uint, bool>(); this.steamClient = new SteamClient(); this.steamUser = this.steamClient.GetHandler<SteamUser>(); this.steamApps = this.steamClient.GetHandler<SteamApps>(); this.callbacks = new CallbackManager(this.steamClient); this.callbacks.Register(new Callback<SteamClient.ConnectedCallback>(ConnectedCallback)); this.callbacks.Register(new Callback<SteamClient.DisconnectedCallback>(DisconnectedCallback)); this.callbacks.Register(new Callback<SteamUser.LoggedOnCallback>(LogOnCallback)); this.callbacks.Register(new Callback<SteamUser.SessionTokenCallback>(SessionTokenCallback)); this.callbacks.Register(new Callback<SteamApps.LicenseListCallback>(LicenseListCallback)); this.callbacks.Register(new JobCallback<SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback)); Console.Write( "Connecting to Steam3..." ); if ( authenticatedUser ) { FileInfo fi = new FileInfo(String.Format("{0}.sentryFile", logonDetails.Username)); if (fi.Exists && fi.Length > 0) { logonDetails.SentryFileHash = Util.SHAHash(File.ReadAllBytes(fi.FullName)); } } Connect(); }
private void InitializeClient() { // client/manager creation Client = new SteamClient(); Manager = new CallbackManager(Client); _user = Client.GetHandler <SteamUser>(); _apps = Client.GetHandler <SteamApps>(); Client.AddHandler(new SteamTicketAuth()); // subscriptions Manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); Manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); Manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); Manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); // internal subs Manager.Subscribe <SteamApps.GameConnectTokensCallback>(OnGcTokens); }