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 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 );
}
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 PICSTokens(CallbackManager manager)
: base(manager)
{
manager.Register(new Callback<SteamApps.PICSTokensCallback>(OnPICSTokens));
Reload();
}
public PICSChanges(CallbackManager manager)
: base(manager)
{
if (Settings.IsFullRun)
{
PreviousChangeNumber = 1; // Request everything
manager.Register(new Callback<SteamApps.PICSChangesCallback>(OnPICSChangesFullRun));
return;
}
manager.Register(new Callback<SteamApps.PICSChangesCallback>(OnPICSChanges));
using (MySqlDataReader Reader = DbWorker.ExecuteReader("SELECT `ChangeID` FROM `Changelists` ORDER BY `ChangeID` DESC LIMIT 1"))
{
if (Reader.Read())
{
PreviousChangeNumber = Reader.GetUInt32("ChangeID");
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.");
}
}
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 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 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 PICSTokens(CallbackManager manager)
: base(manager)
{
manager.Subscribe<SteamApps.PICSTokensCallback>(OnPICSTokens);
Reload();
}
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 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 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;
}
static void Main( string[] args )
{
if ( args.Length < 2 )
{
Console.WriteLine( "SendMessage: No username and password specified!" );
return;
}
// exit gracefully if possible
Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e) {
e.Cancel = true;
isRunning = false;
};
var url = "http://localhost:3131";
var host = new NancyHost(new Uri(url));
host.Start();
Console.WriteLine ("Server now running on: " + url);
// save our logon details
user = args[ 0 ];
pass = args[ 1 ];
manager = new CallbackManager( Steam3.SteamClient );
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 );
new Callback<SteamFriends.FriendMsgCallback>( OnMsgReceived, manager );
isRunning = true;
Console.WriteLine( "Connecting to Steam..." );
// initiate the connection
Steam3.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 ) );
}
Console.WriteLine( "Disconnecting from Steam..." );
Steam3.SteamUser.LogOff();
Steam3.SteamClient.Disconnect();
host.Stop();
host.Stop();
}
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( "Sample4: No username and password specified!" );
return;
}
// save our logon details
user = args[ 0 ];
pass = args[ 1 ];
// create our steamclient instance
steamClient = new SteamClient();
// create the callback manager which will route callbacks to function calls
manager = new CallbackManager( steamClient );
// get the steamuser handler, which is used for logging on after successfully connecting
steamUser = steamClient.GetHandler<SteamUser>();
// register a few callbacks we're interested in
// these are registered upon creation to a callback manager, which will then route the callbacks
// to the functions specified
new Callback<SteamClient.ConnectedCallback>( OnConnected, manager );
new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager );
new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager );
new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager );
isRunning = true;
Console.WriteLine( "Connecting to Steam..." );
// initiate the connection
steamClient.Connect();
// create our callback handling loop
while ( isRunning )
{
// in order for the callbacks to get routed, they need to be handled by the manager
manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) );
}
}
static void Main(string[] args) {
// Print program information.
Console.WriteLine("SteamIdler, 'run' games without steam.\n(C) No STEAMGUARD Support");
// Check for username and password arguments from stdin.
if (args.Length < 3) {
// Print usage and quit.
Console.WriteLine("usage: <username> <password> <appID> [...]");
return;
}
// Set username and password from stdin.
Username = args[0];
Password = args[1];
// Add all game application IDs to list.
foreach (string GameAppID in args) {
int AppID;
if (int.TryParse(GameAppID, out AppID)) {
AppIDs.Add(Convert.ToInt32(GameAppID));
}
}
// Create SteamClient interface and CallbackManager.
steamClient = new SteamClient(System.Net.Sockets.ProtocolType.Tcp);
manager = new CallbackManager(steamClient);
// Get the steamuser handler, which is used for logging on after successfully connecting.
steamUser = steamClient.GetHandler<SteamUser>();
// Get the steam friends handler, which is used for interacting with friends on the network after logging on.
steamFriends = steamClient.GetHandler<SteamFriends>();
// Register Steam callbacks.
new Callback<SteamClient.ConnectedCallback>(OnConnected, manager);
new Callback<SteamClient.DisconnectedCallback>(OnDisconnected, manager);
new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn, manager);
new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff, manager);
new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo, manager);
// Set the program as running.
Console.WriteLine(":: Connecting to Steam..");
isRunning = true;
// Connect to Steam.
steamClient.Connect();
// Create our callback handling loop.
while (isRunning) {
// In order for the callbacks to get routed, they need to be handled by the manager.
manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
}
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( "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( "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 ) );
}
}
public Steam3Session( SteamUser.LogOnDetails details )
{
this.logonDetails = details;
this.authenticatedUser = details.Username != null;
this.credentials = new Credentials();
this.bConnected = false;
this.bConnecting = false;
this.bAborted = false;
this.seq = 0;
this.AppTickets = new Dictionary<uint, byte[]>();
this.AppTokens = new Dictionary<uint, ulong>();
this.DepotKeys = new Dictionary<uint, byte[]>();
this.CDNAuthTokens = new Dictionary<Tuple<uint, string>, SteamApps.CDNAuthTokenCallback>();
this.AppInfo = new Dictionary<uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>();
this.PackageInfo = new Dictionary<uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>();
this.steamClient = new SteamClient();
this.steamUser = this.steamClient.GetHandler<SteamUser>();
this.steamApps = this.steamClient.GetHandler<SteamApps>();
this.callbacks = new CallbackManager(this.steamClient);
this.callbacks.Subscribe<SteamClient.ConnectedCallback>(ConnectedCallback);
this.callbacks.Subscribe<SteamClient.DisconnectedCallback>(DisconnectedCallback);
this.callbacks.Subscribe<SteamUser.LoggedOnCallback>(LogOnCallback);
this.callbacks.Subscribe<SteamUser.SessionTokenCallback>(SessionTokenCallback);
this.callbacks.Subscribe<SteamApps.LicenseListCallback>(LicenseListCallback);
this.callbacks.Subscribe<SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback);
Console.Write( "Connecting to Steam3..." );
if ( authenticatedUser )
{
FileInfo fi = new FileInfo(String.Format("{0}.sentryFile", logonDetails.Username));
if (ConfigStore.TheConfig.SentryData != null && ConfigStore.TheConfig.SentryData.ContainsKey(logonDetails.Username))
{
logonDetails.SentryFileHash = Util.SHAHash(ConfigStore.TheConfig.SentryData[logonDetails.Username]);
}
else if (fi.Exists && fi.Length > 0)
{
var sentryData = File.ReadAllBytes(fi.FullName);
logonDetails.SentryFileHash = Util.SHAHash(sentryData);
ConfigStore.TheConfig.SentryData[logonDetails.Username] = sentryData;
ConfigStore.Save();
}
}
Connect();
}
static void Main( string[] args )
{
if ( args.Length < 2 )
{
Console.WriteLine( "Sample3: No username and password specified!" );
return;
}
// save our logon details
user = args[ 0 ];
pass = args[ 1 ];
// create our steamclient instance
steamClient = new SteamClient();
// add our custom handler to our steamclient
steamClient.AddHandler( new MyHandler() );
// create the callback manager which will route callbacks to function calls
manager = new CallbackManager( steamClient );
// get the steamuser handler, which is used for logging on after successfully connecting
steamUser = steamClient.GetHandler<SteamUser>();
// now get an instance of our custom handler
myHandler = steamClient.GetHandler<MyHandler>();
// register a few callbacks we're interested in
// these are registered upon creation to a callback manager, which will then route the callbacks
// to the functions specified
new Callback<SteamClient.ConnectedCallback>( OnConnected, manager );
new Callback<SteamClient.DisconnectedCallback>( OnDisconnected, manager );
new Callback<SteamUser.LoggedOnCallback>( OnLoggedOn, manager );
new Callback<SteamUser.LoggedOffCallback>( OnLoggedOff, manager );
// handle our own custom callback
new Callback<MyHandler.MyCallback>( OnMyCallback, manager );
isRunning = true;
Console.WriteLine( "Connecting to Steam..." );
// initiate the connection
steamClient.Connect();
// create our callback handling loop
while ( isRunning )
{
// in order for the callbacks to get routed, they need to be handled by the manager
manager.RunWaitCallbacks( TimeSpan.FromSeconds( 1 ) );
}
}
static void Main( string[] args )
{
if ( args.Length < 2 )
{
Console.WriteLine( "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 ) );
}
}
public void Init()
{
FacebookLogger.Instance = new FacebookTestLogger();
Type type = this.GetType();
var callbackManager = new CallbackManager();
if (Attribute.GetCustomAttribute(type, typeof(AndroidTestAttribute)) != null)
{
var mockWrapper = new MockAndroid();
Constants.CurrentPlatform = FacebookUnityPlatform.Android;
var facebook = new AndroidFacebook(mockWrapper, callbackManager);
this.Mock = mockWrapper;
this.Mock.Facebook = facebook;
FB.FacebookImpl = facebook;
}
else if (Attribute.GetCustomAttribute(type, typeof(IOSTestAttribute)) != null)
{
var mockWrapper = new MockIOS();
Constants.CurrentPlatform = FacebookUnityPlatform.IOS;
var facebook = new IOSFacebook(mockWrapper, callbackManager);
this.Mock = mockWrapper;
this.Mock.Facebook = facebook;
FB.FacebookImpl = facebook;
}
else if (Attribute.GetCustomAttribute(type, typeof(CanvasTestAttribute)) != null)
{
var mockWrapper = new MockCanvas();
Constants.CurrentPlatform = FacebookUnityPlatform.WebGL;
var facebook = new CanvasFacebook(mockWrapper, callbackManager);
this.Mock = mockWrapper;
this.Mock.Facebook = facebook;
FB.FacebookImpl = facebook;
}
else if (Attribute.GetCustomAttribute(type, typeof(EditorTestAttribute)) != null)
{
var mockWrapper = new MockEditor();
// The editor works for all platforms but claim to be android for testing.
Constants.CurrentPlatform = FacebookUnityPlatform.Android;
var facebook = new EditorFacebook(mockWrapper, callbackManager);
this.Mock = mockWrapper;
this.Mock.Facebook = facebook;
FB.FacebookImpl = facebook;
}
else
{
throw new Exception("Failed to specify platform specified on test class");
}
this.OnInit();
}
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 static void Main()
{
Log.WriteInfo("Program", "Starting...");
Console.CancelKeyPress += delegate
{
Log.WriteInfo("Program", "Exiting...");
try
{
Client.Disconnect();
}
catch
{
Log.WriteError("Steam", "Failed to disconnect from Steam");
}
IsRunning = false;
};
TwitterToken = new Token(
ConfigurationManager.AppSettings["token_AccessToken"],
ConfigurationManager.AppSettings["token_AccessTokenSecret"],
ConfigurationManager.AppSettings["token_ConsumerKey"],
ConfigurationManager.AppSettings["token_ConsumerSecret"]
);
ITokenRateLimits tokenLimits = TwitterToken.GetRateLimit();
Log.WriteInfo("Twitter", "Remaining Twitter requests: {0} of {1}", tokenLimits.ApplicationRateLimitStatusLimit.Remaining, tokenLimits.ApplicationRateLimitStatusLimit.Limit);
Timer.Elapsed += OnTimer;
Timer.Interval = TimeSpan.FromMinutes(10).TotalMilliseconds;
var CallbackManager = new CallbackManager(Client);
CallbackManager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected));
CallbackManager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected));
CallbackManager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn));
CallbackManager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff));
CallbackManager.Register(new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo));
CallbackManager.Register(new Callback<SteamFriends.ClanStateCallback>(OnClanState));
Client.Connect();
while (IsRunning)
{
CallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(5));
}
}
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 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 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 Connection(CallbackManager manager)
: base(manager)
{
SentryFile = Path.Combine(Application.Path, "files", ".support", "sentry.bin");
ReconnectionTimer = new Timer();
ReconnectionTimer.AutoReset = false;
ReconnectionTimer.Elapsed += Reconnect;
ReconnectionTimer.Interval = TimeSpan.FromSeconds(RETRY_DELAY).TotalMilliseconds;
manager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected));
manager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected));
manager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn));
manager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff));
manager.Register(new Callback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth));
}
public SteamManager( CallbackManager manager )
{
handlers = new List<SteamHandler>();
var handlerTypes = Assembly.GetExecutingAssembly().GetTypes()
.Where( t => t.IsSubclassOf( typeof( SteamHandler ) ) );
foreach ( var type in handlerTypes )
{
var handler = Activator.CreateInstance( type, manager ) as SteamHandler;
Log.WriteDebug( "SteamManager", "Registering handler {0}", type );
handlers.Add( handler );
}
}
public void OnGetPayloadComplete(ResultContainer resultContainer)
{
var result = new PayloadResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public void OnRefreshCurrentAccessTokenComplete(ResultContainer resultContainer)
{
var result = new AccessTokenRefreshResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public EditorFacebook(IEditorWrapper wrapper, CallbackManager callbackManager) : base(callbackManager)
{
this.editorWrapper = wrapper;
}
public void OnUploadVideoToMediaLibraryComplete(ResultContainer resultContainer)
{
var result = new MediaUploadResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public void OnGetCatalogComplete(ResultContainer resultContainer)
{
var result = new CatalogResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public void OnGetPurchasesComplete(ResultContainer resultContainer)
{
var result = new PurchasesResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public CanvasFacebook(ICanvasJSWrapper canvasJSWrapper, CallbackManager callbackManager)
: base(callbackManager)
{
this.canvasJSWrapper = canvasJSWrapper;
}
public AndroidFacebook(IAndroidWrapper androidWrapper, CallbackManager callbackManager)
: base(callbackManager)
{
this.KeyHash = string.Empty;
this.androidWrapper = androidWrapper;
}
void editor_ControlsCreated(object sender, EventArgs e)
{
var editor = (ASPxGridListEditor)sender;
editor.ControlsCreated -= editor_ControlsCreated;
editor.Grid.ClientSideEvents.Init = string.Format(
CultureInfo.InvariantCulture,
"function(s,e) {{s.selectedRowCount = s.GetSelectedKeysOnPage().length; s.SelectionChanged.AddHandler(function() {{if (s.selectedRowCount != s.GetSelectedKeysOnPage().length) {{s.selectedRowCount = s.GetSelectedKeysOnPage().length; {0} }}; s.firstSelectionChangedAfterInit = false;}}); }}", CallbackManager.GetScript(GetType().Name, "'RefreshCallback'"));
}
public WebAuth(CallbackManager manager)
: base(manager)
{
manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn);
manager.Subscribe <SteamUser.WebAPIUserNonceCallback>(OnWebAPIUserNonce);
}
public AndroidFacebook(IAndroidJavaClass facebookJavaClass, CallbackManager callbackManager)
: base(callbackManager)
{
this.KeyHash = string.Empty;
this.facebookJava = facebookJavaClass;
}
public Steam3Session(SteamUser.LogOnDetails details)
{
this.logonDetails = details;
this.authenticatedUser = details.Username != null;
this.credentials = new Credentials();
this.bConnected = false;
this.bConnecting = false;
this.bAborted = false;
this.bExpectingDisconnectRemote = false;
this.bDidDisconnect = false;
this.bDidReceiveLoginKey = false;
this.seq = 0;
this.AppTickets = new Dictionary <uint, byte[]>();
this.AppTokens = new Dictionary <uint, ulong>();
this.PackageTokens = new Dictionary <uint, ulong>();
this.DepotKeys = new Dictionary <uint, byte[]>();
this.CDNAuthTokens = new ConcurrentDictionary <string, TaskCompletionSource <SteamApps.CDNAuthTokenCallback> >();
this.AppInfo = new Dictionary <uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>();
this.PackageInfo = new Dictionary <uint, SteamApps.PICSProductInfoCallback.PICSProductInfo>();
this.AppBetaPasswords = new Dictionary <string, byte[]>();
this.steamClient = new SteamClient();
this.steamUser = this.steamClient.GetHandler <SteamUser>();
this.steamApps = this.steamClient.GetHandler <SteamApps>();
var steamUnifiedMessages = this.steamClient.GetHandler <SteamUnifiedMessages>();
this.steamPublishedFile = steamUnifiedMessages.CreateService <IPublishedFile>();
this.callbacks = new CallbackManager(this.steamClient);
this.callbacks.Subscribe <SteamClient.ConnectedCallback>(ConnectedCallback);
this.callbacks.Subscribe <SteamClient.DisconnectedCallback>(DisconnectedCallback);
this.callbacks.Subscribe <SteamUser.LoggedOnCallback>(LogOnCallback);
this.callbacks.Subscribe <SteamUser.SessionTokenCallback>(SessionTokenCallback);
this.callbacks.Subscribe <SteamApps.LicenseListCallback>(LicenseListCallback);
this.callbacks.Subscribe <SteamUser.UpdateMachineAuthCallback>(UpdateMachineAuthCallback);
this.callbacks.Subscribe <SteamUser.LoginKeyCallback>(LoginKeyCallback);
Console.Write("Connecting to Steam3...");
if (authenticatedUser)
{
FileInfo fi = new FileInfo(String.Format("{0}.sentryFile", logonDetails.Username));
if (AccountSettingsStore.Instance.SentryData != null && AccountSettingsStore.Instance.SentryData.ContainsKey(logonDetails.Username))
{
logonDetails.SentryFileHash = Util.SHAHash(AccountSettingsStore.Instance.SentryData[logonDetails.Username]);
}
else if (fi.Exists && fi.Length > 0)
{
var sentryData = File.ReadAllBytes(fi.FullName);
logonDetails.SentryFileHash = Util.SHAHash(sentryData);
AccountSettingsStore.Instance.SentryData[logonDetails.Username] = sentryData;
AccountSettingsStore.Save();
}
}
Connect();
}
public CallbackManagerFacts_LegacyBehavior()
{
client = new SteamClient();
mgr = new CallbackManager(client);
}
public void OnShowInterstitialAdComplete(ResultContainer resultContainer)
{
var result = new InterstitialAdResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public void OnConsumePurchaseComplete(ResultContainer resultContainer)
{
var result = new ConsumePurchaseResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public void OnScheduleAppToUserNotificationComplete(ResultContainer resultContainer)
{
var result = new ScheduleAppToUserNotificationResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public PlayerCountHandler(CallbackManager manager)
: base(manager)
{
}
public void OnFetchDeferredAppLinkComplete(ResultContainer resultContainer)
{
var result = new AppLinkResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public void OnOnIAPReadyComplete(ResultContainer resultContainer)
{
var result = new IAPReadyResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public void OnAppInviteComplete(string message)
{
var result = new AppInviteResult(message);
CallbackManager.OnFacebookResponse(result);
}
public void OnFetchDeferredAppLinkComplete(string message)
{
var result = new AppLinkResult(message);
CallbackManager.OnFacebookResponse(result);
}
public void OnInitCloudGameComplete(ResultContainer resultContainer)
{
var result = new InitCloudGameResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public void OnFriendFinderComplete(ResultContainer resultContainer)
{
var result = new GamingServicesFriendFinderResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public override void OnAppRequestsComplete(ResultContainer resultContainer)
{
var result = new AppRequestResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public override void OnAppRequestsComplete(string message)
{
var result = new AppRequestResult(message);
CallbackManager.OnFacebookResponse(result);
}
public void OnShowRewardedVideoComplete(ResultContainer resultContainer)
{
var result = new RewardedVideoResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
public override void OnGroupJoinComplete(string message)
{
var result = new GroupJoinResult(message);
CallbackManager.OnFacebookResponse(result);
}
public override void OnShareLinkComplete(string message)
{
var result = new ShareResult(message);
CallbackManager.OnFacebookResponse(result);
}
public AndroidFacebook(IAndroidJavaClass fbJavaClass, CallbackManager callbackManager)
: base(callbackManager)
{
this.KeyHash = "";
this.fbJava = fbJavaClass;
}
public override void OnShareLinkComplete(ResultContainer resultContainer)
{
var result = new ShareResult(resultContainer);
CallbackManager.OnFacebookResponse(result);
}
