public PICSChanges(CallbackManager manager)
: base(manager)
{
if (Settings.IsFullRun)
{
PreviousChangeNumber = 1; // Request everything
manager.Subscribe<SteamApps.PICSChangesCallback>(OnPICSChangesFullRun);
return;
}
manager.Subscribe<SteamApps.PICSChangesCallback>(OnPICSChanges);
using (var db = Database.GetConnection())
{
BillingTypeKey = db.ExecuteScalar<uint>("SELECT `ID` FROM `KeyNamesSubs` WHERE `Name` = 'root_billingtype'");
PreviousChangeNumber = db.ExecuteScalar<uint>("SELECT `ChangeID` FROM `Changelists` ORDER BY `ChangeID` DESC LIMIT 1");
Log.WriteInfo("PICSChanges", "Previous changelist was {0}", PreviousChangeNumber);
}
if (PreviousChangeNumber == 0)
{
Log.WriteWarn("PICSChanges", "Looks like there are no changelists in the database.");
Log.WriteWarn("PICSChanges", "If you want to fill up your database first, restart with \"FullRun\" setting set to 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 Login(SteamNerd steamNerd, CallbackManager manager)
{
_steamNerd = steamNerd;
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnect);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnect);
manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.LoginKeyCallback>(OnLoginKey);
}
public Login(SteamNerd steamNerd, CallbackManager manager)
{
_steamNerd = steamNerd;
manager.Subscribe<SteamClient.ConnectedCallback>(OnConnect);
manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnect);
manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe<SteamUser.LoginKeyCallback>(OnLoginKey);
}
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("Sample3: 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
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
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 SteamBot(string login, string password)
{
var configuration = SteamConfiguration.Create(b => b.WithProtocolTypes(ProtocolTypes.Tcp).WithCellID(1));
SteamClient = new SteamClient(configuration);
Manager = new CallbackManager(SteamClient);
Chatters = new HashSet <Friend>();
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.LoggedOffCallback>(OnLoggedOff);
Manager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo);
Manager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendsList);
Manager.Subscribe <SteamFriends.PersonaStateCallback>(OnPersonaState);
Manager.Subscribe <SteamFriends.FriendAddedCallback>(OnFriendAdded);
Manager.Subscribe <SteamFriends.FriendMsgCallback>(OnFriendMsg);
_login = login;
_password = password;
IsRunning = true;
Console.WriteLine("Connecting to Steam");
SteamClient.Connect();
KeepBotAlive();
}
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 Task Run(CancellationToken cancellation = default(CancellationToken))
{
var tcs = new TaskCompletionSource <object>();
var steamThread = new Thread(() => {
CallbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
CallbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
CallbackManager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
CallbackManager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo);
CallbackManager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendsList);
CallbackManager.Subscribe <SteamFriends.PersonaStateCallback>(OnPersonaState);
CallbackManager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMessage);
Trace.WriteLine("Connecting ...", "Steam");
SteamClient.Connect();
while (!cancellation.IsCancellationRequested)
{
try
{
CallbackManager.RunWaitCallbacks();
}
catch (Exception ex)
{
Trace.WriteLine((object)ex, "Steam callback exception");
}
}
tcs.SetCanceled();
});
steamThread.Name = "Steam thread";
steamThread.Start();
return(tcs.Task);
}
public SteamApiClient()
{
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);
}
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 )
{
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)
{
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));
}
}
public void Start(string[] args)
{
DebugLog.AddListener((category, msg) => Console.WriteLine("AnonymousMethod - {0}: {1}", category, msg));
DebugLog.Enabled = false;
if (args.Length < 2)
{
Console.WriteLine("Sample1: 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>();
gameCoordinator = steamClient.GetHandler <SteamGameCoordinator>();
manager.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage);
// 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);
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 ) );
}
}
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( "Sample2: 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
manager.Subscribe<SteamClient.ConnectedCallback>( OnConnected );
manager.Subscribe<SteamClient.DisconnectedCallback>( OnDisconnected );
manager.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn );
manager.Subscribe<SteamUser.LoggedOffCallback>( OnLoggedOff );
// handle our own custom callback
manager.Subscribe<MyHandler.MyCallback>( OnMyCallback );
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("Sample2: 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
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
// handle our own custom callback
manager.Subscribe <MyHandler.MyCallback>(OnMyCallback);
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 Steam()
{
Client = new SteamClient();
User = Client.GetHandler <SteamUser>();
Apps = Client.GetHandler <SteamApps>();
CallbackManager = new CallbackManager(Client);
CallbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
CallbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
CallbackManager.Subscribe <SteamApps.PICSChangesCallback>(OnPICSChanges);
}
public SteamUserFixture(SteamUser.LogOnDetails logOnDetails)
{
this.logOnDetails = logOnDetails;
Friends = Client.GetHandler <SteamFriends>();
Matchmaking = Client.GetHandler <SteamMatchmaking>();
User = Client.GetHandler <SteamUser>();
CallbackManager = new CallbackManager(Client);
CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
}
private void CreateSteamCallbacks()
{
if (manager != null)
{
return;
}
manager = new CallbackManager(client);
disposables.Add(manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected));
disposables.Add(manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected));
disposables.Add(manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn));
disposables.Add(manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff));
}
public SteamSession()
{
Client = new SteamClient("SteamDepotBrowser");
steamUser = Client.GetHandler <SteamUser>();
steamApps = Client.GetHandler <SteamApps>();
callbacks = new CallbackManager(Client);
callbacks.Subscribe <SteamUser.LoginKeyCallback>(OnSteamLoginKey);
callbacks.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnSteamUpdateMachineAuth);
callbacks.Subscribe <SteamApps.LicenseListCallback>(OnSteamLicenseList);
Task.Run(UpdateSteamThread);
}
public Connection(CallbackManager manager)
: base(manager)
{
ReconnectionTimer = new Timer();
ReconnectionTimer.AutoReset = false;
ReconnectionTimer.Elapsed += Reconnect;
ReconnectionTimer.Interval = TimeSpan.FromSeconds(RETRY_DELAY).TotalMilliseconds;
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);
}
public BotInstance(IServiceConsumer <ISteamBotCoordinator> coordinator, ILogProvider logProvider,
BotCookieManager cookieManager, MqClientProvider mqClientProvider)
{
_coordinator = coordinator;
_logger = logProvider.Logger;
_mqClientProvider = mqClientProvider;
CookieManager = cookieManager;
_callbackManager = new CallbackManager(SteamClient);
_callbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
_callbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
_callbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
_callbackManager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnUpdateMachineAuth);
_callbackManager.Subscribe <SteamUser.LoginKeyCallback>(OnLoginKeyReceived);
_callbackManager.Subscribe <SteamFriends.PersonaStateCallback>(OnPersonaStateChanged);
_callbackManager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendListUpdated);
_callbackManager.Subscribe <SteamFriends.FriendMsgCallback>(OnFriendMessageReceived);
_steamUser = SteamClient.GetHandler <SteamUser>();
SteamFriends = SteamClient.GetHandler <SteamFriends>();
SteamApps = SteamClient.GetHandler <SteamApps>();
}
public Connection(CallbackManager manager)
: base(manager)
{
ReconnectionTimer = new Timer();
ReconnectionTimer.AutoReset = false;
ReconnectionTimer.Elapsed += Reconnect;
ReconnectionTimer.Interval = TimeSpan.FromSeconds(RETRY_DELAY).TotalMilliseconds;
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);
}
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();
}
// Registers callbacks and connects to steam client
private void ConnectToSteam()
{
steamClient = new SteamClient();
manager = new CallbackManager(steamClient);
steamUser = steamClient.GetHandler <SteamUser>();
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);
steamClient.Connect();
}
public Monitor(DatabaseRecord server, SteamConfiguration config)
{
Server = server;
Client = new SteamClient(config);
steamUser = new SteamMonitorUser();
Client.AddHandler(steamUser);
callbackMgr = new CallbackManager(Client);
callbackMgr.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
callbackMgr.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
callbackMgr.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
callbackMgr.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
}
// ReSharper disable once SuggestBaseTypeForParameter
protected SteamKitBot(ISteamKitBotSettings settings, ILogger botLogger) : base(settings, botLogger)
{
CancellationTokenSource = new CancellationTokenSource();
SteamClient = new SteamClient(
SteamConfiguration.Create(
builder =>
{
if (settings.ConnectionTimeout != null)
{
builder.WithConnectionTimeout(
TimeSpan.FromSeconds(settings.ConnectionTimeout.Value)
);
}
if (!string.IsNullOrWhiteSpace(settings.ApiKey))
{
builder.WithWebAPIKey(settings.ApiKey);
}
}
)
);
CallbackManager = new CallbackManager(SteamClient);
SteamUser = SteamClient.GetHandler <SteamUser>();
SteamFriends = SteamClient.GetHandler <SteamFriends>();
SubscribedCallbacks.Add(
CallbackManager.Subscribe <SteamClient.ConnectedCallback>(OnInternalSteamClientConnected)
);
SubscribedCallbacks.Add(
CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnInternalSteamClientDisconnect)
);
SubscribedCallbacks.Add(
CallbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnInternalSteamUserLoggedOn)
);
SubscribedCallbacks.Add(
CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnInternalSteamUserLoggedOff)
);
SubscribedCallbacks.Add(
CallbackManager.Subscribe <SteamUser.LoginKeyCallback>(OnInternalSteamUserLoginKeyExchange)
);
SubscribedCallbacks.Add(
CallbackManager.Subscribe <SteamUser.WebAPIUserNonceCallback>(OnInternalSteamUserNewWebApiUserNonce)
);
SubscribedCallbacks.Add(
CallbackManager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnInternalSteamUserUpdateMachineAuthenticationCallback)
);
SubscribedCallbacks.Add(
CallbackManager.Subscribe <SteamUser.AccountInfoCallback>(OnInternalAccountInfoAvailable)
);
SubscribedCallbacks.Add(
CallbackManager.Subscribe <SteamUser.WalletInfoCallback>(OnInternalWalletInfoAvailable)
);
}
public PICSTokens(CallbackManager manager)
: base(manager)
{
manager.Subscribe <SteamApps.PICSTokensCallback>(OnPICSTokens);
Reload();
}
public FreeLicense(CallbackManager manager)
: base(manager)
{
PackageRegex = new Regex("RemoveFreeLicense\\( ?(?<subid>[0-9]+), ?'(?<name>.+)' ?\\)", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture);
manager.Subscribe <SteamApps.FreeLicenseCallback>(OnFreeLicenseCallback);
}
public void Start()
{
//get game coordinator handler, use in game
_steamGameCoordinator = _steamClient.GetHandler <SteamGameCoordinator>();
_callbackManager.Subscribe <SteamGameCoordinator.MessageCallback>(OnGcMessage);
//tell that we are playing DOTA
var playGame = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
playGame.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed
{
game_id = new GameID(570), // or game_id = APPID,
});
_steamClient.Send(playGame);
// inform the dota GC that we want a session
var clientHello = new ClientGCMsgProtobuf <CMsgClientHello>((uint)EGCBaseClientMsg.k_EMsgGCClientHello)
{
Body =
{
engine = ESourceEngine.k_ESE_Source2,
client_session_need = 104
}
};
AddMessageHandler((uint)EGCBaseClientMsg.k_EMsgGCClientWelcome, Connected);
AddMessageHandler((uint)ESOMsg.k_ESOMsg_CacheSubscribed, OnCacheSubscribed);
AddMessageHandler((uint)ESOMsg.k_ESOMsg_UpdateMultiple, OnUpdateMultiple);
_steamGameCoordinator.Send(clientHello, 570);
_status = DotaManagerStatus.Connecting;
}
public FreeLicense(CallbackManager manager)
{
PackageRegex = new Regex("RemoveFreeLicense\\( ?(?<subid>[0-9]+), ?'(?<name>.+)' ?\\)", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture);
manager.Subscribe <SteamApps.FreeLicenseCallback>(OnFreeLicenseCallback);
FreeLicenseTimer = new Timer
{
AutoReset = false,
Interval = TimeSpan.FromMinutes(61).TotalMilliseconds
};
FreeLicenseTimer.Elapsed += OnTimer;
var db = Database.Get();
var data = db.ExecuteScalar <string>("SELECT `Value` FROM `LocalConfig` WHERE `ConfigKey` = 'backend.freelicense.requests'");
if (data != null)
{
FreeLicensesToRequest = JsonConvert.DeserializeObject <Dictionary <uint, uint> >(data);
}
if (FreeLicensesToRequest.Count == 0)
{
return;
}
Log.WriteInfo(nameof(FreeLicense), $"There are {FreeLicensesToRequest.Count} free licenses to request");
if (!Settings.IsFullRun)
{
AppsRequestedInHour = REQUEST_RATE_LIMIT;
FreeLicenseTimer.Start();
}
}
public Steam()
{
DebugLog.AddListener(new SteamKitLogger());
DebugLog.Enabled = true;
Client = new SteamClient();
User = Client.GetHandler <SteamUser>();
Apps = Client.GetHandler <SteamApps>();
CallbackManager = new CallbackManager(Client);
CallbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
CallbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
CallbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
CallbackManager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
CallbackManager.Subscribe <SteamApps.PICSChangesCallback>(OnPICSChanges);
}
public Dota2Client(string userName, string password)
{
this.userName = userName;
this.password = password;
isStartOver = false;
steamClient = new SteamClient();
// get our handlers
steamUser = steamClient.GetHandler <SteamUser>();
steamGameCoordinator = steamClient.GetHandler <SteamGameCoordinator>();
// setup callbacks
callbackMgr = new CallbackManager(steamClient);
callbackMgr.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
callbackMgr.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
callbackMgr.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
callbackMgr.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage);
}
public PICSTokens(CallbackManager manager)
: base(manager)
{
manager.Subscribe<SteamApps.PICSTokensCallback>(OnPICSTokens);
Reload();
}
public FreeLicense(CallbackManager manager)
: base(manager)
{
PackageRegex = new Regex("RemoveFreeLicense\\( ?(?<subid>[0-9]+), ?'(?<name>.+)' ?\\)", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture);
manager.Subscribe<SteamApps.FreeLicenseCallback>(OnFreeLicenseCallback);
}
private static void steamLogin()
{
// create our steamclient instance
var configuration = SteamConfiguration.Create(b => b.WithProtocolTypes(ProtocolTypes.Tcp));
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>();
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
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);
// we use the following callbacks for friends related activities
manager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo);
manager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendsList);
manager.Subscribe <SteamFriends.PersonaStateCallback>(OnPersonaState);
manager.Subscribe <SteamFriends.FriendAddedCallback>(OnFriendAdded);
manager.Subscribe <SteamFriends.FriendMsgCallback>(OnChatMessage);
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 Run(string[] args)
{
user = args[0];
pass = args[1];
steamClient = new SteamClient(System.Net.Sockets.ProtocolType.Tcp);
manager = new CallbackManager(steamClient);
steamUser = steamClient.GetHandler <SteamUser>();
steamUserStats = steamClient.GetHandler <SteamUserStats>();
manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
isRunning = true;
Console.WriteLine("Connecting to Steam...");
loggedIn = false;
SteamDirectory.Initialize().Wait();
steamClient.Connect();
while (!loggedIn)
{
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
if (!isRunning)
{
return;
}
}
uint appid = Convert.ToUInt32(args[2]);
string lbListFile = args[3];
foreach (string lbname in File.ReadLines(lbListFile))
{
if (!String.IsNullOrEmpty(lbname) && isRunning)
{
DownloadLeaderboard(appid, lbname);
}
}
}
public Dota2Client()
{
steam = new SteamClient();
user = steam.GetHandler <SteamUser>();
manager = new CallbackManager(steam);
gameCoordinator = steam.GetHandler <SteamGameCoordinator>();
manager.Subscribe <SteamClient.ConnectedCallback>(onConnect);
manager.Subscribe <SteamUser.LoggedOnCallback>(onLogon);
manager.Subscribe <SteamGameCoordinator.MessageCallback>(onMessage);
connected = false;
loggedOn = false;
welcomed = false;
receivedReplayURLs = new List <string>();
}
// 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 override Result Start()
{
Thread.CurrentThread.Name = JsonAccount.Username + " - " + (_reportInfo != null ? "Report" : "Commend");
_freeGamesHandler = new PrimitiveFreeGamesRequestHandler(OnFreeLicenseResponse);
_steamClient.AddHandler(_freeGamesHandler);
_callbacks.Subscribe <SteamClient.ConnectedCallback>(OnConnected);
_callbacks.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected);
_callbacks.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
_callbacks.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff);
_callbacks.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage);
_callbacks.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
_callbacks.Subscribe <SteamUser.LoginKeyCallback>(OnNewLoginKey);
IsRunning = true;
_steamClient.Connect();
while (IsRunning)
{
_callbacks.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(500));
}
return(Result);
}
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 DepotProcessor(SteamClient client, CallbackManager manager)
{
DepotLocks = new ConcurrentDictionary<uint, byte>();
CDNClient = new CDNClient(client);
FileDownloader.SetCDNClient(CDNClient);
CDNServers = new List<string>
{
"cdn.level3.cs.steampowered.com",
"cdn.akamai.cs.steampowered.com",
"cdn.highwinds.cs.steampowered.com"
};
manager.Subscribe<SteamApps.CDNAuthTokenCallback>(OnCDNAuthTokenCallback);
manager.Subscribe<SteamApps.DepotKeyCallback>(OnDepotKeyCallback);
}
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 );
callbackMgr.Subscribe<SteamClient.ConnectedCallback>( OnConnected );
callbackMgr.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn );
callbackMgr.Subscribe<SteamGameCoordinator.MessageCallback>( OnGCMessage );
}
static void Main( string[] args )
{
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( 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
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 friends related activities
manager.Subscribe<SteamUser.AccountInfoCallback>( OnAccountInfo );
manager.Subscribe<SteamFriends.FriendsListCallback>( OnFriendsList );
manager.Subscribe<SteamFriends.PersonaStateCallback>( OnPersonaState );
manager.Subscribe<SteamFriends.FriendAddedCallback>( OnFriendAdded );
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 ECheckResult StartSteam()
{
_steamClient = new SteamClient();
_manager = new CallbackManager(_steamClient);
_steamUser = _steamClient.GetHandler<SteamUser>();
_manager.Subscribe<SteamClient.ConnectedCallback>(OnConnected);
_manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected);
_manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn);
_manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
_isRunning = true;
_steamClient.Connect();
while (_isRunning)
_manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
if (_operation == EOperationType.CreateSentry)
Thread.Sleep(500);
_steamClient.Disconnect();
return _checkResult;
}
public UGCHandler( CallbackManager manager )
: base(manager)
{
try
{
Directory.CreateDirectory( Path.Combine( "cache", "ugc" ) );
}
catch ( IOException ex )
{
Log.WriteError( "UGCHandler", "Unable to create ugc cache directory: {0}", ex.Message );
}
manager.Subscribe<SteamUnifiedMessages.ServiceMethodResponse>( OnServiceMethod );
Steam.Instance.CallbackManager.Subscribe<SteamUser.LoggedOnCallback>( OnLoggedOn );
}
public FreeLicense(CallbackManager manager)
: base(manager)
{
manager.Subscribe<SteamApps.FreeLicenseCallback>(OnFreeLicenseCallback);
}
public void Init()
{
Client = new SteamClient();
CallbackManager = new CallbackManager( Client );
User = Client.GetHandler<SteamUser>();
Friends = Client.GetHandler<SteamFriends>();
Apps = Client.GetHandler<SteamApps>();
UserStats = Client.GetHandler<SteamUserStats>();
Cloud = Client.GetHandler<SteamCloud>();
Workshop = Client.GetHandler<SteamWorkshop>();
Unified = Client.GetHandler<SteamUnifiedMessages>();
MasterServer = Client.GetHandler<SteamMasterServer>();
GameCoordinator = Client.GetHandler<SteamGameCoordinator>();
Levels = new SteamLevels();
Games = new SteamGames();
AppInfo = new SteamAppInfo();
Account = new SteamAccount();
PublishedFiles = Unified.CreateService<IPublishedFile>();
Client.AddHandler( Levels );
Client.AddHandler( Games );
Client.AddHandler( AppInfo );
Client.AddHandler( Account );
SteamManager = new SteamManager( CallbackManager );
GCManager = new GCManager( CallbackManager );
JobManager = new JobManager( CallbackManager );
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 async Task<byte[]> DownloadReplay(ulong matchId, CancellationToken cancellationToken)
{
return await Task.Run<byte[]>(async () =>
{
CMsgDOTAMatch matchDetails = null;
// get the GC handler, which is used for messaging DOTA
var gcHandler = this.SteamClient.GetHandler<SteamGameCoordinator>();
// register a few callbacks we're interested in
var cbManager = new CallbackManager(this.SteamClient);
var sub = cbManager.Subscribe<SteamGameCoordinator.MessageCallback>((SteamGameCoordinator.MessageCallback callback) =>
{
cancellationToken.ThrowIfCancellationRequested();
if (callback.EMsg == (uint)EDOTAGCMsg.k_EMsgGCMatchDetailsResponse)
{
var msg = new ClientGCMsgProtobuf<CMsgGCMatchDetailsResponse>(callback.Message);
matchDetails = msg.Body.match;
}
});
// Send Request
var request = new ClientGCMsgProtobuf<CMsgGCMatchDetailsRequest>((uint)EDOTAGCMsg.k_EMsgGCMatchDetailsRequest);
request.Body.match_id = matchId;
gcHandler.Send(request, APPID);
while (matchDetails == null)
{
cancellationToken.ThrowIfCancellationRequested();
// in order for the callbacks to get routed, they need to be handled by the manager
cbManager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
var url = string.Format("http://replay{0}.valve.net/{1}/{2}_{3}.dem.bz2", matchDetails.cluster, APPID, matchDetails.match_id, matchDetails.replay_salt);
var webClient = new WebClient();
var compressedMatchData = await webClient.DownloadDataTaskAsync(url);
var uncompressedMatchData = CompressionFactory.BZip2.Decompress(compressedMatchData);
return uncompressedMatchData;
});
}
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));
}
}
}
void steam_connection()
{
steamClient = new SteamClient();
manager = new CallbackManager(steamClient);
steamUser = steamClient.GetHandler<SteamUser>();
manager.Subscribe<SteamClient.ConnectedCallback>(OnConnected);
manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff);
manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnect);
manager.Subscribe<SteamUnifiedMessages.ServiceMethodResponse>(OnServiceMethod);
steamClient.Connect();
while (isRunning)
{
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
}
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 SteamBot()
{
reconnectBackoff = new ExponentialBackoff();
// 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>();
steamApps = steamClient.GetHandler<SteamApps>();
steamClient.AddHandler(new CustomHandler());
// 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);
//manager.Subscribe<SteamUser.MarketingMessageCallback>(OnMarketing);
// we use the following callbacks for friends related activities
manager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo);
manager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList);
manager.Subscribe<SteamFriends.PersonaStateCallback>(OnPersonaState);
manager.Subscribe<SteamFriends.FriendAddedCallback>(OnFriendAdded);
manager.Subscribe<SteamFriends.FriendMsgCallback>(OnFriendMsg);
manager.Subscribe<SteamFriends.FriendMsgEchoCallback>(EchoMsg);
manager.Subscribe<SteamFriends.FriendMsgHistoryCallback>(ch_OnOfflineMessage2);
manager.Subscribe<SteamFriends.ChatInviteCallback>(OnChatInvite);
manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
}
public WebAuth(CallbackManager manager)
: base(manager)
{
manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe<SteamUser.WebAPIUserNonceCallback>(OnWebAPIUserNonce);
}
public PICSProductInfo(CallbackManager manager)
: base(manager)
{
manager.Subscribe<SteamApps.PICSProductInfoCallback>(OnPICSProductInfo);
}
static void Main(string[] args)
{
if (!File.Exists("chat.txt"))
{
File.Create("chat.txt").Close();
File.WriteAllText("chat.txt", "abc | 123");
}
if (!File.Exists("admin.txt"))
{
File.Create("admin.txt").Close();
File.WriteAllText("admin.txt", "Please Insert Your steamID64");
}
Console.Title = "Steam Bot Beta V0.1";
Console.WriteLine("CTRL+C To Quit.....");
Console.Write("Username: "******"Password: "******"\nConnecting To Steam....\n");
steamClient.Connect();
while (isRunning)
{
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
}
public AccountInfo(CallbackManager manager)
: base(manager)
{
manager.Subscribe<SteamUser.AccountInfoCallback>(OnAccountInfo);
}
internal Bot(string botName) {
if (string.IsNullOrEmpty(botName)) {
throw new ArgumentNullException(nameof(botName));
}
if (Bots.ContainsKey(botName)) {
throw new ArgumentException("That bot is already defined!");
}
string botPath = Path.Combine(SharedInfo.ConfigDirectory, botName);
BotName = botName;
SentryFile = botPath + ".bin";
string botConfigFile = botPath + ".json";
BotConfig = BotConfig.Load(botConfigFile);
if (BotConfig == null) {
Logging.LogGenericError("Your bot config is invalid, please verify content of " + botConfigFile + " and try again!", botName);
return;
}
// Register bot as available for ASF
if (!Bots.TryAdd(botName, this)) {
throw new ArgumentException("That bot is already defined!");
}
string botDatabaseFile = botPath + ".db";
BotDatabase = BotDatabase.Load(botDatabaseFile);
if (BotDatabase == null) {
Logging.LogGenericError("Bot database could not be loaded, refusing to create this bot instance! In order to recreate it, remove " + botDatabaseFile + " and try again!", botName);
return;
}
if (BotDatabase.MobileAuthenticator != null) {
BotDatabase.MobileAuthenticator.Init(this);
} else {
// Support and convert SDA files
string maFilePath = botPath + ".maFile";
if (File.Exists(maFilePath)) {
ImportAuthenticator(maFilePath);
}
}
// Initialize
SteamClient = new SteamClient(Program.GlobalConfig.SteamProtocol);
if (Program.GlobalConfig.Debug && Directory.Exists(SharedInfo.DebugDirectory)) {
string debugListenerPath = Path.Combine(SharedInfo.DebugDirectory, botName);
try {
Directory.CreateDirectory(debugListenerPath);
SteamClient.DebugNetworkListener = new NetHookNetworkListener(debugListenerPath);
} catch (Exception e) {
Logging.LogGenericException(e, botName);
}
}
ArchiHandler = new ArchiHandler(this);
SteamClient.AddHandler(ArchiHandler);
CallbackManager = new CallbackManager(SteamClient);
CallbackManager.Subscribe<SteamClient.ConnectedCallback>(OnConnected);
CallbackManager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected);
SteamApps = SteamClient.GetHandler<SteamApps>();
CallbackManager.Subscribe<SteamApps.FreeLicenseCallback>(OnFreeLicense);
CallbackManager.Subscribe<SteamApps.GuestPassListCallback>(OnGuestPassList);
CallbackManager.Subscribe<SteamApps.LicenseListCallback>(OnLicenseList);
SteamFriends = SteamClient.GetHandler<SteamFriends>();
CallbackManager.Subscribe<SteamFriends.ChatInviteCallback>(OnChatInvite);
CallbackManager.Subscribe<SteamFriends.ChatMsgCallback>(OnChatMsg);
CallbackManager.Subscribe<SteamFriends.FriendsListCallback>(OnFriendsList);
CallbackManager.Subscribe<SteamFriends.FriendMsgCallback>(OnFriendMsg);
CallbackManager.Subscribe<SteamFriends.FriendMsgHistoryCallback>(OnFriendMsgHistory);
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.LoginKeyCallback>(OnLoginKey);
CallbackManager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
CallbackManager.Subscribe<SteamUser.WebAPIUserNonceCallback>(OnWebAPIUserNonce);
CallbackManager.Subscribe<ArchiHandler.NotificationsCallback>(OnNotifications);
CallbackManager.Subscribe<ArchiHandler.OfflineMessageCallback>(OnOfflineMessage);
CallbackManager.Subscribe<ArchiHandler.PlayingSessionStateCallback>(OnPlayingSessionState);
CallbackManager.Subscribe<ArchiHandler.PurchaseResponseCallback>(OnPurchaseResponse);
CallbackManager.Subscribe<ArchiHandler.SharedLibraryLockStatusCallback>(OnSharedLibraryLockStatus);
ArchiWebHandler = new ArchiWebHandler(this);
CardsFarmer = new CardsFarmer(this) {
Paused = BotConfig.Paused
};
Trading = new Trading(this);
HeartBeatTimer = new Timer(
async e => await HeartBeat().ConfigureAwait(false),
null,
TimeSpan.FromMinutes(1) + TimeSpan.FromMinutes(0.2 * Bots.Count), // Delay
TimeSpan.FromMinutes(1) // Period
);
Initialize().Forget();
}
public Task<uint> Connect(bool autoReconect, CancellationToken cancellationToken)
{
return Task.Run<uint>(() => {
bool completed = false;
uint version = 0;
// get the GC handler, which is used for messaging DOTA
var gcHandler = this.SteamClient.GetHandler<SteamGameCoordinator>();
// register a few callbacks we're interested in
var cbManager = new CallbackManager(this.SteamClient);
// these are registered upon creation to a callback manager,
// which will then route the callbacks to the functions specified
cbManager.Subscribe<SteamClient.ConnectedCallback>((SteamClient.ConnectedCallback callback) => {
cancellationToken.ThrowIfCancellationRequested();
if (callback.Result == EResult.OK)
{
Trace.TraceInformation("Connected to Steam, Logging in '{0}'", this.Username);
// get the steamuser handler, which is used for logging on after successfully connecting
var UserHandler = this.SteamClient.GetHandler<SteamUser>();
UserHandler.LogOn(new SteamUser.LogOnDetails
{
Username = this.Username,
Password = this.Password,
SentryFileHash = this.Sentry,
});
}
else
{
Trace.TraceError("Unable to connect to Steam");
throw new Exception("Failed to Connect");
}
});
cbManager.Subscribe<SteamClient.DisconnectedCallback>((SteamClient.DisconnectedCallback callback) => {
cancellationToken.ThrowIfCancellationRequested();
Trace.TraceInformation("Disconnected from Steam.");
if (autoReconect)
{
// delay a little to give steam some time to finalize the DC
Thread.Sleep(TimeSpan.FromSeconds(1));
// reconect
this.SteamClient.Connect();
}
});
cbManager.Subscribe<SteamUser.LoggedOnCallback>((SteamUser.LoggedOnCallback callback) => {
cancellationToken.ThrowIfCancellationRequested();
if (callback.Result == EResult.OK)
{
Trace.TraceInformation("Successfully logged on!");
// we've logged into the account
// now we need to inform the steam server that we're playing dota (in order to receive GC messages)
// steamkit doesn't expose the "play game" message through any handler, so we'll just send the message manually
var gameMsg = new ClientMsgProtobuf<CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
gameMsg.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed
{
game_id = new GameID(APPID), // or game_id = APPID,
});
// send it off - notice here we're sending this message directly using the SteamClient
this.SteamClient.Send(gameMsg);
// delay a little to give steam some time to establish a GC connection to us
Thread.Sleep(TimeSpan.FromSeconds(1));
// inform the dota GC that we want a session
var helloMsg = new ClientGCMsgProtobuf<CMsgClientHello>((uint)EGCBaseClientMsg.k_EMsgGCClientHello);
helloMsg.Body.engine = ESourceEngine.k_ESE_Source2;
gcHandler.Send(helloMsg, APPID);
}
else if (callback.Result == EResult.AccountLogonDenied)
{
Trace.TraceInformation("Account {0}@{1} is denied.", this.Username, callback.EmailDomain);
throw new Exception(string.Format("Account {0}@{1} is denied.", this.Username, callback.EmailDomain));
}
else
{
Trace.TraceError("Failed to Login; Result {0}", callback.Result);
throw new Exception("Failed to Login.");
}
});
cbManager.Subscribe<SteamGameCoordinator.MessageCallback>((SteamGameCoordinator.MessageCallback callback) =>
{
cancellationToken.ThrowIfCancellationRequested();
if (callback.EMsg == (uint)EGCBaseClientMsg.k_EMsgGCClientWelcome)
{
var msg = new ClientGCMsgProtobuf<CMsgClientWelcome>(callback.Message);
version = msg.Body.version;
Trace.TraceInformation("GC - Welcome Message");
completed = true;
}
});
// initiate the connection
SteamClient.Connect();
while(completed == false)
{
cancellationToken.ThrowIfCancellationRequested();
// in order for the callbacks to get routed, they need to be handled by the manager
cbManager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
return version;
});
}