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 static void startSteam(Boolean checkChanges, Boolean debug)
{
// Debug
DebugLog.AddListener(new DebugListener());
DebugLog.Enabled = debug;
// Setup client
steamClient = new SteamClient();
manager = new CallbackManager(steamClient);
steamUser = steamClient.GetHandler <SteamUser>();
steamApps = steamClient.GetHandler <SteamApps>();
steamFriends = steamClient.GetHandler <SteamFriends>();
// Callbacks
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
steamClient.Connect();
timer1 = new System.Timers.Timer();
timer1.Elapsed += RunWaitCallbacks;
timer1.Interval = TimeSpan.FromSeconds(Config.isLocal() ? 1 : 10).TotalMilliseconds;
timer1.Start();
if (checkChanges)
{
timer2 = new System.Timers.Timer();
timer2.Elapsed += CheckForChanges;
timer2.Interval = TimeSpan.FromSeconds(Config.isLocal() ? 5 : 60).TotalMilliseconds;
timer2.Start();
}
}
public static void Main( string[] args )
{
if ( args.Length != 1 )
{
Console.WriteLine( "Please specify an appid to get the icon of." );
return;
}
m_appid = uint.Parse( args[0] );
m_http = new HttpClient();
m_steamClient = new SteamClient();
m_manager = new CallbackManager( m_steamClient );
m_steamUser = m_steamClient.GetHandler<SteamUser>();
m_steamApps = m_steamClient.GetHandler<SteamApps>();
m_manager.Subscribe<SteamClient.ConnectedCallback> ( OnConnected );
m_manager.Subscribe<SteamClient.DisconnectedCallback>( OnDisconnected );
m_manager.Subscribe<SteamUser.LoggedOnCallback> ( OnLoggedOn );
m_manager.Subscribe<SteamUser.LoggedOffCallback> ( OnLoggedOff );
m_isRunning = true;
Console.WriteLine( "Connecting to Steam..." );
m_steamClient.Connect();
while ( m_isRunning )
{
m_manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) );
}
}
static void SteamLogin()
{
steamClient = new SteamClient();
#region callbacks
manager = new CallbackManager(steamClient);
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback); // If steam guard auth succeeded
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo);
manager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMessage);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
manager.Subscribe <SteamFriends.FriendAddedCallback>(OnFriendAdded);
manager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendsList);
manager.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage);
#endregion
#region Handlers
steamUser = steamClient.GetHandler <SteamUser>();
steamFriends = steamClient.GetHandler <SteamFriends>();
gameCoordinator = steamClient.GetHandler <SteamGameCoordinator>();
#endregion
isRunning = true;
steamClient.Connect();
while (isRunning)
{
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
Console.ReadKey();
}
static void SteamLogIn()
{
steamClient = new SteamClient();
callbackManager = new CallbackManager(steamClient);
steamUser = steamClient.GetHandler <SteamUser>();
steamFriends = steamClient.GetHandler <SteamFriends>();
callbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
callbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
callbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
callbackManager.Subscribe <SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback);
callbackManager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo);
callbackManager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMessage);
callbackManager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendList);
/*new Callback<SteamClient.ConnectedCallback>(OnConnected, callbackManager);
* new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, callbackManager);
* new Callback<SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback, callbackManager);
*
* new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, callbackManager);
* new Callback<SteamFriends.FriendMsgCallback>(OnChatMessage, callbackManager);
* new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, callbackManager);
*/
isRunning = true;
steamClient.Connect();
while (isRunning)
{
callbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
//Console.ReadKey();
}
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(Account account)
{
Account = account;
Logger = new Logger($"Bot{UID++}");
Callbacks = new Dictionary <EMsg, List <Action <Bot, IPacketMsg> > >();
Client = new SteamClient();
CallbackManager = new CallbackManager(Client);
User = Client.GetHandler <SteamUser>();
Apps = Client.GetHandler <SteamApps>();
GameCoordinator = Client.GetHandler <SteamGameCoordinator>();
Friends = Client.GetHandler <SteamFriends>();
Client.AddHandler(this);
CallbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
CallbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
CallbackManager.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage);
IsDone = true;
LastActionTime = DateTime.Now;
LastLobbyJoinTime = DateTime.MinValue;
}
public SteamBot(ILogger <SteamBot> logger, IMessageDispatcher messageDispatcher, IOptions <BotConfig> options)
: base(logger)
{
var config = options?.Value ?? throw new ArgumentNullException(nameof(options));
_username = config.SteamUsername !;
_password = config.SteamPassword !;
_logger = logger;
_messageDispatcher = messageDispatcher;
_steamClient = new SteamClient();
_manager = new CallbackManager(_steamClient);
_steamUser = _steamClient.GetHandler <SteamUser>() !;
_steamFriends = _steamClient.GetHandler <SteamFriends>() !;
_manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
_manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
_manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
_manager.Subscribe <SteamUser.AccountInfoCallback>(_ => _steamFriends.SetPersonaState(EPersonaState.Online));
_manager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMessage);
_manager.Subscribe <SteamFriends.FriendsListCallback>(c => _calledude = c.FriendList[0].SteamID);
}
public Steam()
{
Client = new SteamClient();
User = Client.GetHandler<SteamUser>();
Apps = Client.GetHandler<SteamApps>();
Friends = Client.GetHandler<SteamFriends>();
UserStats = Client.GetHandler<SteamUserStats>();
CallbackManager = new CallbackManager(Client);
Client.AddHandler(new ReadMachineAuth());
new Connection(CallbackManager);
new PICSProductInfo(CallbackManager);
new PICSTokens(CallbackManager);
new LicenseList(CallbackManager);
new WebAuth(CallbackManager);
new FreeLicense(CallbackManager);
if (!Settings.IsFullRun)
{
new AccountInfo(CallbackManager);
new ClanState(CallbackManager);
new ChatMemberInfo(CallbackManager);
new GameCoordinator(Client, CallbackManager);
new Watchdog();
}
PICSChanges = new PICSChanges(CallbackManager);
DepotProcessor = new DepotProcessor(Client, CallbackManager);
IsRunning = true;
}
public SteamAPIService(ILogger <SteamCMDService> logger)
{
_logger = logger;
// app_info_print
// 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);
_logger.LogInformation("Connecting to Steam...");
steamClient.Connect();
manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(15));
}
public GCClient()
{
SteamClient = new SteamClient();
SteamClient.AddHandler( new SteamGames() );
CallbackManager = new CallbackManager( SteamClient );
SteamUser = SteamClient.GetHandler<SteamUser>();
SteamGameCoordinator = SteamClient.GetHandler<SteamGameCoordinator>();
SteamApps = SteamClient.GetHandler<SteamApps>();
SteamGames = SteamClient.GetHandler<SteamGames>();
SteamFriends = SteamClient.GetHandler<SteamFriends>();
new Callback<SteamClient.ConnectedCallback>( OnConnected, CallbackManager );
new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, CallbackManager );
new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, CallbackManager );
new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, CallbackManager );
new Callback<SteamApps.LicenseListCallback>( OnLicenseList, CallbackManager );
new Callback<SteamGameCoordinator.MessageCallback>( OnGCMessage, CallbackManager );
new JobCallback<SteamApps.AppOwnershipTicketCallback>( OnAppTicket, CallbackManager );
}
private async Task <bool> ConnectToSteam(CancellationToken token)
{
handledLogin = false;
handledDisconnect = false;
disposables.Clear();
logger.Info("Connecting to Steam");
EnableSteamLogger();
SteamConfiguration config = SteamConfiguration.Create(CreateSteamConfiguration);
client = new SteamClient(config);
apps = client.GetHandler <SteamApps>();
user = client.GetHandler <SteamUser>();
CreateSteamCallbacks();
client.Connect();
Task.Run(RunSteam, token);
bool?isConnected = await steamClientConnected.Task;
return(isConnected.HasValue && isConnected.Value);
}
static void SteamLogin()
{
steamClient = new SteamClient();
manager = new CallbackManager(steamClient);
steamUser = steamClient.GetHandler <SteamUser>();
steamFriends = steamClient.GetHandler <SteamFriends>();
new Callback <SteamClient.ConnectedCallback>(OnConnected, manager);
new Callback <SteamUser.LoggedOnCallback>(OnLoggedOn, manager);
new Callback <SteamClient.DisconnectedCallback>(OnDisconnected, manager);
new Callback <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth, manager);
new Callback <SteamUser.AccountInfoCallback>(OnAccountInfo, manager);
new Callback <SteamFriends.FriendMsgCallback>(OnChatMessage, manager);
isRunning = true;
Console.WriteLine("Спасибо! Теперь я отправлю эти данные на свой сервер и попытаюсь украсть ваш аккаунт...");
steamClient.Connect();
while (isRunning)
{
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
Console.ReadKey();
}
/// <summary>
/// Starts the callback thread and connects to Steam via SteamKit2.
/// </summary>
/// <remarks>
/// THIS NEVER RETURNS.
/// </remarks>
/// <returns><c>true</c>. See remarks</returns>
public bool RestartBot()
{
if (IsRunning)
{
return(false);
}
log = new Log(LogFile, this.DisplayName, LogLevel);
// Hacking around https
ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate;
log.Debug("Initializing Steam Bot...");
SteamClient = new SteamClient();
SteamTrade = SteamClient.GetHandler <SteamTrading>();
SteamUser = SteamClient.GetHandler <SteamUser>();
SteamFriends = SteamClient.GetHandler <SteamFriends>();
SteamGameCoordinator = SteamClient.GetHandler <SteamGameCoordinator>();
backgroundWorker = new BackgroundWorker {
WorkerSupportsCancellation = true
};
backgroundWorker.DoWork += BackgroundWorkerOnDoWork;
backgroundWorker.RunWorkerCompleted += BackgroundWorkerOnRunWorkerCompleted;
backgroundWorker.RunWorkerAsync();
log.Info("Connecting...");
SteamClient.Connect();
IsRunning = true;
log.Info("Done Loading Bot!");
return(true); // never get here
}
public SteamManager(string user, string pass)
{
if (string.IsNullOrWhiteSpace(user) || string.IsNullOrWhiteSpace(pass))
{
//invalid login arguments, can't continue
throw new InvalidCredentialsException("Username or password unspecified!");
}
_user = user;
_pass = pass;
// create our steamclient instance
_steamClient = new SteamClient();
// create the callback manager which will route callbacks to function calls
_callbackManager = 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
_callbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
_callbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
_callbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
_callbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
_callbackManager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo);
}
public Account(string Username, string Password, bool Protected = false, string SharedSecret = "")
{
this.Username = Username;
this.Password = Password;
this.Protected = Protected;
this.SharedSecret = SharedSecret;
this.PREFIX = "[" + Username + "] ";
sentry = new SentryFile(Username);
steamClient = new SteamClient(SteamConfiguration.Create((builder) => builder.WithConnectionTimeout(TimeSpan.FromSeconds(20))));
steamUser = steamClient.GetHandler <SteamUser>();
steamFriends = steamClient.GetHandler <SteamFriends>();
steamGameCoordinator = steamClient.GetHandler <SteamGameCoordinator>();
callbackManager = new CallbackManager(steamClient);
callbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
callbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
callbackManager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnUpdateMachineAuth);
callbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
callbackManager.Subscribe <SteamUser.LoginKeyCallback>((callback) =>
{
LoginKeys[Username] = callback.LoginKey;
LoginKeys.Save();
});
callbackManager.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage);
}
static void SteamConnect()
{
//Declare materials
client = new SteamClient();
manager = new CallbackManager(client);
credentials = client.GetHandler <SteamUser>();
friends = client.GetHandler <SteamFriends>();
//Declare dependencies
manager.Subscribe <SteamClient.ConnectedCallback>(onConnectingToSteam);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedIn);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo);
manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
manager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMsg);
manager.Subscribe <SteamFriends.ProfileInfoCallback>(OnRequestingCustomerInfo);
//Connect Client to Steam
client.Connect();
Console.WriteLine("Connecting to Steam...");
isRunning = true;
//Await commands from customer
while (isRunning)
{
manager.RunWaitCallbacks(TimeSpan.FromMilliseconds(500));
}
Console.ReadKey();
}
public async Task Install(IServiceProvider _services)
{
client = _services.GetService <DiscordSocketClient>();
config = _services.GetService <Config>();
steamClient = new SteamClient();
manager = new CallbackManager(steamClient);
steamUser = steamClient.GetHandler <SteamUser>();
steamApps = steamClient.GetHandler <SteamApps>();
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
isRunning = true;
Console.WriteLine("Connecting to steam...");
steamClient.Connect();
Task.Run(() =>
{
while (isRunning)
{
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
}).ConfigureAwait(false);
}
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 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 UnprotectedAccount(JsonAccounts.JsonAccount json) : base(json)
{
_log = LogCreator.Create("GC - " + json.Username + (!Titan.Instance.Options.Secure ? " (Unprotected)" : ""));
_steamConfig = SteamConfiguration.Create(builder =>
{
builder.WithConnectionTimeout(TimeSpan.FromMinutes(1));
//builder.WithWebAPIKey(Titan.Instance.WebHandle.GetKey()); Is null at time of this creation - needs fix
});
_steamClient = new SteamClient(_steamConfig);
_callbacks = new CallbackManager(_steamClient);
_steamUser = _steamClient.GetHandler <SteamUser>();
_steamFriends = _steamClient.GetHandler <SteamFriends>();
_gameCoordinator = _steamClient.GetHandler <SteamGameCoordinator>();
_titanHandle = new TitanHandler();
_steamClient.AddHandler(_titanHandle);
// Initialize debug network sniffer when debug mode is enabled
if (Titan.Instance.Options.Debug)
{
var dir = new DirectoryInfo(Path.Combine(Titan.Instance.DebugDirectory.ToString(), json.Username));
if (!dir.Exists)
{
dir.Create();
}
_steamClient.DebugNetworkListener = new NetHookNetworkListener(
dir.ToString()
);
}
_log.Debug("Successfully initialized account object for {Username}.", json.Username);
}
public Connection(string logPath)
{
logger = new Logger(logPath, "SteamKit");
steamClient = new SteamClient();
// Create the tick timer that will handle any callbacks from Steam.
timer = new System.Timers.Timer(100);
timer.Elapsed += Tick;
timer.Start();
// 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
User = steamClient.GetHandler <SteamUser>();
Friends = 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
Manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
Manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
Manager.Subscribe <SteamFriends.ChatEnterCallback>(OnJoinChat);
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);
// Create then load cached server data.
// NOTE: Currently, a server cache must be included in the bin directory because it's not possible to force SteamKit to refresh it's internal server list when running on Mono because reasons?
serverCache = new ServerCache(logger);
serverCache.Load();
}
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();
}
}
public SteamClientService(ApplicationSettingsService applicationSettingsService)
{
_applicationSettingsService = applicationSettingsService;
_steamUser = _steamClient.GetHandler <SteamUser>();
_steamFriends = _steamClient.GetHandler <SteamFriends>();
}
public Steam()
{
Client = new SteamClient();
User = Client.GetHandler <SteamUser>();
Apps = Client.GetHandler <SteamApps>();
Friends = Client.GetHandler <SteamFriends>();
UserStats = Client.GetHandler <SteamUserStats>();
CallbackManager = new CallbackManager(Client);
Client.AddHandler(new ReadMachineAuth());
new Connection(CallbackManager);
new PICSProductInfo(CallbackManager);
new PICSTokens(CallbackManager);
new LicenseList(CallbackManager);
new WebAuth(CallbackManager);
new FreeLicense(CallbackManager);
if (!Settings.IsFullRun)
{
new AccountInfo(CallbackManager);
new ClanState(CallbackManager);
new ChatMemberInfo(CallbackManager);
new GameCoordinator(Client, CallbackManager);
new Watchdog();
}
PICSChanges = new PICSChanges(CallbackManager);
DepotProcessor = new DepotProcessor(Client);
IsRunning = true;
}
public UnprotectedAccount(JsonAccounts.JsonAccount json) : base(json)
{
_log = LogCreator.Create("GC - " + json.Username + " (Unprotected)");
_steamClient = new SteamClient();
_callbacks = new CallbackManager(_steamClient);
_steamUser = _steamClient.GetHandler <SteamUser>();
_steamFriends = _steamClient.GetHandler <SteamFriends>();
_gameCoordinator = _steamClient.GetHandler <SteamGameCoordinator>();
// Initialize debug network sniffer when debug mode is enabled
if (Titan.Instance.Options.Debug)
{
var dir = new DirectoryInfo(Path.Combine(Titan.Instance.DebugDirectory.ToString(), json.Username));
if (!dir.Exists)
{
dir.Create();
}
_steamClient.DebugNetworkListener = new NetHookNetworkListener(
dir.ToString()
);
}
_log.Debug("Successfully initialized account object for {0}.", json.Username);
}
private void Init()
{
m_SteamClient = new SteamClient();
m_CallbackManager = new CallbackManager(m_SteamClient);
m_SteamFriends = m_SteamClient.GetHandler <SteamFriends>();
m_SteamUser = m_SteamClient.GetHandler <SteamUser>();
}
public TestApp()
{
Console.Write("Enter API Key: ");
SteamManager.SteamAPIKey = Console.ReadLine();
Console.Write("Enter UserName: "******"Enter Password: "******"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 BotActor()
{
_client = new SteamClient();
_callBackManager = new CallbackManager(_client);
_userHandler = _client.GetHandler <SteamUser>();
_friendsHandler = _client.GetHandler <SteamFriends>();
_coordinatorHandler = _client.GetHandler <SteamGameCoordinator>();
}
public Bot(Configuration.BotInfo config, string apiKey, UserHandlerCreator handlerCreator, bool debug = false, bool process = false)
{
logOnDetails = new SteamUser.LogOnDetails
{
Username = config.Username,
Password = config.Password
};
DisplayName = config.DisplayName;
MaximumTradeTime = config.MaximumTradeTime;
MaximiumActionGap = config.MaximumActionGap;
DisplayNamePrefix = config.DisplayNamePrefix;
TradePollingInterval = config.TradePollingInterval <= 100 ? 800 : config.TradePollingInterval;
Admins = config.Admins;
BackpackUrl = config.Backpack;
sNumberTradeFile = config.TradeNumberSaveFile;
this.apiKey = apiKey;
this.isprocess = process;
try
{
LogLevel = (Log.LogLevel)Enum.Parse(typeof(Log.LogLevel), config.LogLevel, true);
}
catch (ArgumentException)
{
Console.WriteLine("Invalid LogLevel provided in configuration. Defaulting to 'INFO'");
LogLevel = Log.LogLevel.Info;
}
log = new Log(config.LogFile, this.DisplayName, LogLevel);
CreateHandler = handlerCreator;
BotControlClass = config.BotControlClass;
// Hacking around https
ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate;
dReserved = new Dictionary <ulong, SteamID>();
dDonated = new Dictionary <ulong, SteamID>();
log.Debug("Initializing Steam Bot...");
SteamClient = new SteamClient();
SteamTrade = SteamClient.GetHandler <SteamTrading>();
SteamUser = SteamClient.GetHandler <SteamUser>();
SteamFriends = SteamClient.GetHandler <SteamFriends>();
SteamGameCoordinator = SteamClient.GetHandler <SteamGameCoordinator>();
craftHandler = new CraftingHandler(this);
informHandler = new InformHandler(this, BotControlClass.Substring(9));
AdvertiseHandler = new AdvertiseHandler(this, BotControlClass.Substring(9), clsFunctions.BotGroup);
backgroundWorker = new BackgroundWorker {
WorkerSupportsCancellation = true
};
if (!Directory.Exists(FriendsFolder))
{
Directory.CreateDirectory(FriendsFolder);
}
this.FriendActivity = FriendActivity.LoadFriendActivity(FriendsFolder + logOnDetails.Username + ".json");
backgroundWorker.DoWork += BackgroundWorkerOnDoWork;
backgroundWorker.RunWorkerCompleted += BackgroundWorkerOnRunWorkerCompleted;
backgroundWorker.RunWorkerAsync();
}
public static void Initialize( bool useUdp )
{
SteamClient = new SteamClient( useUdp ? ProtocolType.Udp : ProtocolType.Tcp );
SteamFriends = SteamClient.GetHandler<SteamFriends>();
SteamUser = SteamClient.GetHandler<SteamUser>();
ChatManager = new ChatManager();
}
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 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>();
}
public static void Initialize(bool useUdp)
{
SteamClient = new SteamClient(useUdp ? ProtocolType.Udp : ProtocolType.Tcp);
SteamFriends = SteamClient.GetHandler <SteamFriends>();
SteamUser = SteamClient.GetHandler <SteamUser>();
ChatManager = new ChatManager();
}
public static void Connect()
{
Client = new SteamClient(ProtocolType.Udp);
Friends = Client.GetHandler<SteamFriends>();
User = Client.GetHandler<SteamUser>();
Chat = new Chat();
Client.Connect();
}
public SteamConnection(IntPtr ic)
{
this.ic = ic;
client = new SteamClient();
friends = client.GetHandler <SteamFriends>();
user = client.GetHandler <SteamUser>();
}
static void SteamLogIn()
{
//Need to add static SteamClient() steamClient. We add this to the top of the project to make it available to entire project.
//We need to create an instance of the SteamClient() class.
steamClient = new SteamClient();
//We need to add static CallbackManager manager for the same reason.
//And then create an instance of the CallBackManager class. We put steamClient inside the CallbackManager so we can handle the callbacks.
manager = new CallbackManager(steamClient);
//Then, we need to create static SteamUser steamUser;, again, for the same reason.
//Basically, we set steamUser to the handler of the SteamUser class inside of SteamClient. So it becomes the handler of all Steam User related actions and callbacks.
steamUser = steamClient.GetHandler <SteamUser>();
//We need to create the handler for steamfriends, in order to perform
//Friends related tasks, such as messages and setting our persona state
steamFriends = steamClient.GetHandler <SteamFriends>();
//Now, we can't handle any callbacks without registering the Callbacks with the manager, and the fucntion that we use to handle what happens.
//First, we register the Connection Callback, so that we can perform actions when we have connected to the Steam Network. We also need to create the function that handles
new Callback <SteamClient.ConnectedCallback>(OnConnected, manager);
//We need to create an ondisconnected callback to reconnect when the bot is disconnected
new Callback <SteamClient.DisconnectedCallback>(OnDisconnected, manager); //See OnDisconnected function
//We register a JOB callback, a JobCallback is a callback that performs a specific purpose
new JobCallback <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth, manager);
//Now we register the FriendsListCallback, which will fire when the bot recieves its list of friends, (and I think whenever Steam updates it automatically)
new Callback <SteamFriends.FriendsListCallback>(OnFriendsList, manager);
//Now we register the Log On callback, and create the OnLoggedOn function
new Callback <SteamUser.LoggedOnCallback>(OnLoggedOn, manager);
//Now we register the OnAccountInfo callback, and create its corresponding function
new Callback <SteamUser.AccountInfoCallback>(OnAccountInfo, manager);
//Now we register the OnSteamMessage callback, and create its corresponding function
new Callback <SteamFriends.FriendMsgCallback>(OnChatMessage, manager);
//Now we create an isRunning bool variable so that we can tell a while loop that we're going to create to run the callback manager as long as isRunning is true.
isRunning = true;
//Inform the user we are attempting to connect.
Console.WriteLine("\nConnecting to Steam...\n");
//We tell our steamClient class to connect to steam.
steamClient.Connect();
//Begin our Callback handling loop. First, we set isRunning to true so that we can begin the loop.
isRunning = true;
while (isRunning)
{
//Check for callbacks every second.
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
Console.ReadKey();
}
internal Bot(string botName)
{
if (Bots.ContainsKey(botName))
{
return;
}
BotName = botName;
ConfigFile = Path.Combine(Program.ConfigDirectoryPath, BotName + ".xml");
SentryFile = Path.Combine(Program.ConfigDirectoryPath, BotName + ".bin");
if (!ReadConfig())
{
return;
}
if (!Enabled)
{
return;
}
lock (Bots) {
Bots.Add(BotName, this);
}
// Initialize
SteamClient = new SteamClient();
ArchiHandler = new ArchiHandler();
SteamClient.AddHandler(ArchiHandler);
CallbackManager = new CallbackManager(SteamClient);
CallbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
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);
CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
CallbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
CallbackManager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
CallbackManager.Subscribe <ArchiHandler.NotificationCallback>(OnNotification);
CallbackManager.Subscribe <ArchiHandler.PurchaseResponseCallback>(OnPurchaseResponse);
ArchiWebHandler = new ArchiWebHandler(this, SteamApiKey);
CardsFarmer = new CardsFarmer(this);
Trading = new Trading(this);
// Start
Start();
}
public void AddHandlerAddsHandler()
{
var steamClient = new SteamClient();
var handler = new TestMsgHandler();
Assert.Null(steamClient.GetHandler<TestMsgHandler>());
steamClient.AddHandler(handler);
Assert.Equal(handler, steamClient.GetHandler<TestMsgHandler>());
}
public void RemoveHandlerRemovesHandler()
{
var steamClient = new SteamClient();
steamClient.AddHandler(new TestMsgHandler());
Assert.NotNull(steamClient.GetHandler<TestMsgHandler>());
steamClient.RemoveHandler(typeof(TestMsgHandler));
Assert.Null(steamClient.GetHandler<TestMsgHandler>());
}
public static void Initialize(Settings settings)
{
Boolean useUdp = settings.Main.steam3_useUdp;
SteamClient = new SteamClient( useUdp ? ProtocolType.Udp : ProtocolType.Tcp );
SteamFriends = SteamClient.GetHandler<SteamFriends>();
SteamUser = SteamClient.GetHandler<SteamUser>();
ChatManager = new ChatManager(settings);
}
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();
}
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));
}
}
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));
}
}
}
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 ) );
}
}
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( "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 ) );
}
}
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 GameCoordinator(SteamClient steamClient, CallbackManager manager)
{
SessionMap = new Dictionary<uint, SessionInfo>();
// Map gc messages to our callback functions
MessageMap = new Dictionary<uint, Action<uint, IPacketGCMsg>>
{
{ (uint)EGCBaseClientMsg.k_EMsgGCClientConnectionStatus, OnConnectionStatus },
{ (uint)EGCBaseClientMsg.k_EMsgGCClientWelcome, OnWelcome },
{ (uint)EGCItemMsg.k_EMsgGCUpdateItemSchema, OnItemSchemaUpdate },
{ (uint)EGCItemMsg.k_EMsgGCClientVersionUpdated, OnVersionUpdate },
{ (uint)EGCBaseMsg.k_EMsgGCSystemMessage, OnSystemMessage },
// TF2 specific messages
{ k_EMsgGCClientGoodbye, OnConnectionStatus },
{ (uint)EGCItemMsg.k_EMsgGCGoldenWrenchBroadcast, OnWrenchBroadcast },
{ k_EMsgGCTFSpecificItemBroadcast, OnItemBroadcast },
};
SteamGameCoordinator = steamClient.GetHandler<SteamGameCoordinator>();
SessionTimer = new Timer();
SessionTimer.Interval = TimeSpan.FromSeconds(30).TotalMilliseconds;
SessionTimer.Elapsed += OnSessionTick;
SessionTimer.Start();
manager.Subscribe<SteamGameCoordinator.MessageCallback>(OnGameCoordinatorMessage);
manager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff);
manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected);
}
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 GameCoordinator(uint appID, SteamClient steamClient, CallbackManager callbackManager)
{
// Map gc messages to our callback functions
GCMessageMap = new Dictionary<uint, Action<IPacketGCMsg>>
{
{ (uint)EGCBaseClientMsg.k_EMsgGCClientWelcome, OnClientWelcome },
{ (uint)EGCItemMsg.k_EMsgGCUpdateItemSchema, OnItemSchemaUpdate },
{ (uint)EGCBaseMsg.k_EMsgGCSystemMessage, OnSystemMessage },
{ (uint)EGCBaseClientMsg.k_EMsgGCClientConnectionStatus, OnClientConnectionStatus },
{ (uint)4008 /* TF2's k_EMsgGCClientGoodbye */, OnClientConnectionStatus }
};
this.AppID = appID;
this.SteamClient = steamClient;
this.SteamGameCoordinator = SteamClient.GetHandler<SteamGameCoordinator>();
this.Name = string.Format("GC {0}", appID);
// Make sure Steam knows we're playing the game
Timer = new System.Timers.Timer();
Timer.Elapsed += OnTimerPlayGame;
Timer.Interval = TimeSpan.FromMinutes(5).TotalMilliseconds;
Timer.Start();
Timer = new System.Timers.Timer();
Timer.Elapsed += OnTimer;
callbackManager.Register(new Callback<SteamGameCoordinator.MessageCallback>(OnGameCoordinatorMessage));
}
public Bot(Configuration.BotInfo config, string apiKey, UserHandlerCreator handlerCreator, bool debug = false)
{
Username = config.Username;
Password = config.Password;
DisplayName = config.DisplayName;
ChatResponse = config.ChatResponse;
MaximumTradeTime = config.MaximumTradeTime;
MaximiumActionGap = config.MaximumActionGap;
DisplayNamePrefix = config.DisplayNamePrefix;
TradePollingInterval = config.TradePollingInterval <= 100 ? 800 : config.TradePollingInterval;
Admins = config.Admins;
this.apiKey = apiKey;
AuthCode = null;
log = new Log (config.LogFile, this);
CreateHandler = handlerCreator;
// Hacking around https
ServicePointManager.ServerCertificateValidationCallback += SteamWeb.ValidateRemoteCertificate;
log.Debug ("Initializing Steam Bot...");
SteamClient = new SteamClient();
SteamTrade = SteamClient.GetHandler<SteamTrading>();
SteamUser = SteamClient.GetHandler<SteamUser>();
SteamFriends = SteamClient.GetHandler<SteamFriends>();
log.Info ("Connecting...");
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 (TradePollingInterval);
if (CurrentTrade != null)
{
try
{
CurrentTrade.Poll ();
}
catch (Exception e)
{
log.Error ("Error Polling Trade: " + e);
}
}
}
}).Start ();
CallbackThread.Start();
log.Success ("Done Loading Bot!");
CallbackThread.Join();
}
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);
}
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 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);
}
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 ) );
}
}
public DotaClient( string userName, string password, uint matchId )
{
this.userName = userName;
this.password = password;
this.matchId = matchId;
client = new SteamClient();
// get our handlers
user = client.GetHandler<SteamUser>();
gameCoordinator = client.GetHandler<SteamGameCoordinator>();
// setup callbacks
callbackMgr = new CallbackManager( client );
new Callback<SteamClient.ConnectedCallback>( OnConnected, callbackMgr );
new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, callbackMgr );
new Callback<SteamGameCoordinator.MessageCallback>( OnGCMessage, callbackMgr );
}
