public override void HandleMsg(IPacketMsg packetMsg) {
if (packetMsg == null) {
ArchiLogger.LogNullError(nameof(packetMsg));
return;
}
switch (packetMsg.MsgType) {
case EMsg.ClientFSOfflineMessageNotification:
HandleFSOfflineMessageNotification(packetMsg);
break;
case EMsg.ClientItemAnnouncements:
HandleItemAnnouncements(packetMsg);
break;
case EMsg.ClientPlayingSessionState:
HandlePlayingSessionState(packetMsg);
break;
case EMsg.ClientPurchaseResponse:
HandlePurchaseResponse(packetMsg);
break;
case EMsg.ClientRedeemGuestPassResponse:
HandleRedeemGuestPassResponse(packetMsg);
break;
case EMsg.ClientSharedLibraryLockStatus:
HandleSharedLibraryLockStatus(packetMsg);
break;
case EMsg.ClientUserNotifications:
HandleUserNotifications(packetMsg);
break;
}
}
public override void HandleMsg(IPacketMsg packetMsg)
{
if (packetMsg.MsgType == EMsg.ClientRequestFreeLicenseResponse)
{
HandleClientRequestFreeLicenseResponse(packetMsg);
}
}
void HandleNumberOfPlayersResponse( IPacketMsg packetMsg )
{
var msg = new ClientMsg<MsgClientGetNumberOfCurrentPlayersResponse>( packetMsg );
var callback = new NumberOfPlayersCallback( msg.Header.TargetJobID, msg.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 HandleFromGC( IPacketMsg packetMsg )
{
var msg = new ClientMsgProtobuf<CMsgGCClient>( packetMsg );
var callback = new MessageCallback( msg.Body );
this.Client.PostCallback( callback );
}
void HandleResponse(IPacketMsg packetMsg)
{
var response = new ClientMsgProtobuf<CMsgClientPlayerNicknameList>(packetMsg);
var nicknames = response.Body.nicknames;
Client.PostCallback(new ClientPlayerNicknameListCallback(nicknames));
}
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 HandleWebAPINonce(IPacketMsg packetMsg)
{
var nonceMsg = new ClientMsgProtobuf<CMsgClientRequestWebAPIAuthenticateUserNonceResponse>(packetMsg);
var callback = new NonceCallback(nonceMsg.Body);
Client.PostCallback(callback);
}
void HandleSteamLevelsResponse( IPacketMsg msg )
{
var clientMsg = new ClientMsgProtobuf<CMsgClientFSGetFriendsSteamLevelsResponse>( msg );
var callback = new SteamLevelsCallback( clientMsg.TargetJobID, clientMsg.Body );
Client.PostCallback( callback );
}
void HandleAccountDataResponse( IPacketMsg packetMsg )
{
var msg = new ClientMsgProtobuf<CMsgClientRequestAccountDataResponse>( packetMsg );
var callback = new ResponseCallback( msg.TargetJobID, msg.Body );
Client.PostCallback( callback );
}
private void HandleClientCommentNotifications(IPacketMsg packetMsg)
{
var clientCommentNotifications = new ClientMsgProtobuf<CMsgClientCommentNotifications>(packetMsg);
CMsgClientCommentNotifications result = clientCommentNotifications.Body;
Client.PostCallback(new CommentNotificationCallback(result));
}
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>
/// Handles a client message. This should not be called directly.
/// </summary>
/// <param name="packetMsg">The <see cref="SteamKit2.IPacketMsg"/> instance containing the event data.</param>
public override void HandleMsg( IPacketMsg packetMsg )
{
switch ( packetMsg.MsgType )
{
case EMsg.ClientGetNumberOfCurrentPlayersResponse:
HandleNumberOfPlayersResponse( packetMsg );
break;
}
}
public override void HandleMsg(IPacketMsg packetMsg)
{
switch (packetMsg.MsgType)
{
case EMsg.ClientPlayerNicknameList:
HandleResponse(packetMsg);
break;
}
}
/// <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 )
{
switch ( packetMsg.MsgType )
{
case EMsg.ClientUFSGetUGCDetailsResponse:
HandleUGCDetailsResponse( packetMsg );
break;
}
}
/// <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 )
{
switch ( packetMsg.MsgType )
{
case EMsg.GMSClientServerQueryResponse:
HandleServerQueryResponse( packetMsg );
break;
}
}
public override void HandleMsg( IPacketMsg packetMsg )
{
switch ( packetMsg.MsgType )
{
case EMsg.ClientRequestAccountDataResponse:
HandleAccountDataResponse( packetMsg );
break;
}
}
public override void HandleMsg( IPacketMsg packetMsg )
{
switch ( packetMsg.MsgType )
{
case EMsg.ClientFSGetFriendsSteamLevelsResponse:
HandleSteamLevelsResponse( packetMsg );
break;
}
}
public override void HandleMsg( IPacketMsg packetMsg )
{
switch ( packetMsg.MsgType )
{
case EMsg.ClientGameConnectTokens:
HandleGameConnectTokens( packetMsg );
break;
}
}
public override void HandleMsg(IPacketMsg packetMsg)
{
switch (packetMsg.MsgType)
{
case EMsg.ClientRequestWebAPIAuthenticateUserNonceResponse:
HandleWebAPINonce(packetMsg);
break;
}
}
/// <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 );
}
}
private void HandlePlayingSessionState(IPacketMsg packetMsg)
{
if (packetMsg == null)
{
//Logging.LogNullError(nameof(packetMsg), Bot.BotName);
return;
}
ClientMsgProtobuf<CMsgClientPlayingSessionState> response = new ClientMsgProtobuf<CMsgClientPlayingSessionState>(packetMsg);
Client.PostCallback(new PlayingSessionStateCallback(packetMsg.TargetJobID, response.Body));
}
void HandleNumberOfPlayersResponse( IPacketMsg packetMsg )
{
var msg = new ClientMsg<MsgClientGetNumberOfCurrentPlayersResponse>( packetMsg );
#if STATIC_CALLBACKS
var innerCallback = new NumberOfPlayersCallback( Client, msg.Body );
var callback = new SteamClient.JobCallback<NumberOfPlayersCallback>( Client, msg.Header.TargetJobID, innerCallback );
SteamClient.PostCallback( callback );
#else
var innerCallback = new NumberOfPlayersCallback( msg.Body );
var callback = new SteamClient.JobCallback<NumberOfPlayersCallback>( msg.Header.TargetJobID, innerCallback );
Client.PostCallback( callback );
#endif
}
public override sealed void HandleMsg(IPacketMsg packetMsg)
{
if (packetMsg != null) {
switch (packetMsg.MsgType) {
case EMsg.ClientPurchaseResponse:
HandlePurchaseResponse(packetMsg);
break;
case EMsg.ClientUserNotifications:
HandleUserNotifications(packetMsg);
break;
}
}
}
/// <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 )
{
Action<IPacketMsg> handlerFunc;
bool haveFunc = dispatchMap.TryGetValue( packetMsg.MsgType, out handlerFunc );
if ( !haveFunc )
{
// ignore messages that we don't have a handler function for
return;
}
handlerFunc( packetMsg );
}
/// <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 )
{
switch ( packetMsg.MsgType )
{
case EMsg.ClientUFSGetUGCDetailsResponse:
HandleUGCDetailsResponse( packetMsg );
break;
case EMsg.ClientUFSGetSingleFileInfoResponse:
HandleSingleFileInfoResponse( packetMsg );
break;
case EMsg.ClientUFSShareFileResponse:
HandleShareFileResponse( packetMsg );
break;
}
}
/// <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)
{
switch (packetMsg.MsgType)
{
case EMsg.EconTrading_InitiateTradeProposed:
HandleInitiateTradeProposed(packetMsg);
break;
case EMsg.EconTrading_InitiateTradeResult:
HandleInitiateTradeResult(packetMsg);
break;
case EMsg.EconTrading_StartSession:
HandleStartSession(packetMsg);
break;
}
}
public override void HandleMsg(IPacketMsg packetMsg)
{
if (packetMsg == null)
{
//Logging.LogNullError(nameof(packetMsg), Bot.BotName);
return;
}
switch (packetMsg.MsgType)
{
case EMsg.ClientPlayingSessionState:
HandlePlayingSessionState(packetMsg);
break;
}
}
/// <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 );
#if STATIC_CALLBACKS
var callback = new MessageCallback( Client, msg.Body );
SteamClient.PostCallback( callback );
#else
var callback = new MessageCallback( msg.Body );
this.Client.PostCallback( callback );
#endif
}
}
public override void HandleMsg(IPacketMsg packetMsg)
{
switch (packetMsg.MsgType)
{
case EMsg.ClientNewLoginKey:
HandleClientNewLoginKey(packetMsg);
break;
case EMsg.ClientUserNotifications:
HandleClientUserNotifications(packetMsg);
break;
case EMsg.ClientCommentNotifications:
HandleClientCommentNotifications(packetMsg);
break;
}
}
void HandleLoggedOff(IPacketMsg packetMsg)
{
EResult result = EResult.Invalid;
if (packetMsg.IsProto)
{
var loggedOff = new ClientMsgProtobuf <CMsgClientLoggedOff>(packetMsg);
result = ( EResult )loggedOff.Body.eresult;
}
else
{
var loggedOff = new ClientMsg <MsgClientLoggedOff>(packetMsg);
result = loggedOff.Body.Result;
}
this.Client.PostCallback(new LoggedOffCallback(result));
}
void HandleLogOnResponse(IPacketMsg packetMsg)
{
if (packetMsg.IsProto)
{
var logonResp = new ClientMsgProtobuf <CMsgClientLogonResponse>(packetMsg);
var callback = new LoggedOnCallback(logonResp.Body);
this.Client.PostCallback(callback);
}
else
{
var logonResp = new ClientMsg <MsgClientLogOnResponse>(packetMsg);
var callback = new LoggedOnCallback(logonResp.Body);
this.Client.PostCallback(callback);
}
}
public override void HandleMsg(IPacketMsg msg)
{
if (Callbacks.ContainsKey(msg.MsgType))
{
var callbacks = Callbacks[msg.MsgType];
foreach (var callback in callbacks)
{
callback(this, msg);
//callbacks.Remove(callback);
}
}
if (msg.MsgType == EMsg.ClientMMSJoinLobbyResponse)
{
LastLobbyJoinTime = DateTime.Now;
}
}
/// <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 == null)
{
throw new ArgumentNullException(nameof(packetMsg));
}
bool haveFunc = dispatchMap.TryGetValue(packetMsg.MsgType, out var handlerFunc);
if (!haveFunc)
{
// ignore messages that we don't have a handler function for
return;
}
handlerFunc(packetMsg);
}
public override void HandleMsg(IPacketMsg msg)
{
if (msg.MsgType != EMsg.ClientPurchaseResponse)
{
return;
}
CMsgClientPurchaseResponse resp = new ClientMsgProtobuf <CMsgClientPurchaseResponse>(msg).Body;
EResult result = (EResult)resp.eresult;
if (result != EResult.OK)
{
onKeyRedeem((EPurchaseResultDetail)resp.purchase_result_details, null);
Program.Context.Log("Redemption failed: " + (EPurchaseResultDetail)resp.purchase_result_details);
}
else
{
KeyValue receipt = new KeyValue();
using (MemoryStream stream = new MemoryStream(resp.purchase_receipt_info)) {
if (!receipt.TryReadAsBinary(stream))
{
Program.Context.Log("Could not process key response for some reason. Did Valve change something?");
}
}
string itemName = "No items added to account.";
if (receipt["lineitems"].Children.Count > 0)
{
List <string> items = new List <string>();
foreach (KeyValue item in receipt["lineitems"].Children)
{
items.Add(item["ItemDescription"].Value + " (" + item["PackageID"].AsUnsignedInteger() + ")");
}
itemName = string.Join(",", items);
}
Program.Context.Log((EPurchaseResultDetail)resp.purchase_result_details + ": " + itemName);
onKeyRedeem((EPurchaseResultDetail)resp.purchase_result_details, itemName);
}
}
void HandleServerList(IPacketMsg packetMsg)
{
var listMsg = new ClientMsgProtobuf <CMsgClientServerList>(packetMsg);
foreach (var server in listMsg.Body.servers)
{
EServerType type = ( EServerType )server.server_type;
List <IPEndPoint> endpointList;
if (!serverMap.TryGetValue(type, out endpointList))
{
serverMap[type] = endpointList = new List <IPEndPoint>();
}
endpointList.Add(new IPEndPoint(NetHelpers.GetIPAddress(server.server_ip), ( int )server.server_port));
}
}
void HandleLeaveLobbyResponse(IPacketMsg packetMsg)
{
var leaveLobbyResponse = new ClientMsgProtobuf <CMsgClientMMSLeaveLobbyResponse>(packetMsg);
var body = leaveLobbyResponse.Body;
if (body.eresult == ( int )EResult.OK)
{
lobbyCache.ClearLobbyMembers(body.app_id, body.steam_id_lobby);
}
Client.PostCallback(new LeaveLobbyCallback(
leaveLobbyResponse.TargetJobID,
body.app_id,
( EResult )body.eresult,
body.steam_id_lobby
));
}
/// <summary>
/// Called when a client message is received from the network.
/// </summary>
/// <param name="packetMsg">The packet message.</param>
protected virtual void OnClientMsgReceived(IPacketMsg packetMsg)
{
if (packetMsg == null)
{
DebugLog.WriteLine("CMClient", "Packet message failed to parse, shutting down connection");
Disconnect();
return;
}
DebugLog.WriteLine("CMClient", "<- Recv'd EMsg: {0} ({1}) (Proto: {2})", packetMsg.MsgType, ( int )packetMsg.MsgType, packetMsg.IsProto);
switch (packetMsg.MsgType)
{
case EMsg.ChannelEncryptRequest:
HandleEncryptRequest(packetMsg);
break;
case EMsg.ChannelEncryptResult:
HandleEncryptResult(packetMsg);
break;
case EMsg.Multi:
HandleMulti(packetMsg);
break;
case EMsg.ClientLogOnResponse: // we handle this to get the SteamID/SessionID and to setup heartbeating
HandleLogOnResponse(packetMsg);
break;
case EMsg.ClientLoggedOff: // to stop heartbeating when we get logged off
HandleLoggedOff(packetMsg);
break;
case EMsg.ClientServerList: // Steam server list
HandleServerList(packetMsg);
break;
case EMsg.ClientCMList:
HandleCMList(packetMsg);
break;
case EMsg.ClientSessionToken: // am session token
HandleSessionToken(packetMsg);
break;
}
}
/// <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)
{
switch (packetMsg.MsgType)
{
case EMsg.EconTrading_InitiateTradeProposed:
HandleTradeProposed(packetMsg);
break;
case EMsg.EconTrading_InitiateTradeResult:
HandleTradeResult(packetMsg);
break;
case EMsg.EconTrading_StartSession:
HandleStartSession(packetMsg);
break;
}
}
void HandleMulti(IPacketMsg packetMsg)
{
if (!packetMsg.IsProto)
{
LogDebug("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
{
using (var compressedStream = new MemoryStream(payload))
using (var gzipStream = new GZipStream(compressedStream, CompressionMode.Decompress))
using (var decompressedStream = new MemoryStream())
{
gzipStream.CopyTo(decompressedStream);
payload = decompressedStream.ToArray();
}
}
catch (Exception ex)
{
LogDebug("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);
if (!OnClientMsgReceived(GetPacketMsg(subData, this)))
{
break;
}
}
}
}
void HandleServiceMethodResponse(IPacketMsg packetMsg)
{
CallbackMsg callback = null;
var jobId = packetMsg.TargetJobID;
if (_clientFileDownloadJobs.Contains(jobId))
{
lock (_clientFileDownloadJobs)
{
_clientFileDownloadJobs.Remove(jobId);
}
var shareResponse = new ClientMsgProtobuf <CCloud_ClientFileDownload_Response>(packetMsg);
callback = new ClientFileDownloadCallback(shareResponse.TargetJobID, shareResponse.Body);
}
else if (_clientBeginFileUploadJobs.Contains(jobId))
{
lock (_clientBeginFileUploadJobs)
{
_clientBeginFileUploadJobs.Remove(jobId);
}
var shareResponse = new ClientMsgProtobuf <CCloud_ClientBeginFileUpload_Response>(packetMsg);
callback = new ClientBeginFileUploadCallback(shareResponse.TargetJobID, shareResponse.Body);
}
else if (_clientCommitFileJobs.Contains(jobId))
{
lock (_clientCommitFileJobs)
{
_clientCommitFileJobs.Remove(jobId);
}
var shareResponse = new ClientMsgProtobuf <CCloud_ClientCommitFileUpload_Response>(packetMsg);
callback = new ClientCommitFileUploadCallback(shareResponse.TargetJobID, shareResponse.Body);
}
if (callback != null)
{
Client.PostCallback(callback);
}
}
/// <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)
{
switch (packetMsg.MsgType)
{
case EMsg.ClientPersonaState:
HandlePersonaState(packetMsg);
break;
case EMsg.ClientFriendsList:
HandleFriendsList(packetMsg);
break;
case EMsg.ClientFriendMsgIncoming:
HandleFriendMsg(packetMsg);
break;
case EMsg.ClientAccountInfo:
HandleAccountInfo(packetMsg);
break;
case EMsg.ClientAddFriendResponse:
HandleFriendResponse(packetMsg);
break;
case EMsg.ClientChatEnter:
HandleChatEnter(packetMsg);
break;
case EMsg.ClientChatMsg:
HandleChatMsg(packetMsg);
break;
case EMsg.ClientChatMemberInfo:
HandleChatMemberInfo(packetMsg);
break;
case EMsg.ClientChatActionResult:
HandleChatActionResult(packetMsg);
break;
case EMsg.ClientChatInvite:
HandleChatInvite(packetMsg);
break;
}
}
void HandleEncryptResult( IPacketMsg packetMsg )
{
var result = new Msg<MsgChannelEncryptResult>( packetMsg );
log.LogDebug( nameof(EnvelopeEncryptedConnection), "Encryption result: {0}", result.Body.Result );
DebugLog.Assert( encryption != null, nameof( EnvelopeEncryptedConnection ), "Encryption is null" );
if ( result.Body.Result == EResult.OK && encryption != null )
{
state = EncryptionState.Encrypted;
Connected?.Invoke( this, EventArgs.Empty );
}
else
{
log.LogDebug( nameof(EnvelopeEncryptedConnection), "Encryption channel setup failed" );
Disconnect( userInitiated: false );
}
}
void HandleLoginKey(IPacketMsg packetMsg)
{
var loginKey = new ClientMsgProtobuf <CMsgClientNewLoginKey>(packetMsg);
var resp = new ClientMsgProtobuf <CMsgClientNewLoginKeyAccepted>(EMsg.ClientNewLoginKeyAccepted);
resp.Body.unique_id = loginKey.Body.unique_id;
this.Client.Send(resp);
#if STATIC_CALLBACKS
var callback = new LoginKeyCallback(Client, loginKey.Body);
SteamClient.PostCallback(callback);
#else
var callback = new LoginKeyCallback(loginKey.Body);
this.Client.PostCallback(callback);
#endif
}
public override void HandleMsg(IPacketMsg packetMsg)
{
if (packetMsg.MsgType != EMsg.ClientItemAnnouncements)
{
return;
}
var response = new ClientMsgProtobuf <CMsgClientItemAnnouncements>(packetMsg);
if (response.Body.count_new_items == 0)
{
return;
}
Log.WriteInfo("ClientItemAnnouncements", $"New items: {response.Body.count_new_items}");
TaskManager.RunAsync(async() => await AccountInfo.RefreshAppsToIdle());
}
private void OnMessage(IPacketMsg packetMsg)
{
Client.OnMessage(packetMsg);
if (packetMsg.MsgType == EMsg.ClientPlayingSessionState)
{
var pb = new ClientMsgProtobuf <CMsgClientPlayingSessionState>(packetMsg);
if (pb.Body.playing_app == 0)
{
Machine.Trigger(Event.PLAYING_STATE_CLOSED);
}
else
{
Machine.Trigger(Event.PLAYING_STATE_OPENED);
}
}
else if (packetMsg.MsgType == EMsg.ClientGetAppOwnershipTicketResponse)
{
var pb = new ClientMsgProtobuf <CMsgClientGetAppOwnershipTicketResponse>(packetMsg);
if (pb.Body.eresult != (uint)EResult.OK)
{
throw new NotImplementedException("Unable to get app ticket");
}
Machine.Trigger(Event.GOT_APP_TICKET);
}
else if (packetMsg.MsgType == EMsg.ClientAuthListAck)
{
Machine.Trigger(Event.GOT_AUTH);
}
else if (packetMsg.MsgType == EMsg.ClientOGSBeginSessionResponse)
{
var msg = new ClientMsg <MsgClientOGSBeginSessionResponse>(packetMsg);
if (msg.Body.Result != EResult.OK)
{
throw new NotImplementedException("OGSBeginSession not OK");
}
Machine.Trigger(Event.GOT_SESSION);
}
}
public override void HandleMsg(IPacketMsg packetMsg)
{
if (packetMsg != null)
{
LastPacket = DateTime.Now;
switch (packetMsg.MsgType)
{
case EMsg.ClientSharedLibraryLockStatus:
// TODO: Handle CS:GO shared over family sharing (It doesn't work for report botting!)
break;
}
_log.Debug("Recv'd msg: {msg} Content: {@content}", packetMsg, packetMsg);
return;
}
_log.Error("Received null package: {package}", nameof(packetMsg));
}
/// <summary>
/// Called when a client message is received from the network.
/// </summary>
/// <param name="packetMsg">The packet message.</param>
protected override bool OnClientMsgReceived(IPacketMsg packetMsg)
{
// let the underlying CMClient handle this message first
if (!base.OnClientMsgReceived(packetMsg))
{
return(false);
}
bool haveFunc = dispatchMap.TryGetValue(packetMsg.MsgType, out var handlerFunc);
if (haveFunc)
{
// we want to handle some of the clientmsgs before we pass them along to registered handlers
handlerFunc(packetMsg);
}
// pass along the clientmsg to all registered handlers
foreach (DictionaryEntry kvp in handlers)
{
var key = (Type)kvp.Key;
var value = (ClientMsgHandler)kvp.Value;
try
{
value.HandleMsg(packetMsg);
}
catch (ProtoException ex)
{
DebugLog.WriteLine("SteamClient", "'{0}' handler failed to (de)serialize a protobuf: '{1}'", key.Name, ex.Message);
Disconnect();
return(false);
}
catch (Exception ex)
{
DebugLog.WriteLine("SteamClient", "Unhandled '{0}' exception from '{1}' handler: '{2}'", ex.GetType().Name, key.Name, ex.Message);
Disconnect();
return(false);
}
}
return(true);
}
void HandleLoggedOff(IPacketMsg packetMsg)
{
SessionID = null;
SteamID = null;
CellID = 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, ServerQuality.Bad);
}
}
}
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;
callback.Status = (EEconTradeResponse)callback.Response;
var WebLogin = Client.GetHandler <SteamWeb>().Login;
if (callback.Status == EEconTradeResponse.Accepted)
{
callback.Trade = new TradeSession(Client.SteamID, callback.Other, WebLogin);
}
this.Client.PostCallback(callback);
}
void HandleEncryptResult(IPacketMsg packetMsg)
{
var encResult = new Msg <MsgChannelEncryptResult>(packetMsg);
DebugLog.WriteLine("UFSClient", "Encryption result: {0}", encResult.Body.Result);
if (encResult.Body.Result == EResult.OK && pendingNetFilterEncryption != null)
{
Debug.Assert(pendingNetFilterEncryption != null);
connection.SetNetEncryptionFilter(pendingNetFilterEncryption);
pendingNetFilterEncryption = null;
steamClient.PostCallback(new ConnectedCallback(encResult.Body));
}
else
{
DebugLog.WriteLine("UFSClient", "Encryption channel setup failed");
connection.Disconnect();
}
}
public override void HandleMsg(IPacketMsg packetMsg)
{
var handler = Client.GetHandler <SteamUnifiedMessages>();
if (packetMsg == null)
{
ASF.ArchiLogger.LogNullError(nameof(packetMsg));
return;
}
switch (packetMsg.MsgType)
{
case EMsg.ClientGetUserStatsResponse:
break;
case EMsg.ClientStoreUserStatsResponse:
break;
}
}
void HandleJoinLobbyResponse(IPacketMsg packetMsg)
{
var joinLobbyResponse = new ClientMsgProtobuf <CMsgClientMMSJoinLobbyResponse>(packetMsg);
var body = joinLobbyResponse.Body;
Lobby joinedLobby = null;
if (body.steam_id_lobbySpecified)
{
var members =
body.members.ConvertAll(member => new Lobby.Member(
member.steam_id,
member.persona_name,
Lobby.DecodeMetadata(member.metadata)
));
var cachedLobby = lobbyCache.GetLobby(body.app_id, body.steam_id_lobby);
joinedLobby = new Lobby(
body.steam_id_lobby,
( ELobbyType )body.lobby_type,
body.lobby_flags,
body.steam_id_owner,
Lobby.DecodeMetadata(body.metadata),
body.max_members,
members.Count,
members,
cachedLobby?.Distance,
cachedLobby?.Weight
);
lobbyCache.CacheLobby(body.app_id, joinedLobby);
}
Client.PostCallback(new JoinLobbyCallback(
joinLobbyResponse.TargetJobID,
body.app_id,
( EChatRoomEnterResponse )body.chat_room_enter_response,
joinedLobby
));
}
public override void HandleMsg(IPacketMsg packetMsg)
{
if (packetMsg == null)
{
ArchiLogger.LogNullError(nameof(packetMsg));
return;
}
LastPacketReceived = DateTime.UtcNow;
switch (packetMsg.MsgType)
{
case EMsg.ClientItemAnnouncements:
HandleItemAnnouncements(packetMsg);
break;
case EMsg.ClientPlayingSessionState:
HandlePlayingSessionState(packetMsg);
break;
case EMsg.ClientPurchaseResponse:
HandlePurchaseResponse(packetMsg);
break;
case EMsg.ClientRedeemGuestPassResponse:
HandleRedeemGuestPassResponse(packetMsg);
break;
case EMsg.ClientSharedLibraryLockStatus:
HandleSharedLibraryLockStatus(packetMsg);
break;
case EMsg.ClientUserNotifications:
HandleUserNotifications(packetMsg);
break;
case EMsg.ClientVanityURLChangedNotification:
HandleVanityURLChangedNotification(packetMsg);
break;
}
}
/// <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)
{
switch (packetMsg.MsgType)
{
case EMsg.ClientLogOnResponse:
HandleLogOnResponse(packetMsg);
break;
case EMsg.ClientNewLoginKey:
HandleLoginKey(packetMsg);
break;
case EMsg.ClientSessionToken:
HandleSessionToken(packetMsg);
break;
case EMsg.ClientLoggedOff:
HandleLoggedOff(packetMsg);
break;
case EMsg.ClientUpdateMachineAuth:
HandleUpdateMachineAuth(packetMsg);
break;
case EMsg.ClientAccountInfo:
HandleAccountInfo(packetMsg);
break;
case EMsg.ClientWalletInfoUpdate:
HandleWalletInfo(packetMsg);
break;
case EMsg.ClientRequestWebAPIAuthenticateUserNonceResponse:
HandleWebAPIUserNonce(packetMsg);
break;
case EMsg.ClientMarketingMessageUpdate2:
HandleMarketingMessageUpdate(packetMsg);
break;
}
}
/// <summary>
/// Called when a client message is received from the network.
/// </summary>
/// <param name="packetMsg">The packet message.</param>
protected override void OnClientMsgReceived(IPacketMsg packetMsg)
{
// let the underlying CMClient handle this message first
base.OnClientMsgReceived(packetMsg);
if (packetMsg == null)
{
// bail if the packet failed to parse. CMClient will handle this
return;
}
Action <IPacketMsg> handlerFunc;
bool haveFunc = dispatchMap.TryGetValue(packetMsg.MsgType, out handlerFunc);
if (haveFunc)
{
// we want to handle some of the clientmsgs before we pass them along to registered handlers
handlerFunc(packetMsg);
}
// pass along the clientmsg to all registered handlers
foreach (var kvp in handlers)
{
try
{
kvp.Value.HandleMsg(packetMsg);
}
catch (ProtoException ex)
{
DebugLog.WriteLine("SteamClient", "'{0}' handler failed to (de)serialize a protobuf: '{1}'", kvp.Key.Name, ex.Message);
Disconnect();
return;
}
catch (Exception ex)
{
DebugLog.WriteLine("SteamClient", "Unhandled '{0}' exception from '{1}' handler: '{2}'", ex.GetType().Name, kvp.Key.Name, ex.Message);
Disconnect();
return;
}
}
}
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(
Bot.Client.SteamID, TicketForAuth, AppOwnershipTicket);
}
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;
}
}
}
void HandleLoggedOff(IPacketMsg packetMsg)
{
EResult result = EResult.Invalid;
if (packetMsg.IsProto)
{
var loggedOff = new ClientMsgProtobuf <CMsgClientLoggedOff>(packetMsg);
result = ( EResult )loggedOff.Body.eresult;
}
else
{
var loggedOff = new ClientMsg <MsgClientLoggedOff>(packetMsg);
result = loggedOff.Body.Result;
}
#if STATIC_CALLBACKS
SteamClient.PostCallback(new LoggedOffCallback(Client, result));
#else
this.Client.PostCallback(new LoggedOffCallback(result));
#endif
}
/// <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)
{
switch (packetMsg.MsgType)
{
case EMsg.CREEnumeratePublishedFilesResponse:
HandleEnumPublishedFiles(packetMsg);
break;
case EMsg.ClientUCMEnumerateUserPublishedFilesResponse:
HandleEnumUserPublishedFiles(packetMsg);
break;
case EMsg.ClientUCMEnumerateUserSubscribedFilesResponse:
HandleEnumUserSubscribedFiles(packetMsg);
break;
case EMsg.ClientUCMEnumeratePublishedFilesByUserActionResponse:
HandleEnumPublishedFilesByAction(packetMsg);
break;
}
}
