private void GetContentHandleCallback(RPCContext context)
{
ResourcesAPIPendingState resourcesAPIPendingState = null;
if (!this.m_pendingLookups.TryGetValue(context.Header.Token, out resourcesAPIPendingState))
{
base.ApiLog.LogWarning("Received unmatched lookup response");
return;
}
this.m_pendingLookups.Remove(context.Header.Token);
bnet.protocol.ContentHandle contentHandle = bnet.protocol.ContentHandle.ParseFrom(context.Payload);
if (contentHandle == null || !contentHandle.IsInitialized)
{
base.ApiLog.LogWarning("Received invalid response");
resourcesAPIPendingState.Callback(null, resourcesAPIPendingState.UserContext);
return;
}
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
if (status != BattleNetErrors.ERROR_OK)
{
base.ApiLog.LogWarning("Battle.net Resources API C#: Failed lookup. Error={0}", new object[]
{
status
});
resourcesAPIPendingState.Callback(null, resourcesAPIPendingState.UserContext);
return;
}
ContentHandle contentHandle2 = ContentHandle.FromProtocol(contentHandle);
resourcesAPIPendingState.Callback(contentHandle2, resourcesAPIPendingState.UserContext);
}
public Error(BattleNetErrors code)
{
this = new Error()
{
EnumVal = code
};
}
public BnetErrorInfo(BnetFeature feature, BnetFeatureEvent featureEvent, BattleNetErrors error, int context)
{
this.m_feature = feature;
this.m_featureEvent = featureEvent;
this.m_error = error;
this.m_clientContext = context;
}
private void HandleLogonCompleteRequest(RPCContext context)
{
LogonResult logonResult = LogonResult.ParseFrom(context.Payload);
BattleNetErrors errorCode = (BattleNetErrors)logonResult.ErrorCode;
if (errorCode != BattleNetErrors.ERROR_OK)
{
this.m_battleNet.EnqueueErrorInfo(BnetFeature.Auth, BnetFeatureEvent.Auth_OnFinish, errorCode, 0);
return;
}
this.m_accountEntity = logonResult.Account;
this.m_battleNet.Presence.PresenceSubscribe(this.m_accountEntity);
this.m_gameAccounts = new List <bnet.protocol.EntityId>();
foreach (bnet.protocol.EntityId gameAccountList in logonResult.GameAccountList)
{
this.m_gameAccounts.Add(gameAccountList);
this.m_battleNet.Presence.PresenceSubscribe(gameAccountList);
}
if (logonResult.HasBattleTag)
{
this.m_battleTag = logonResult.BattleTag;
}
if (this.m_gameAccounts.Count > 0)
{
this.m_gameAccount = logonResult.GameAccountList[0];
}
this.m_sessionKey = logonResult.SessionKey;
this.m_battleNet.IssueSelectGameAccountRequest();
this.m_battleNet.SetConnectedRegion(logonResult.ConnectedRegion);
base.ApiLog.LogDebug("LogonComplete {0}", new object[] { logonResult });
base.ApiLog.LogDebug("Region (connected): {0}", new object[] { logonResult.ConnectedRegion });
}
private void UtilClientRequestCallback(RPCContext context)
{
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
if (status != BattleNetErrors.ERROR_OK)
{
this.m_battleNet.EnqueueErrorInfo(BnetFeature.Games, BnetFeatureEvent.Games_OnClientRequest, status, 0);
return;
}
ClientResponse clientResponse = ClientResponse.ParseFrom(context.Payload);
if (clientResponse.AttributeCount >= 2)
{
bnet.protocol.attribute.Attribute attribute = clientResponse.AttributeList[0];
bnet.protocol.attribute.Attribute attribute2 = clientResponse.AttributeList[1];
if (!attribute.Value.HasIntValue || !attribute2.Value.HasBlobValue)
{
base.ApiLog.LogError("Malformed Attribute in Util Packet: incorrect values");
}
this.m_utilPackets.Enqueue(new GamesAPI.UtilResponse(clientResponse, context.Context));
}
else
{
base.ApiLog.LogError("Malformed Attribute in Util Packet: missing values");
}
}
public void CancelGameCallback(RPCContext context)
{
BattleNetCSharp battleNetCSharp = BattleNet.Get() as BattleNetCSharp;
if (battleNetCSharp == null || battleNetCSharp.Games == null)
{
return;
}
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
battleNetCSharp.Games.ApiLog.LogDebug("CancelGameCallback, status=" + status);
if (status == BattleNetErrors.ERROR_OK || status == BattleNetErrors.ERROR_GAME_MASTER_INVALID_GAME)
{
if (battleNetCSharp.Games.IsFindGamePending || (battleNetCSharp.Games.CurrentGameRequest != 0UL && battleNetCSharp.Games.CurrentGameRequest != this.m_gameRequestId))
{
battleNetCSharp.Games.ApiLog.LogDebug("CancelGameCallback received for id={0} but is not the current gameRequest={1}, ignoring it.", new object[]
{
this.m_gameRequestId,
battleNetCSharp.Games.CurrentGameRequest
});
}
else
{
battleNetCSharp.Games.CurrentGameRequest = 0UL;
battleNetCSharp.Games.AddQueueEvent(QueueEvent.Type.QUEUE_CANCEL, 0, 0, 0, null);
}
}
else
{
battleNetCSharp.EnqueueErrorInfo(BnetFeature.Games, BnetFeatureEvent.Games_OnCancelGame, status, 0);
}
}
public void MatchMakerEndHandler(Notification notification)
{
BattleNetErrors battleNetErrors = (BattleNetErrors)ProtocolHelper.GetUintAttribute(notification.AttributeList, "error", 0UL, null);
ulong uintAttribute = ProtocolHelper.GetUintAttribute(notification.AttributeList, "game_request_id", 0UL, null);
base.ApiLog.LogDebug("MM_END requestId={0} code={1}", new object[]
{
uintAttribute,
(uint)battleNetErrors
});
QueueEvent.Type type;
if (battleNetErrors == BattleNetErrors.ERROR_OK)
{
type = QueueEvent.Type.QUEUE_LEAVE;
}
else if (battleNetErrors == BattleNetErrors.ERROR_GAME_MASTER_GAME_ENTRY_CANCELLED)
{
type = QueueEvent.Type.QUEUE_CANCEL;
}
else if (battleNetErrors == BattleNetErrors.ERROR_GAME_MASTER_GAME_ENTRY_ABORTED_CLIENT_DROPPED)
{
type = QueueEvent.Type.ABORT_CLIENT_DROPPED;
}
else
{
type = QueueEvent.Type.QUEUE_AMM_ERROR;
}
base.ApiLog.LogDebug("MatchMakerEndHandler event={0} code={1}", new object[]
{
type,
(uint)battleNetErrors
});
this.AddQueueEvent(type, 0, 0, (int)battleNetErrors, null);
}
public void MatchMakerEndHandler(bnet.protocol.notification.Notification notification)
{
BattleNetErrors errors = (BattleNetErrors)((uint)ProtocolHelper.GetUintAttribute(notification.AttributeList, "error", 0L, null));
ulong num = ProtocolHelper.GetUintAttribute(notification.AttributeList, "game_request_id", 0L, null);
object[] args = new object[] { num, (uint)errors };
base.ApiLog.LogDebug("MM_END requestId={0} code={1}", args);
BattleNet.QueueEvent.Type queueType = BattleNet.QueueEvent.Type.QUEUE_LEAVE;
switch (errors)
{
case BattleNetErrors.ERROR_OK:
queueType = BattleNet.QueueEvent.Type.QUEUE_LEAVE;
break;
case BattleNetErrors.ERROR_GAME_MASTER_GAME_ENTRY_CANCELLED:
queueType = BattleNet.QueueEvent.Type.QUEUE_CANCEL;
break;
case BattleNetErrors.ERROR_GAME_MASTER_GAME_ENTRY_ABORTED_CLIENT_DROPPED:
queueType = BattleNet.QueueEvent.Type.ABORT_CLIENT_DROPPED;
break;
default:
queueType = BattleNet.QueueEvent.Type.QUEUE_AMM_ERROR;
break;
}
object[] objArray2 = new object[] { queueType, (uint)errors };
base.ApiLog.LogDebug("MatchMakerEndHandler event={0} code={1}", objArray2);
this.AddQueueEvent(queueType, 0, 0, (int)errors, null);
}
private void GetAccountStateCallback(RPCContext context)
{
if ((context == null) || (context.Payload == null))
{
base.ApiLog.LogWarning("GetAccountLevelInfo invalid context!");
}
else
{
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
if (status != BattleNetErrors.ERROR_OK)
{
object[] args = new object[] { status.ToString() };
base.ApiLog.LogError("GetAccountLevelInfo failed with error={0}", args);
}
else
{
GetAccountStateResponse response = GetAccountStateResponse.ParseFrom(context.Payload);
if ((response == null) || !response.IsInitialized)
{
base.ApiLog.LogWarning("GetAccountStateCallback unable to parse response!");
}
else if (!response.HasState || !response.State.HasAccountLevelInfo)
{
base.ApiLog.LogWarning("GetAccountStateCallback response has no data!");
}
else
{
GetAccountStateRequest request = (GetAccountStateRequest)context.Request;
if ((request != null) && (request.EntityId == base.m_battleNet.AccountId))
{
AccountLevelInfo accountLevelInfo = response.State.AccountLevelInfo;
this.m_preferredRegion = accountLevelInfo.PreferredRegion;
this.m_accountCountry = accountLevelInfo.Country;
object[] objArray2 = new object[] { this.m_preferredRegion };
base.ApiLog.LogDebug("Region (preferred): {0}", objArray2);
object[] objArray3 = new object[] { this.m_accountCountry };
base.ApiLog.LogDebug("Country (account): {0}", objArray3);
if (accountLevelInfo.LicensesList.Count > 0)
{
this.m_licenses.Clear();
object[] objArray4 = new object[] { accountLevelInfo.LicensesList.Count };
base.ApiLog.LogDebug("Found {0} licenses.", objArray4);
for (int i = 0; i < accountLevelInfo.LicensesList.Count; i++)
{
AccountLicense item = accountLevelInfo.LicensesList[i];
this.m_licenses.Add(item);
object[] objArray5 = new object[] { item.Id };
base.ApiLog.LogDebug("Adding license id={0}", objArray5);
}
}
else
{
base.ApiLog.LogWarning("No licenses found!");
}
}
base.ApiLog.LogDebug("GetAccountLevelInfo, status=" + status.ToString());
}
}
}
}
public void CancelGameCallback(RPCContext context)
{
BattleNetCSharp sharp = BattleNet.Get() as BattleNetCSharp;
if ((sharp != null) && (sharp.Games != null))
{
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
sharp.Games.ApiLog.LogDebug("CancelGameCallback, status=" + status);
switch (status)
{
case BattleNetErrors.ERROR_OK:
case BattleNetErrors.ERROR_GAME_MASTER_INVALID_GAME:
if (sharp.Games.IsFindGamePending || ((sharp.Games.CurrentGameRequest != 0) && (sharp.Games.CurrentGameRequest != this.m_gameRequestId)))
{
object[] args = new object[] { this.m_gameRequestId, sharp.Games.CurrentGameRequest };
sharp.Games.ApiLog.LogDebug("CancelGameCallback received for id={0} but is not the current gameRequest={1}, ignoring it.", args);
}
else
{
sharp.Games.CurrentGameRequest = 0L;
sharp.Games.AddQueueEvent(BattleNet.QueueEvent.Type.QUEUE_CANCEL, 0, 0, 0, null);
}
break;
default:
sharp.EnqueueErrorInfo(BnetFeature.Games, BnetFeatureEvent.Games_OnCancelGame, status, context.Context);
break;
}
}
}
private void ClientRequestCallback(RPCContext context)
{
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
if (status != BattleNetErrors.ERROR_OK)
{
base.m_battleNet.EnqueueErrorInfo(BnetFeature.Games, BnetFeatureEvent.Games_OnClientRequest, status, context.Context);
}
else
{
ClientResponse response = ClientResponse.ParseFrom(context.Payload);
if (response.AttributeCount >= 2)
{
bnet.protocol.attribute.Attribute attribute = response.AttributeList[0];
bnet.protocol.attribute.Attribute attribute2 = response.AttributeList[1];
if (!attribute.Value.HasIntValue || !attribute2.Value.HasBlobValue)
{
base.ApiLog.LogError("Malformed Attribute in Util Packet: incorrect values");
}
int intValue = (int)attribute.Value.IntValue;
byte[] blobValue = attribute2.Value.BlobValue;
PegasusPacket item = new PegasusPacket(intValue, blobValue.Length, blobValue)
{
Context = context.Context
};
this.m_utilPackets.Enqueue(item);
}
else
{
base.ApiLog.LogError("Malformed Attribute in Util Packet: missing values");
}
}
}
public void CopyFrom(BattleNet.DllErrorInfo src)
{
this.m_feature = (BnetFeature)src.feature;
this.m_featureEvent = (BnetFeatureEvent)src.featureEvent;
this.m_error = (BattleNetErrors)src.code;
this.m_clientContext = src.context;
}
private void OnDisconnectCallback(BattleNetErrors error)
{
if (this.m_onDisconnectHandler != null)
{
this.m_onDisconnectHandler(error);
}
}
private void HandleLogonCompleteRequest(RPCContext context)
{
LogonResult result = LogonResult.ParseFrom(context.Payload);
BattleNetErrors errorCode = (BattleNetErrors)result.ErrorCode;
if (errorCode != BattleNetErrors.ERROR_OK)
{
base.m_battleNet.EnqueueErrorInfo(BnetFeature.Auth, BnetFeatureEvent.Auth_OnFinish, errorCode, context.Context);
}
else
{
this.m_accountEntity = result.Account;
base.m_battleNet.Presence.PresenceSubscribe(this.m_accountEntity);
this.m_gameAccounts = new List <EntityId>();
foreach (EntityId id in result.GameAccountList)
{
this.m_gameAccounts.Add(id);
base.m_battleNet.Presence.PresenceSubscribe(id);
}
if (this.m_gameAccounts.Count > 0)
{
this.m_gameAccount = result.GameAccountList[0];
}
base.m_battleNet.IssueSelectGameAccountRequest();
base.m_battleNet.SetConnectedRegion(result.ConnectedRegion);
object[] args = new object[] { result };
base.ApiLog.LogDebug("LogonComplete {0}", args);
object[] objArray2 = new object[] { result.ConnectedRegion };
base.ApiLog.LogDebug("Region (connected): {0}", objArray2);
BIReport.Get().Report_Telemetry(Telemetry.Level.LEVEL_INFO, BIReport.TelemetryEvent.EVENT_LOGIN_SUCCESS);
}
}
private void OnDisconnect(BattleNetErrors error)
{
if (this.ShouldHandleDisconnect() && (error == BattleNetErrors.ERROR_RPC_PEER_DISCONNECTED))
{
Network.Get().RemoveGameServerDisconnectEventListener(new Network.GameServerDisconnectEvent(this.OnDisconnect));
this.HandleDisconnect();
}
}
public bool CheckRPCCallback(string name, RPCContext context)
{
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
int index = (status != BattleNetErrors.ERROR_OK) ? 1 : 0;
object[] args = new object[] { status, !string.IsNullOrEmpty(name) ? name : "<null>", (context.Request == null) ? "<null>" : context.Request.ToString() };
this.m_logDelegates[index]("Callback invoked, status = {0}, name = {1}, request = {2}", args);
return(status == BattleNetErrors.ERROR_OK);
}
private void WhisperSentCallback(RPCContext context)
{
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
if (status != BattleNetErrors.ERROR_OK)
{
base.ApiLog.LogWarning("Battle.net Whisper API C#: Failed to SendWhisper. " + status);
this.m_battleNet.EnqueueErrorInfo(BnetFeature.Whisper, BnetFeatureEvent.Whisper_OnSend, status, context.Context);
}
}
private void SubscribeToAccountServiceCallback(RPCContext context)
{
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
if (status != BattleNetErrors.ERROR_OK)
{
base.ApiLog.LogError("SubscribeToAccountServiceCallback: " + status.ToString());
return;
}
base.ApiLog.LogDebug("SubscribeToAccountServiceCallback, status=" + status.ToString());
}
private void AddDisconnectEvent(BattleNetErrors error)
{
ClientConnection <PacketType> .ConnectionEvent connectionEvent = new ClientConnection <PacketType> .ConnectionEvent()
{
Type = ClientConnection <PacketType> .ConnectionEventTypes.OnDisconnected
};
lock (error)
{
this.m_connectionEvents.Add(connectionEvent);
}
}
public bool CheckRPCCallback(string name, RPCContext context)
{
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
BattleNetAPI.LogDelegate mLogDelegates = this.m_logDelegates[(status != BattleNetErrors.ERROR_OK ? 1 : 0)];
object[] objArray = new object[] { status, null, null };
objArray[1] = (!string.IsNullOrEmpty(name) ? name : "<null>");
objArray[2] = (context.Request == null ? "<null>" : context.Request.ToString());
mLogDelegates("Callback invoked, status = {0}, name = {1}, request = {2}", objArray);
return(status == BattleNetErrors.ERROR_OK);
}
private void TriggerOnDisconnectHandler(BattleNetErrors error)
{
SslClientConnection.ConnectionEvent connectionEvent = new SslClientConnection.ConnectionEvent()
{
Type = SslClientConnection.ConnectionEventTypes.OnDisconnected
};
lock (error)
{
this.m_connectionEvents.Add(connectionEvent);
}
}
private void AcceptInvitationCallback(RPCContext context)
{
if (this.m_state == FriendsAPIState.INITIALIZED)
{
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
if (status != BattleNetErrors.ERROR_OK)
{
base.ApiLog.LogWarning("Battle.net Friends API C#: Failed to AcceptInvitation. " + status);
base.m_battleNet.EnqueueErrorInfo(BnetFeature.Friends, BnetFeatureEvent.Friends_OnAcceptInvitation, status, context.Context);
}
}
}
private void GetAccountStateCallback(RPCContext context)
{
if (context == null || context.Payload == null)
{
base.ApiLog.LogWarning("GetAccountLevelInfo invalid context!");
return;
}
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
if (status != BattleNetErrors.ERROR_OK)
{
base.ApiLog.LogError("GetAccountLevelInfo failed with error={0}", new object[] { status.ToString() });
return;
}
GetAccountStateResponse getAccountStateResponse = GetAccountStateResponse.ParseFrom(context.Payload);
if (getAccountStateResponse == null || !getAccountStateResponse.IsInitialized)
{
base.ApiLog.LogWarning("GetAccountStateCallback unable to parse response!");
return;
}
if (!getAccountStateResponse.HasState || !getAccountStateResponse.State.HasAccountLevelInfo)
{
base.ApiLog.LogWarning("GetAccountStateCallback response has no data!");
return;
}
GetAccountStateRequest request = (GetAccountStateRequest)context.Request;
if (request != null && request.EntityId == this.m_battleNet.AccountId)
{
AccountLevelInfo accountLevelInfo = getAccountStateResponse.State.AccountLevelInfo;
this.m_preferredRegion = accountLevelInfo.PreferredRegion;
this.m_accountCountry = accountLevelInfo.Country;
base.ApiLog.LogDebug("Region (preferred): {0}", new object[] { this.m_preferredRegion });
base.ApiLog.LogDebug("Country (account): {0}", new object[] { this.m_accountCountry });
if (accountLevelInfo.LicensesList.Count <= 0)
{
base.ApiLog.LogWarning("No licenses found!");
}
else
{
this.m_licenses.Clear();
base.ApiLog.LogDebug("Found {0} licenses.", new object[] { accountLevelInfo.LicensesList.Count });
for (int i = 0; i < accountLevelInfo.LicensesList.Count; i++)
{
AccountLicense item = accountLevelInfo.LicensesList[i];
this.m_licenses.Add(item);
base.ApiLog.LogDebug("Adding license id={0}", new object[] { item.Id });
}
}
}
base.ApiLog.LogDebug(string.Concat("GetAccountLevelInfo, status=", status.ToString()));
}
private void AddConnectEvent(BattleNetErrors error, Exception exception = null)
{
ClientConnection <PacketType> .ConnectionEvent connectionEvent = new ClientConnection <PacketType> .ConnectionEvent()
{
Type = ClientConnection <PacketType> .ConnectionEventTypes.OnConnected,
Error = error
};
lock (exception)
{
this.m_connectionEvents.Add(connectionEvent);
}
}
public void OnConnectHandlerCallback(BattleNetErrors error)
{
if (error != BattleNetErrors.ERROR_OK)
{
this.SwitchToState(BattleNetCSharp.ConnectionState.Error);
this.EnqueueErrorInfo(BnetFeature.Bnet, BnetFeatureEvent.Bnet_OnConnected, error, 0);
}
foreach (BattleNetAPI battleNetAPI in this.m_apiList)
{
battleNetAPI.OnConnected(error);
}
}
private void TriggerOnDisconnectHandler(BattleNetErrors error)
{
SslClientConnection.ConnectionEvent connectionEvent = new SslClientConnection.ConnectionEvent();
connectionEvent.Type = SslClientConnection.ConnectionEventTypes.OnDisconnected;
connectionEvent.Error = error;
object connectionEvents = this.m_connectionEvents;
lock (connectionEvents)
{
this.m_connectionEvents.Add(connectionEvent);
}
}
private void GetAllValuesForAttributeCallback(RPCContext context)
{
BattleNetErrors status = (BattleNetErrors)context.Header.Status;
if (status != BattleNetErrors.ERROR_OK)
{
this.m_battleNet.EnqueueErrorInfo(BnetFeature.Games, BnetFeatureEvent.Games_OnGetAllValuesForAttribute, status, 0);
return;
}
GetAllValuesForAttributeResponse response = ProtobufUtil.ParseFrom <GetAllValuesForAttributeResponse>(context.Payload, 0, -1);
this.m_getAllValuesForAttributeResults.Enqueue(new GamesAPI.GetAllValuesForAttributeResult(response, context.Context));
}
private void AddDisconnectEvent(BattleNetErrors error)
{
ConnectionEvent <PacketType> item = new ConnectionEvent <PacketType> {
Type = ConnectionEventTypes <PacketType> .OnDisconnected,
Error = error
};
object mutex = this.m_mutex;
lock (mutex)
{
this.m_connectionEvents.Add(item);
}
}
public void QueueExitHandler(Notification notification)
{
BattleNetErrors uintAttribute = (BattleNetErrors)((uint)ProtocolHelper.GetUintAttribute(notification.AttributeList, "error", (ulong)0, null));
ulong num = ProtocolHelper.GetUintAttribute(notification.AttributeList, "game_request_id", (ulong)0, null);
base.ApiLog.LogDebug("QueueExitHandler: requestId={0} code={1}", new object[] { num, (uint)uintAttribute });
if (uintAttribute != BattleNetErrors.ERROR_OK)
{
QueueEvent.Type type = QueueEvent.Type.QUEUE_DELAY_ERROR;
base.ApiLog.LogDebug("QueueExitHandler event={0} code={1}", new object[] { type, (uint)uintAttribute });
this.AddQueueEvent(type, 0, 0, (int)uintAttribute, null);
}
}
private void AddDisconnectEvent(BattleNetErrors error)
{
ClientConnection <PacketType> .ConnectionEvent connectionEvent = new ClientConnection <PacketType> .ConnectionEvent();
connectionEvent.Type = ClientConnection <PacketType> .ConnectionEventTypes.OnDisconnected;
connectionEvent.Error = error;
object mutex = this.m_mutex;
lock (mutex)
{
this.m_connectionEvents.Add(connectionEvent);
}
}
