void HandleFromGC( IPacketMsg packetMsg )
{
var msg = new ClientMsgProtobuf<CMsgGCClient>( packetMsg );
var callback = new MessageCallback( msg.Body );
this.Client.PostCallback( callback );
}
/// <summary>
/// Request to see if the client user has any comment notifications
/// </summary>
public void RequestCommentNotifications()
{
var clientRequestCommentNotifications =
new ClientMsgProtobuf<CMsgClientRequestCommentNotifications>(EMsg.ClientRequestCommentNotifications);
Client.Send(clientRequestCommentNotifications);
}
void HandleWebAPINonce(IPacketMsg packetMsg)
{
var nonceMsg = new ClientMsgProtobuf<CMsgClientRequestWebAPIAuthenticateUserNonceResponse>(packetMsg);
var callback = new NonceCallback(nonceMsg.Body);
Client.PostCallback(callback);
}
private static void HandleClientRequestFreeLicenseResponse(IPacketMsg packetMsg)
{
var resp = new ClientMsgProtobuf<CMsgClientRequestFreeLicenseResponse>(packetMsg);
JobAction job;
JobManager.TryRemoveJob(packetMsg.TargetJobID, out job);
var packageIDs = resp.Body.granted_packageids;
var appIDs = resp.Body.granted_appids;
Log.WriteDebug("FreeLicense", "Received free license: {0} ({1} apps, {2} packages)", (EResult)resp.Body.eresult, appIDs.Count, packageIDs.Count);
if (packageIDs.Count > 0)
{
Steam.Instance.Apps.PICSGetProductInfo(Enumerable.Empty<uint>(), packageIDs);
if (packageIDs.Count > 5)
{
IRC.Instance.SendMain("{0}{1}{2} new free licenses granted", Colors.OLIVE, packageIDs.Count, Colors.NORMAL);
}
else
{
foreach (var package in packageIDs)
{
IRC.Instance.SendMain("New free license granted: {0}{1}{2} -{3} {4}", Colors.OLIVE, Steam.GetPackageName(package), Colors.NORMAL, Colors.DARKBLUE, SteamDB.GetPackageURL(package));
}
}
}
if (appIDs.Count > 0)
{
Steam.Instance.Apps.PICSGetAccessTokens(appIDs, Enumerable.Empty<uint>());
}
}
void HandleInitiateTradeResult(IPacketMsg packetMsg)
{
var msg = new ClientMsgProtobuf<CMsgTrading_InitiateTradeResult>(packetMsg);
var callback = new TradeRequestCallback();
callback.Response = msg.Body.response;
callback.TradeRequestId = msg.Body.trade_request_id;
callback.Other = msg.Body.other_steamid;
if (callback.Response == 0)
callback.Status = ETradeStatus.Accepted;
else if (callback.Response == 1)
callback.Status = ETradeStatus.Rejected;
else if (callback.Response == 6)
callback.Status = ETradeStatus.Unknown;
else if (callback.Response == 7)
callback.Status = ETradeStatus.Cancelled;
else if (callback.Response == 8)
callback.Status = ETradeStatus.Unknown;
else if (callback.Response == 11)
callback.Status = ETradeStatus.InTrade;
else if (callback.Response == 12)
callback.Status = ETradeStatus.Unknown2;
else if (callback.Response == 13)
callback.Status = ETradeStatus.TimedOut;
else
throw new Exception("Unknown trade status: "+callback.Status);
this.Client.PostCallback(callback);
}
void HandleResponse(IPacketMsg packetMsg)
{
var response = new ClientMsgProtobuf<CMsgClientPlayerNicknameList>(packetMsg);
var nicknames = response.Body.nicknames;
Client.PostCallback(new ClientPlayerNicknameListCallback(nicknames));
}
/// <summary>
/// Logs onto the Steam network as a persistent game server.
/// The client should already have been connected at this point.
/// Results are return in a <see cref="SteamUser.LoggedOnCallback"/>.
/// </summary>
/// <param name="details">The details to use for logging on.</param>
/// <exception cref="System.ArgumentNullException">No logon details were provided.</exception>
/// <exception cref="System.ArgumentException">Username or password are not set within <paramref name="details"/>.</exception>
public void LogOn( LogOnDetails details )
{
if ( details == null )
{
throw new ArgumentNullException( "details" );
}
if ( string.IsNullOrEmpty( details.Username ) || string.IsNullOrEmpty( details.Password ) )
{
throw new ArgumentException( "LogOn requires a username and password to be set in 'details'." );
}
var logon = new ClientMsgProtobuf<CMsgClientLogon>( EMsg.ClientLogon );
SteamID gsId = new SteamID( 0, 0, Client.ConnectedUniverse, EAccountType.GameServer );
logon.ProtoHeader.client_sessionid = 0;
logon.ProtoHeader.steamid = gsId.ConvertToUInt64();
uint localIp = NetHelpers.GetIPAddress( this.Client.LocalIP );
logon.Body.obfustucated_private_ip = localIp ^ MsgClientLogon.ObfuscationMask;
logon.Body.protocol_version = MsgClientLogon.CurrentProtocol;
logon.Body.client_os_type = ( uint )Utils.GetOSType();
logon.Body.game_server_app_id = ( int )details.AppID;
logon.Body.machine_id = Utils.GenerateMachineID();
logon.Body.account_name = details.Username;
logon.Body.password = details.Password;
this.Client.Send( logon );
}
/// <summary>
/// Accepts the new Login Key provided by a <see cref="LoginKeyCallback"/>.
/// </summary>
/// <param name="callback">The callback containing the new Login Key.</param>
public void AcceptNewLoginKey( LoginKeyCallback callback )
{
var acceptance = new ClientMsgProtobuf<CMsgClientNewLoginKeyAccepted>( EMsg.ClientNewLoginKeyAccepted );
acceptance.Body.unique_id = callback.UniqueID;
this.Client.Send( acceptance );
}
private void HandleClientCommentNotifications(IPacketMsg packetMsg)
{
var clientCommentNotifications = new ClientMsgProtobuf<CMsgClientCommentNotifications>(packetMsg);
CMsgClientCommentNotifications result = clientCommentNotifications.Body;
Client.PostCallback(new CommentNotificationCallback(result));
}
void HandleSteamLevelsResponse( IPacketMsg msg )
{
var clientMsg = new ClientMsgProtobuf<CMsgClientFSGetFriendsSteamLevelsResponse>( msg );
var callback = new SteamLevelsCallback( clientMsg.TargetJobID, clientMsg.Body );
Client.PostCallback( callback );
}
/// <summary>
/// Cancels a pending trade request.
/// </summary>
/// <param name="target">The target account you want to trade with.</param>
public void CancelPendingTrade(SteamID target)
{
var cancelTrade = new ClientMsgProtobuf<CMsgTrading_CancelTradeRequest>( EMsg.EconTrading_CancelTradeRequest );
cancelTrade.Body.other_steamid = target;
this.Client.Send(cancelTrade);
}
private void HandleClientUserNotifications(IPacketMsg packetMsg)
{
var clientUserNotificationResponse = new ClientMsgProtobuf<CMsgClientUserNotifications>(packetMsg);
CMsgClientUserNotifications result = clientUserNotificationResponse.Body;
Client.PostCallback(new NotificationCallback(result));
}
void HandleUGCDetailsResponse( IPacketMsg packetMsg )
{
var infoResponse = new ClientMsgProtobuf<CMsgClientUFSGetUGCDetailsResponse>( packetMsg );
var innerCallback = new UGCDetailsCallback( infoResponse.Body );
var callback = new SteamClient.JobCallback<UGCDetailsCallback>( infoResponse.TargetJobID, innerCallback );
this.Client.PostCallback( callback );
}
/// <summary>
/// Sends a friend request to a user.
/// </summary>
/// <param name="steamId">The SteamID of the friend to add.</param>
public void AddFriend( SteamID steamId )
{
var addFriend = new ClientMsgProtobuf<CMsgClientAddFriend>( EMsg.ClientAddFriend );
addFriend.Body.steamid_to_add = steamId;
this.Client.Send( addFriend );
}
/// <summary>
/// Proposes a trade to another client.
/// </summary>
/// <param name="user">The client to trade.</param>
public void Trade( SteamID user )
{
var tradeReq = new ClientMsgProtobuf<CMsgTrading_InitiateTradeRequest>( EMsg.EconTrading_InitiateTradeRequest );
tradeReq.Body.other_steamid = user;
Client.Send( tradeReq );
}
/// <summary>
/// Sends a friend request to a user.
/// </summary>
/// <param name="accountNameOrEmail">The account name or email of the user.</param>
public void AddFriend( string accountNameOrEmail )
{
var addFriend = new ClientMsgProtobuf<CMsgClientAddFriend>( EMsg.ClientAddFriend );
addFriend.Body.accountname_or_email_to_add = accountNameOrEmail;
this.Client.Send( addFriend );
}
/// <summary>
/// Cancels an already sent trade proposal.
/// </summary>
/// <param name="user">The user.</param>
public void CancelTrade( SteamID user )
{
var cancelTrade = new ClientMsgProtobuf<CMsgTrading_CancelTradeRequest>( EMsg.EconTrading_CancelTradeRequest );
cancelTrade.Body.other_steamid = user;
Client.Send( cancelTrade );
}
void HandleAccountDataResponse( IPacketMsg packetMsg )
{
var msg = new ClientMsgProtobuf<CMsgClientRequestAccountDataResponse>( packetMsg );
var callback = new ResponseCallback( msg.TargetJobID, msg.Body );
Client.PostCallback( callback );
}
/// <summary>
/// Responds to a trade proposal.
/// </summary>
/// <param name="tradeId">The trade id of the received proposal.</param>
/// <param name="acceptTrade">if set to <c>true</c>, the trade will be accepted.</param>
public void RespondToTrade( uint tradeId, bool acceptTrade )
{
var tradeResp = new ClientMsgProtobuf<CMsgTrading_InitiateTradeResponse>( EMsg.EconTrading_InitiateTradeResponse );
tradeResp.Body.trade_request_id = tradeId;
tradeResp.Body.response = acceptTrade ? 0u : 1u;
Client.Send( tradeResp );
}
public static void LaunchGame(ulong appid)
{
var clientMsg = new ClientMsgProtobuf<CMsgClientGamesPlayed>(EMsg.ClientGamesPlayedNoDataBlob);
clientMsg.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed
{
game_id = appid,
});
steamClient.Send(clientMsg);
}
/// <summary>
/// Handles a client message. This should not be called directly.
/// </summary>
/// <param name="packetMsg">The packet message that contains the data.</param>
public override void HandleMsg( IPacketMsg packetMsg )
{
if ( packetMsg.MsgType == EMsg.ClientFromGC )
{
var msg = new ClientMsgProtobuf<CMsgGCClient>( packetMsg );
var callback = new MessageCallback( msg.Body );
this.Client.PostCallback( callback );
}
}
/// <summary>
/// Responds to a trade request from another Steam account.
/// If the trade is accepted, a <see cref="SteamTrading.StartSessionCallback"/> will be received.
/// </summary>
/// <param name="target">The target account you want to trade with.</param>
public void RespondTradeRequest(UInt32 tradeRequestId, SteamID otherId, bool accept)
{
var responseTrade = new ClientMsgProtobuf<CMsgTrading_InitiateTradeResponse>(EMsg.EconTrading_InitiateTradeRequest);
responseTrade.Body.trade_request_id = tradeRequestId;
responseTrade.Body.other_steamid = otherId;
responseTrade.Body.response = accept ? 0u : 1u;
this.Client.Send(responseTrade);
}
/// <summary>
/// Requests a trade with another Steam account.
/// Results are returned in <see cref="SteamTrading.TradeRequestCallback"/>.
/// </summary>
/// <param name="target">The target account you want to trade with.</param>
public void RequestTrade(SteamID target)
{
var requestTrade = new ClientMsgProtobuf<CMsgTrading_InitiateTradeRequest>( EMsg.EconTrading_InitiateTradeRequest );
requestTrade.Body.trade_request_id = 0;
requestTrade.Body.other_steamid = target;
requestTrade.Body.other_name = null;
this.Client.Send(requestTrade);
}
/// <summary>
/// Sets the local user's persona state and broadcasts it over the network.
/// </summary>
/// <param name="state">The state.</param>
public void SetPersonaState( EPersonaState state )
{
cache.LocalUser.PersonaState = state;
var stateMsg = new ClientMsgProtobuf<CMsgClientChangeStatus>( EMsg.ClientChangeStatus );
stateMsg.Body.persona_state = ( uint )state;
stateMsg.Body.player_name = cache.LocalUser.Name;
this.Client.Send( stateMsg );
}
/// <summary>
/// Requests an app ownership ticket for the specified AppID.
/// Results are returned in a <see cref="AppOwnershipTicketCallback"/> callback.
/// </summary>
/// <param name="appid">The appid to request the ownership ticket of.</param>
/// <returns>The Job ID of the request. This can be used to find the appropriate <see cref="SteamClient.JobCallback<T>"/>.</returns>
public JobID GetAppOwnershipTicket( uint appid )
{
var request = new ClientMsgProtobuf<CMsgClientGetAppOwnershipTicket>( EMsg.ClientGetAppOwnershipTicket );
request.SourceJobID = Client.GetNextJobID();
request.Body.app_id = appid;
this.Client.Send( request );
return request.SourceJobID;
}
public void Send( byte[] data, uint appId )
{
var clientMsg = new ClientMsgProtobuf<CMsgGCClient>( EMsg.ClientToGC );
clientMsg.Body.msgtype = BitConverter.ToUInt32( data, 0 );
clientMsg.Body.appid = appId;
clientMsg.Body.payload = data;
this.Client.Send( clientMsg );
}
/// <summary>
/// Sets the local user's persona name and broadcasts it over the network.
/// </summary>
/// <param name="name">The name.</param>
public void SetPersonaName( string name )
{
// cache the local name right away, so that early calls to SetPersonaState don't reset the set name
cache.LocalUser.Name = name;
var stateMsg = new ClientMsgProtobuf<CMsgClientChangeStatus>( EMsg.ClientChangeStatus );
stateMsg.Body.persona_state = ( uint )cache.LocalUser.PersonaState;
stateMsg.Body.player_name = name;
this.Client.Send( stateMsg );
}
public JobID RequestLevels( IEnumerable<SteamID> steamIds )
{
var clientMsg = new ClientMsgProtobuf<CMsgClientFSGetFriendsSteamLevels>( EMsg.ClientFSGetFriendsSteamLevels );
clientMsg.SourceJobID = Client.GetNextJobID();
clientMsg.Body.accountids.AddRange( steamIds.Select( s => s.AccountID ) );
Client.Send( clientMsg );
return clientMsg.SourceJobID;
}
public void PlayGame( GameID game )
{
var clientMsg = new ClientMsgProtobuf<CMsgClientGamesPlayed>( EMsg.ClientGamesPlayedNoDataBlob );
clientMsg.Body.games_played.Add( new CMsgClientGamesPlayed.GamePlayed
{
game_id = game,
} );
Client.Send( clientMsg );
}
/// <summary>
/// Requests details for a specific item of user generated content from the Steam servers.
/// Results are returned in a <see cref="UGCDetailsCallback"/> from a <see cref="SteamClient.JobCallback<T>"/>.
/// </summary>
/// <param name="ugcId">The unique user generated content id.</param>
/// <returns>The Job ID of the request. This can be used to find the appropriate <see cref="SteamClient.JobCallback<T>"/>.</returns>
public JobID RequestUGCDetails( UGCHandle ugcId )
{
var request = new ClientMsgProtobuf<CMsgClientUFSGetUGCDetails>( EMsg.ClientUFSGetUGCDetails );
request.SourceJobID = Client.GetNextJobID();
request.Body.hcontent = ugcId;
this.Client.Send( request );
return request.SourceJobID;
}
internal string itemDropDefList(Bot bot)
{
ClientMsgProtobuf <CMsgClientGamesPlayed> response = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
string IDDL_File = @"plugins\\ASFItemDropper\\idropdeflist.txt";
string idropdeflist_txt = "";
bool fileExists = File.Exists(IDDL_File);
if (fileExists)
{
idropdeflist_txt = "\n";
idropdeflist_txt += System.IO.File.ReadAllText(IDDL_File);
}
else
{
idropdeflist_txt = "## INFO: File 'idropdeflist.txt' does not exist.";
}
return(idropdeflist_txt);
}
public async Task <PurchaseResponseCallback> RedeemKey(string _keyToActivate)
{
ClientMsgProtobuf <CMsgClientRegisterKey> registerKey = new ClientMsgProtobuf <CMsgClientRegisterKey>(EMsg.ClientRegisterKey)
{
SourceJobID = Client.GetNextJobID()
};
registerKey.Body.key = _keyToActivate;
Client.Send(registerKey);
try
{
return(await new AsyncJob <PurchaseResponseCallback>(Client, registerKey.SourceJobID));
}
catch (Exception e)
{
Console.WriteLine(e);
return(null);
}
}
public static void PlayGames(List <uint> gameIDs, string NonSteam)
{
ClientMsgProtobuf <CMsgClientGamesPlayed> request = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
if (NonSteam.ToString() != "disable")
{
request.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed
{
game_id = 12350489788975939584,
game_extra_info = NonSteam
});
}
foreach (uint gameID in gameIDs.Where(gameID => gameID != 0))
{
request.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed {
game_id = new GameID(gameID)
});
}
AccountLogin.steamClient.Send(request);
}
internal void SetCurrentMode(uint chatMode)
{
if (chatMode == 0)
{
ArchiLogger.LogNullError(nameof(chatMode));
return;
}
if (!Client.IsConnected)
{
return;
}
ClientMsgProtobuf <CMsgClientUIMode> request = new ClientMsgProtobuf <CMsgClientUIMode>(EMsg.ClientCurrentUIMode)
{
Body = { chat_mode = chatMode }
};
Client.Send(request);
}
public void OnMessage(IPacketMsg packetMsg)
{
if (packetMsg.MsgType == EMsg.ClientGetAppOwnershipTicketResponse)
{
var pb = new ClientMsgProtobuf <CMsgClientGetAppOwnershipTicketResponse>(packetMsg);
log.Debug("Got client ticket of " + pb.Body.app_id + " " + pb.Body.eresult + " " + pb.Body.ticket.Length);
if (pb.Body.eresult == (uint)EResult.OK)
{
AppOwnershipTicket = pb.Body.ticket;
}
}
else if (packetMsg.MsgType == EMsg.ClientAuthListAck)
{
var pb = new ClientMsgProtobuf <CMsgClientAuthListAck>(packetMsg);
log.Debug("Steam acked ticket crc of "
+ pb.Body.ticket_crc
+ "/"
+ pb.Body.message_sequence);
TicketForAuth = PendingTicketForAuth;
TicketForServer = AuthTicket.CreateServerTicket();
}
else if (packetMsg.MsgType == EMsg.ClientTicketAuthComplete)
{
var pb = new ClientMsgProtobuf <CMsgClientTicketAuthComplete>(packetMsg);
log.Debug("Client ticket auth complete with "
+ pb.Body.estate
+ " on "
+ pb.Body.ticket_crc);
}
else if (packetMsg.MsgType == EMsg.ClientOGSBeginSessionResponse)
{
var msg = new ClientMsg <MsgClientOGSBeginSessionResponse>(packetMsg);
if (msg.Body.Result == EResult.OK)
{
SteamworksSessionId = msg.Body.SessionId;
}
}
}
// called when the client successfully (or unsuccessfully) logs onto an account
void OnLoggedOn(SteamUser.LoggedOnCallback callback)
{
if (callback.Result != EResult.OK)
{
// logon failed (password incorrect, steamguard enabled, etc)
// an EResult of AccountLogonDenied means the account has SteamGuard enabled and an email containing the authcode was sent
// in that case, you would get the auth code from the email and provide it in the LogOnDetails
Console.WriteLine("Unable to logon to Steam: {0}", callback.Result);
gotMatch = true; // we didn't actually get the match details, but we need to jump out of the callback loop
return;
}
Console.WriteLine("Logged in! Launching DOTA...");
// 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 playGame = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
playGame.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
client.Send(playGame);
// delay a little to give steam some time to establish a GC connection to us
Thread.Sleep(5000);
// inform the dota GC that we want a session
var clientHello = new ClientGCMsgProtobuf <CMsgClientHello>(( uint )EGCBaseClientMsg.k_EMsgGCClientHello);
clientHello.Body.engine = ESourceEngine.k_ESE_Source2;
gameCoordinator.Send(clientHello, APPID);
}
void HandleLoggedOff(IPacketMsg packetMsg)
{
SessionID = null;
SteamID = null;
CellID = null;
PublicIP = null;
IPCountryCode = null;
heartBeatFunc.Stop();
if (packetMsg.IsProto)
{
var logoffMsg = new ClientMsgProtobuf <CMsgClientLoggedOff>(packetMsg);
var logoffResult = (EResult)logoffMsg.Body.eresult;
if (logoffResult == EResult.TryAnotherCM || logoffResult == EResult.ServiceUnavailable)
{
Servers.TryMark(connection.CurrentEndPoint, connection.ProtocolTypes, ServerQuality.Bad);
}
}
}
internal async Task <PurchaseResponseCallback> RedeemKey(string key)
{
if (string.IsNullOrEmpty(key) || !Client.IsConnected)
{
return(null);
}
var request = new ClientMsgProtobuf <CMsgClientRegisterKey>(EMsg.ClientRegisterKey)
{
SourceJobID = Client.GetNextJobID()
};
request.Body.key = key;
Client.Send(request);
try {
return(await new AsyncJob <PurchaseResponseCallback>(Client, request.SourceJobID));
} catch (Exception e) {
Logging.LogGenericException(e);
return(null);
}
}
/*
* __ __ _ _ _
| \/ | ___ | |_ | |__ ___ __| | ___
| |\/| | / _ \| __|| '_ \ / _ \ / _` |/ __|
| | | || __/| |_ | | | || (_) || (_| |\__ \
|_| |_| \___| \__||_| |_| \___/ \__,_||___/
|
*/
internal void PlayGame(string gameName)
{
if (!Client.IsConnected)
{
return;
}
ClientMsgProtobuf <CMsgClientGamesPlayed> request = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
if (!string.IsNullOrEmpty(gameName))
{
request.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed {
game_extra_info = gameName,
game_id = new GameID {
AppType = GameID.GameType.Shortcut,
ModID = uint.MaxValue
}
});
}
Client.Send(request);
}
private void ClientGamesPlayedWithDataBlob(uint gameFlags)
{
var changeDataBlobRequest = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayedWithDataBlob);
changeDataBlobRequest.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed
{
steam_id_gs = 0,
game_id = new GameID(CSGOClient.CSGO_APPID),
game_ip_address = 0,
game_port = 0,
is_secure = true,
game_extra_info = "",
game_data_blob = Utils.StringToByteArray("test"),
process_id = 5364,
streaming_provider_id = 0,
game_flags = gameFlags,
owner_id = Convert.ToUInt32(CSGOClient.steamId - 76561197960265728),
launch_option_type = 0,
launch_source = 0
});
changeDataBlobRequest.Body.client_os_type = 16;
}
public void Auth()
{
var pb = new CMsgAuthTicket();
pb.gameid = App;
pb.h_steam_pipe = 327684;
using (var stream = Bitstream.CreateWith(PendingTicketForAuth.ToArray())) {
pb.ticket_crc = CrcUtils.Compute32(stream);
}
pb.ticket = PendingTicketForAuth.ToArray();
var msg = new ClientMsgProtobuf <CMsgClientAuthList>(EMsg.ClientAuthList);
msg.Body.tokens_left = Bot.TokenCount;
msg.Body.app_ids.Add(App);
msg.Body.tickets.Add(pb);
msg.Body.message_sequence = AuthSequence++;
Bot.Client.Send(msg);
log.Debug("Sent auth list with crc " + msg.Body.tickets[0].ticket_crc + "/" + msg.Body.message_sequence);
}
public void SetPlayingGame(string botId, uint[] appIds, string gameName)
{
var playGameMessage = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
if (!string.IsNullOrWhiteSpace(gameName))
{
playGameMessage.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed
{
game_extra_info = gameName,
game_id = new GameID
{
AppType = GameID.GameType.Shortcut,
ModID = uint.MaxValue
}
});
}
foreach (var appId in appIds)
{
playGameMessage.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed
{
game_id = new GameID(appId)
});
}
if (botId == null)
{
if (SteamBot.BotInstances == null)
{
return;
}
foreach (var bot in SteamBot.BotInstances)
{
bot.SteamClient.Send(playGameMessage);
}
return;
}
var botInstance = SteamBot.BotInstances?.SingleOrDefault(b => b.Id == botId);
botInstance?.SteamClient.Send(playGameMessage);
}
private void HandleStoreUserStatsResponse(IPacketMsg packetMsg)
{
if (packetMsg == null)
{
ASF.ArchiLogger.LogNullError(nameof(packetMsg));
return;
}
ClientMsgProtobuf <CMsgClientStoreUserStatsResponse> response = new ClientMsgProtobuf <CMsgClientStoreUserStatsResponse>(packetMsg);
if (!Responses.TryAdd(response.Body.game_id, new StoredResponse {
Success = response.Body.eresult == 1,
Response = null //we don't care about this, just need to know that request was successful
}))
{
ASF.ArchiLogger.LogGenericError(string.Format(Strings.ErrorFailingRequest, "SetAchievements"));
}
if (response.Body.eresult != 1)
{
ASF.ArchiLogger.LogGenericError(string.Format(Strings.ErrorFailingRequest, "SetAchievements"));
}
}
private void HandleGetUserStatsResponse(IPacketMsg packetMsg)
{
if (packetMsg == null)
{
ASF.ArchiLogger.LogNullError(nameof(packetMsg));
return;
}
ClientMsgProtobuf <CMsgClientGetUserStatsResponse> response = new ClientMsgProtobuf <CMsgClientGetUserStatsResponse>(packetMsg);
if (!Responses.TryAdd(response.Body.game_id, new StoredResponse {
Success = response.Body.eresult == 1,
Response = response.Body
}))
{
ASF.ArchiLogger.LogGenericError(string.Format(Strings.ErrorFailingRequest, "GetAchievements"));
}
if (response.Body.eresult != 1)
{
ASF.ArchiLogger.LogGenericError(string.Format(Strings.ErrorFailingRequest, "GetAchievements"));
}
}
public static void LaunchClient()
{
new Callback <SteamGameCoordinator.MessageCallback>(OnGCMessage, SteamApp.manager);
var playGame = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
playGame.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed
{
game_id = new GameID(730), // or game_id = APPID,
});
// send it off
// notice here we're sending this message directly using the SteamClient
SteamApp.steamClient.Send(playGame);
Thread.Sleep(3000);
clientLaunched = true;
CSGOClientLaunchedCallback.SafeInvoke();
var clientHello = new ClientGCMsgProtobuf <CMsgClientHello>((uint)EGCBaseClientMsg.k_EMsgGCClientHello);
SteamApp.steamGameCoordinator.Send(clientHello, 730);
}
/*
* __ __ _ _ _
| \/ | ___ | |_ | |__ ___ __| | ___
| |\/| | / _ \| __|| '_ \ / _ \ / _` |/ __|
| | | || __/| |_ | | | || (_) || (_| |\__ \
|_| |_| \___| \__||_| |_| \___/ \__,_||___/
|
*/
// TODO: Remove me once https://github.com/SteamRE/SteamKit/issues/305 is fixed
internal void LogOnWithoutMachineID(SteamUser.LogOnDetails details)
{
ClientMsgProtobuf <CMsgClientLogon> logon = new ClientMsgProtobuf <CMsgClientLogon>(EMsg.ClientLogon);
SteamID steamId = new SteamID(details.AccountID, details.AccountInstance, Client.ConnectedUniverse, EAccountType.Individual);
if (details.LoginID != null)
{
logon.Body.obfustucated_private_ip = details.LoginID.Value;
}
logon.ProtoHeader.client_sessionid = 0;
logon.ProtoHeader.steamid = steamId.ConvertToUInt64();
logon.Body.account_name = details.Username;
logon.Body.password = details.Password;
logon.Body.should_remember_password = details.ShouldRememberPassword;
logon.Body.protocol_version = MsgClientLogon.CurrentProtocol;
logon.Body.client_os_type = (uint)details.ClientOSType;
logon.Body.client_language = details.ClientLanguage;
logon.Body.cell_id = details.CellID;
logon.Body.steam2_ticket_request = details.RequestSteam2Ticket;
logon.Body.client_package_version = 1771;
logon.Body.auth_code = details.AuthCode;
logon.Body.two_factor_code = details.TwoFactorCode;
logon.Body.login_key = details.LoginKey;
logon.Body.sha_sentryfile = details.SentryFileHash;
logon.Body.eresult_sentryfile = (int)(details.SentryFileHash != null ? EResult.OK : EResult.FileNotFound);
Client.Send(logon);
}
static void OnLoggedOn(SteamUser.LoggedOnCallback callback)
{
// Check to see if we've logged on successfully.
if (callback.Result != EResult.OK)
{
if (callback.Result == EResult.AccountLogonDenied)
{
// Account has Steam Guard enabled.
Console.WriteLine("Unable to logon to Steam: This account is SteamGuard protected.");
isRunning = false;
return;
}
Console.WriteLine(":: Unable to logon to Steam: {0} / {1}", callback.Result, callback.ExtendedResult);
isRunning = false;
return;
}
Console.WriteLine(":: Successfully logged on!");
// Start playing a game.
var playGame = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
// Convert application IDs to array.
int[] GameAppIDs = AppIDs.ToArray();
// Loop application IDs to add.
foreach (int AppID in GameAppIDs)
{
Console.WriteLine(":: Now playing game '{0}'!", AppID.ToString());
playGame.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed {
game_id = new GameID(AppID)
});
}
steamClient.Send(playGame);
}
public void JoinLobby(ulong _lobbyId, string _username)
{
if (inLobby())
{
LeaveLobby();
}
lobbyId = _lobbyId;
StopMatchmaking();
Testt();
var joinRequest = new ClientMsgProtobuf <CMsgClientMMSJoinLobby>(EMsg.ClientMMSJoinLobby);
joinRequest.ProtoHeader.routing_appid = CSGO_APPID;
joinRequest.Header.Proto.routing_appid = CSGO_APPID;
joinRequest.Body.app_id = CSGO_APPID;
joinRequest.Body.steam_id_lobby = _lobbyId;
joinRequest.Body.persona_name = _username;
steamClient.Send(joinRequest);
form.AddLog(string.Format("Joining lobbyId : {0} with username : {1}", _lobbyId, _username));
}
private static void OnAccountInfo(SteamUser.AccountInfoCallback callback)
{
Country = callback.Country;
var stateMsg = new ClientMsgProtobuf <CMsgClientChangeStatus>(EMsg.ClientChangeStatus)
{
Body =
{
persona_state = (uint)EPersonaState.Online,
persona_state_flags = uint.MaxValue,
player_name = Steam.Instance.Friends.GetPersonaName()
}
};
Steam.Instance.Client.Send(stateMsg);
if (Settings.IsFullRun)
{
InGameShorcut.game_extra_info = $"\u23E9 Full run: {Settings.Current.FullRun.ToString()}";
}
Sync();
}
internal void PlayGames(ICollection <uint> gameIDs)
{
if (gameIDs == null || gameIDs.Count == 0 || !Client.IsConnected)
{
return;
}
var request = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
foreach (uint gameID in gameIDs)
{
if (gameID == 0)
{
continue;
}
request.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed {
game_id = new GameID(gameID),
});
}
Client.Send(request);
}
internal void PlayGames(params uint[] gameIDs)
{
if (!Client.IsConnected)
{
return;
}
var request = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
foreach (uint gameID in gameIDs)
{
if (gameID == 0)
{
continue;
}
request.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed {
game_id = new GameID(gameID),
});
}
Client.Send(request);
}
void HandleChangesResponse(IPacketMsg packetMsg)
{
var changesResponse = new ClientMsgProtobuf <CMsgClientPICSChangesSinceResponse>(packetMsg);
if (lastChangelist == changesResponse.Body.current_change_number)
{
return;
}
lastChangelist = changesResponse.Body.current_change_number;
if (changesResponse.Body.app_changes.Count > 0 || changesResponse.Body.package_changes.Count > 0)
{
// this is dirty
// but because we live in a multiverse that consists of infinite universes
// i justify this because this method is totally acceptable in at least one of those universes
Client.GetHandler <SteamApps>().PICSGetProductInfo(
apps: changesResponse.Body.app_changes.Select(a => a.appid),
packages: changesResponse.Body.package_changes.Select(p => p.packageid),
onlyPublic: false
);
}
}
void HandleMulti(IPacketMsg packetMsg)
{
if (!packetMsg.IsProto)
{
DebugLog.WriteLine("CMClient", "HandleMulti got non-proto MsgMulti!!");
return;
}
var msgMulti = new ClientMsgProtobuf <CMsgMulti>(packetMsg);
byte[] payload = msgMulti.Body.message_body;
if (msgMulti.Body.size_unzipped > 0)
{
try
{
payload = ZipUtil.Decompress(payload);
}
catch (Exception ex)
{
DebugLog.WriteLine("CMClient", "HandleMulti encountered an exception when decompressing.\n{0}", ex.ToString());
return;
}
}
using (var ms = new MemoryStream(payload))
using (var br = new BinaryReader(ms))
{
while ((ms.Length - ms.Position) != 0)
{
int subSize = br.ReadInt32();
byte[] subData = br.ReadBytes(subSize);
OnClientMsgReceived(GetPacketMsg(subData));
}
}
}
void HandleLogOnResponse(IPacketMsg packetMsg)
{
if (!packetMsg.IsProto)
{
// a non proto ClientLogonResponse can come in as a result of connecting but never sending a ClientLogon
// in this case, it always fails, so we don't need to do anything special here
LogDebug("CMClient", "Got non-proto logon response, this is indicative of no logon attempt after connecting.");
return;
}
var logonResp = new ClientMsgProtobuf <CMsgClientLogonResponse>(packetMsg);
var logonResult = ( EResult )logonResp.Body.eresult;
if (logonResult == EResult.OK)
{
SessionID = logonResp.ProtoHeader.client_sessionid;
SteamID = logonResp.ProtoHeader.steamid;
CellID = logonResp.Body.cell_id;
PublicIP = logonResp.Body.public_ip.GetIPAddress();
IPCountryCode = logonResp.Body.ip_country_code;
int hbDelay = logonResp.Body.out_of_game_heartbeat_seconds;
// restart heartbeat
heartBeatFunc.Stop();
heartBeatFunc.Delay = TimeSpan.FromSeconds(hbDelay);
heartBeatFunc.Start();
}
else if (logonResult == EResult.TryAnotherCM || logonResult == EResult.ServiceUnavailable)
{
if (connection?.CurrentEndPoint != null)
{
Servers.TryMark(connection.CurrentEndPoint, connection.ProtocolTypes, ServerQuality.Bad);
}
}
}
internal async Task <PurchaseResponseCallback> RedeemKey(string key)
{
if (string.IsNullOrEmpty(key))
{
ArchiLogger.LogNullError(nameof(key));
return(null);
}
if (Client == null)
{
ArchiLogger.LogNullError(nameof(Client));
return(null);
}
if (!Client.IsConnected)
{
return(null);
}
ClientMsgProtobuf <CMsgClientRegisterKey> request = new ClientMsgProtobuf <CMsgClientRegisterKey>(EMsg.ClientRegisterKey)
{
SourceJobID = Client.GetNextJobID(),
Body = { key = key }
};
Client.Send(request);
try {
return(await new AsyncJob <PurchaseResponseCallback>(Client, request.SourceJobID).ToLongRunningTask().ConfigureAwait(false));
} catch (Exception e) {
ArchiLogger.LogGenericException(e);
return(null);
}
}
internal async Task <RedeemGuestPassResponseCallback> RedeemGuestPass(ulong guestPassID)
{
if (guestPassID == 0)
{
ArchiLogger.LogNullError(nameof(guestPassID));
return(null);
}
if (Client == null)
{
ArchiLogger.LogNullError(nameof(Client));
return(null);
}
if (!Client.IsConnected)
{
return(null);
}
ClientMsgProtobuf <CMsgClientRedeemGuestPass> request = new ClientMsgProtobuf <CMsgClientRedeemGuestPass>(EMsg.ClientRedeemGuestPass)
{
SourceJobID = Client.GetNextJobID(),
Body = { guest_pass_id = guestPassID }
};
Client.Send(request);
try {
return(await new AsyncJob <RedeemGuestPassResponseCallback>(Client, request.SourceJobID).ToLongRunningTask().ConfigureAwait(false));
} catch (Exception e) {
ArchiLogger.LogGenericException(e);
return(null);
}
}
void HandleLoggedOff(IPacketMsg packetMsg)
{
SessionID = null;
SteamID = null;
CellID = null;
PublicIP = null;
IPCountryCode = null;
heartBeatFunc.Stop();
if (packetMsg.IsProto)
{
var logoffMsg = new ClientMsgProtobuf <CMsgClientLoggedOff>(packetMsg);
var logoffResult = ( EResult )logoffMsg.Body.eresult;
if (logoffResult == EResult.TryAnotherCM || logoffResult == EResult.ServiceUnavailable)
{
DebugLog.Assert(connection != null, nameof(CMClient), "No connection object during ClientLoggedOff.");
DebugLog.Assert(connection.CurrentEndPoint != null, nameof(CMClient), "No connection endpoint during ClientLoggedOff - cannot update server list status");
Servers.TryMark(connection.CurrentEndPoint, connection.ProtocolTypes, ServerQuality.Bad);
}
}
}
private void OnLoggedOn(SteamUser.LoggedOnCallback callback)
{
if (callback.Result != EResult.OK)
{
if (callback.Result == EResult.AccountLogonDenied)
{
Console.WriteLine($"{username}: Unable to logon to Steam: This account is SteamGuard protected");
isRunning = false;
return;
}
Console.WriteLine($"{username}: Unable to logon to Steam: {callback.Result} / {callback.ExtendedResult}");
isRunning = false;
return;
}
Console.WriteLine("Successfully logged on!");
steamid = callback.ClientSteamID.ConvertToUInt64();
var Play = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed);
Play.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed {
game_id = new GameID(730),
});
steamClient.Send(Play);
Thread.Sleep(SLEEP);
var ClientHello = new ClientGCMsgProtobuf <CMsgClientHello>((uint)EGCBaseClientMsg.k_EMsgGCClientHello);
SteamGameCoordinator.Send(ClientHello, 730);
sw.Start();
}
private AsyncJob <SteamTicketAccepted> VerifyTicket(uint appId, MemoryStream stream, out uint crc)
{
var authTicket = stream.ToArray();
crc = BitConverter.ToUInt32(CryptoHelper.CRCHash(authTicket));
var items = _gameTickets.GetOrAdd(appId, new List <CMsgAuthTicket>());
items.Add(new CMsgAuthTicket()
{
gameid = appId,
ticket = authTicket,
ticket_crc = crc
});
var authList = new ClientMsgProtobuf <CMsgClientAuthList>(EMsg.ClientAuthList);
authList.Body.tokens_left = (uint)_gcTokens.Count;
authList.Body.app_ids.AddRange(_gameTickets.Keys);
authList.Body.tickets.AddRange(_gameTickets.Values.SelectMany(x => x));
authList.SourceJobID = Client.GetNextJobID();
Client.Send(authList);
return(new AsyncJob <SteamTicketAccepted>(Client, authList.SourceJobID));
}
void HandleLogOnResponse(IPacketMsg packetMsg)
{
if (!packetMsg.IsProto)
{
DebugLog.WriteLine("CMClient", "HandleLogOnResponse got non-proto MsgClientLogonResponse!!");
return;
}
var logonResp = new ClientMsgProtobuf <CMsgClientLogonResponse>(packetMsg);
if (logonResp.Body.eresult == ( int )EResult.OK)
{
SessionID = logonResp.ProtoHeader.client_sessionid;
SteamID = logonResp.ProtoHeader.steamid;
int hbDelay = logonResp.Body.out_of_game_heartbeat_seconds;
// restart heartbeat
heartBeatFunc.Stop();
heartBeatFunc.Delay = TimeSpan.FromSeconds(hbDelay);
heartBeatFunc.Start();
}
}
