OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1889 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: 131d26f1cd
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '131d26f1cd'
${ noResults }
CWE-ou-minkata/Sources/Plasma/PubUtilLib/plNetGameLib/Private/plNglAuth.cpp

6203 lines
176 KiB
Raw Blame History

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
/*****************************************************************************
*
* $/Plasma20/Sources/Plasma/PubUtilLib/plNetGameLib/Private/plNglAuth.cpp
*
***/
#include "../Pch.h"
#pragma hdrstop
#include "pnEncryption/plChallengeHash.h"
#include "plVault/plVaultConstants.h"
namespace Ngl { namespace Auth {
/*****************************************************************************
*
* Private
*
***/
struct CliAuConn : hsRefCnt {
CliAuConn ();
~CliAuConn ();
// Reconnection
AsyncTimer * reconnectTimer;
unsigned reconnectStartMs;
// Ping
AsyncTimer * pingTimer;
unsigned pingSendTimeMs;
unsigned lastHeardTimeMs;
// This function should be called during object construction
// to initiate connection attempts to the remote host whenever
// the socket is disconnected.
void AutoReconnect ();
bool AutoReconnectEnabled ();
void StopAutoReconnect (); // call before destruction
void StartAutoReconnect ();
void TimerReconnect ();
// ping
void AutoPing ();
void StopAutoPing ();
void TimerPing ();
void Send (const uintptr_t fields[], unsigned count);
CCritSect critsect;
LINK(CliAuConn) link;
AsyncSocket sock;
NetCli * cli;
plString name;
plNetAddress addr;
plUUID token;
unsigned seq;
unsigned serverChallenge;
AsyncCancelId cancelId;
bool abandoned;
};
//============================================================================
// PingRequestTrans
//============================================================================
struct PingRequestTrans : NetAuthTrans {
FNetCliAuthPingRequestCallback m_callback;
void * m_param;
unsigned m_pingAtMs;
unsigned m_replyAtMs;
ARRAY(uint8_t) m_payload;
PingRequestTrans (
FNetCliAuthPingRequestCallback callback,
void * param,
unsigned pingAtMs,
unsigned payloadBytes,
const void * payload
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// AccountExistsRequestTrans
//============================================================================
struct AccountExistsRequestTrans : NetAuthTrans {
FNetCliAuthAccountExistsRequestCallback m_callback;
void * m_param;
// send
wchar_t m_accountName[kMaxAccountNameLength];
// recv
uint8_t m_exists;
AccountExistsRequestTrans (
FNetCliAuthAccountExistsRequestCallback callback,
void * param,
const wchar_t accountName[]
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// LoginRequestTrans
//============================================================================
struct LoginRequestTrans : NetAuthTrans {
FNetCliAuthLoginRequestCallback m_callback;
void * m_param;
plUUID m_accountId;
unsigned m_accountFlags;
unsigned m_billingType;
unsigned m_playerCount;
NetCliAuthPlayerInfo m_players[kMaxPlayersPerAccount];
LoginRequestTrans (
FNetCliAuthLoginRequestCallback callback,
void * param
);
void AddPlayer (
unsigned playerInt,
const wchar_t playerName[],
const wchar_t avatarShape[],
unsigned explorer
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// AgeRequestTrans
//============================================================================
struct AgeRequestTrans : NetAuthTrans {
FNetCliAuthAgeRequestCallback m_callback;
void * m_param;
plString m_ageName;
unsigned m_ageMcpId;
plUUID m_ageInstId;
unsigned m_ageVaultId;
uint32_t m_gameSrvNode;
AgeRequestTrans (
const plString& ageName,
const plUUID& ageInstId,
FNetCliAuthAgeRequestCallback callback,
void * param
);
~AgeRequestTrans ();
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// AccountCreateRequestTrans
//============================================================================
struct AccountCreateRequestTrans : NetAuthTrans {
FNetCliAuthAccountCreateRequestCallback m_callback;
void * m_param;
// send
wchar_t m_accountName[kMaxAccountNameLength];
ShaDigest m_namePassHash;
unsigned m_accountFlags;
unsigned m_billingType;
// recv
plUUID m_accountId;
AccountCreateRequestTrans (
const wchar_t accountName[],
const wchar_t password[],
unsigned accountFlags,
unsigned billingType,
FNetCliAuthAccountCreateRequestCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// AccountCreateFromKeyRequestTrans
//============================================================================
struct AccountCreateFromKeyRequestTrans : NetAuthTrans {
FNetCliAuthAccountCreateFromKeyRequestCallback m_callback;
void * m_param;
// send
wchar_t m_accountName[kMaxAccountNameLength];
ShaDigest m_namePassHash;
plUUID m_key;
unsigned m_billingType;
// recv
plUUID m_accountId;
plUUID m_activationKey;
AccountCreateFromKeyRequestTrans(
const wchar_t accountName[],
const wchar_t password[],
const plUUID& key,
unsigned billingType,
FNetCliAuthAccountCreateFromKeyRequestCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// PlayerCreateRequestTrans
//============================================================================
struct PlayerCreateRequestTrans : NetAuthTrans {
FNetCliAuthPlayerCreateRequestCallback m_callback;
void * m_param;
// send
plString m_playerName;
plString m_avatarShape;
plString m_friendInvite;
// recv
NetCliAuthPlayerInfo m_playerInfo;
PlayerCreateRequestTrans (
const plString& playerName,
const plString& avatarShape,
const plString& friendInvite,
FNetCliAuthPlayerCreateRequestCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// PlayerDeleteRequestTrans
//============================================================================
struct PlayerDeleteRequestTrans : NetAuthTrans {
FNetCliAuthPlayerDeleteRequestCallback m_callback;
void * m_param;
// send
unsigned m_playerId;
// recv
NetCliAuthPlayerInfo m_playerInfo;
PlayerDeleteRequestTrans (
unsigned playerId,
FNetCliAuthPlayerDeleteRequestCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// UpgradeVisitorRequestTrans
//============================================================================
struct UpgradeVisitorRequestTrans : NetAuthTrans {
FNetCliAuthUpgradeVisitorRequestCallback m_callback;
void * m_param;
// send
unsigned m_playerId;
UpgradeVisitorRequestTrans (
unsigned playerId,
FNetCliAuthUpgradeVisitorRequestCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// SetPlayerRequestTrans
//============================================================================
struct SetPlayerRequestTrans : NetAuthTrans {
FNetCliAuthSetPlayerRequestCallback m_callback;
void * m_param;
unsigned m_playerInt;
SetPlayerRequestTrans (
unsigned playerInt,
FNetCliAuthSetPlayerRequestCallback callback,
void * param
);
// This transaction doesn't timeout since a client starting from a clean
// directory can take a long time between issuing this transaction and
// receiving a reply.
bool TimedOut () { return false; }
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// AccountChangePasswordRequestTrans
//============================================================================
struct AccountChangePasswordRequestTrans : NetAuthTrans {
FNetCliAuthAccountChangePasswordRequestCallback m_callback;
void * m_param;
// send
plString m_accountName;
ShaDigest m_namePassHash;
AccountChangePasswordRequestTrans (
const plString& accountName,
const plString& password,
FNetCliAuthAccountChangePasswordRequestCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// GetPublicAgeListTrans
//============================================================================
struct GetPublicAgeListTrans : NetAuthTrans {
FNetCliAuthGetPublicAgeListCallback m_callback;
void * m_param;
// send
plString m_ageName;
// recv
ARRAY(NetAgeInfo) m_ages;
GetPublicAgeListTrans (
const plString& ageName,
FNetCliAuthGetPublicAgeListCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// AccountSetRolesRequestTrans
//============================================================================
struct AccountSetRolesRequestTrans : NetAuthTrans {
FNetCliAuthAccountSetRolesRequestCallback m_callback;
void * m_param;
// send
wchar_t m_accountName[kMaxAccountNameLength];
unsigned m_accountFlags;
AccountSetRolesRequestTrans (
const wchar_t accountName[],
unsigned accountFlags,
FNetCliAuthAccountSetRolesRequestCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// AccountSetBillingTypeRequestTrans
//============================================================================
struct AccountSetBillingTypeRequestTrans : NetAuthTrans {
FNetCliAuthAccountSetBillingTypeRequestCallback m_callback;
void * m_param;
// send
wchar_t m_accountName[kMaxAccountNameLength];
unsigned m_billingType;
AccountSetBillingTypeRequestTrans (
const wchar_t accountName[],
unsigned billingType,
FNetCliAuthAccountSetBillingTypeRequestCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// AccountActivateRequestTrans
//============================================================================
struct AccountActivateRequestTrans : NetAuthTrans {
FNetCliAuthAccountActivateRequestCallback m_callback;
void * m_param;
// send
plUUID m_activationKey;
AccountActivateRequestTrans (
const plUUID& activationKey,
FNetCliAuthAccountActivateRequestCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// FileListRequestTrans
//============================================================================
struct FileListRequestTrans : NetAuthTrans {
FNetCliAuthFileListRequestCallback m_callback;
void * m_param;
wchar_t m_directory[MAX_PATH];
wchar_t m_ext[MAX_EXT];
ARRAY(NetCliAuthFileInfo) m_fileInfoArray;
FileListRequestTrans (
FNetCliAuthFileListRequestCallback callback,
void * param,
const wchar_t directory[],
const wchar_t ext[]
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// FileDownloadRequestTrans
//============================================================================
struct FileDownloadRequestTrans : NetAuthTrans {
FNetCliAuthFileRequestCallback m_callback;
void * m_param;
plFileName m_filename;
hsStream * m_writer;
FileDownloadRequestTrans (
FNetCliAuthFileRequestCallback callback,
void * param,
const plFileName & filename,
hsStream * writer
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// RcvdFileDownloadChunkTrans
//============================================================================
struct RcvdFileDownloadChunkTrans : NetNotifyTrans {
unsigned bytes;
unsigned offset;
uint8_t * data;
hsStream * writer;
RcvdFileDownloadChunkTrans () : NetNotifyTrans(kRcvdFileDownloadChunkTrans) {}
~RcvdFileDownloadChunkTrans ();
void Post ();
};
//============================================================================
// RcvdPropagatedBufferTrans
//============================================================================
struct RcvdPropagatedBufferTrans : NetNotifyTrans {
unsigned bufferType;
unsigned bufferBytes;
uint8_t * bufferData;
RcvdPropagatedBufferTrans () : NetNotifyTrans(kRcvdPropagatedBufferTrans) {}
~RcvdPropagatedBufferTrans ();
void Post ();
};
//============================================================================
// VaultNodeChangedTrans
//============================================================================
struct VaultNodeChangedTrans : NetNotifyTrans {
unsigned m_nodeId;
plUUID m_revId;
VaultNodeChangedTrans () : NetNotifyTrans(kVaultNodeChangedTrans) {}
void Post ();
};
//============================================================================
// VaultNodeAddedTrans
//============================================================================
struct VaultNodeAddedTrans : NetNotifyTrans {
unsigned m_parentId;
unsigned m_childId;
unsigned m_ownerId;
VaultNodeAddedTrans () : NetNotifyTrans(kVaultNodeAddedTrans) {}
void Post ();
};
//============================================================================
// VaultNodeRemovedTrans
//============================================================================
struct VaultNodeRemovedTrans : NetNotifyTrans {
unsigned m_parentId;
unsigned m_childId;
VaultNodeRemovedTrans () : NetNotifyTrans(kVaultNodeRemovedTrans) {}
void Post ();
};
//============================================================================
// VaultNodeDeletedTrans
//============================================================================
struct VaultNodeDeletedTrans : NetNotifyTrans {
unsigned m_nodeId;
VaultNodeDeletedTrans () : NetNotifyTrans(kVaultNodeDeletedTrans) {}
void Post ();
};
//============================================================================
// VaultFetchNodeRefsTrans
//============================================================================
struct VaultFetchNodeRefsTrans : NetAuthTrans {
unsigned m_nodeId;
FNetCliAuthVaultNodeRefsFetched m_callback;
void * m_param;
ARRAY(NetVaultNodeRef) m_refs;
VaultFetchNodeRefsTrans (
unsigned nodeId,
FNetCliAuthVaultNodeRefsFetched callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// VaultInitAgeTrans
//============================================================================
struct VaultInitAgeTrans : NetAuthTrans {
FNetCliAuthAgeInitCallback m_callback;
void * m_param;
plUUID m_ageInstId;
plUUID m_parentAgeInstId;
plString m_ageFilename;
plString m_ageInstName;
plString m_ageUserName;
plString m_ageDesc;
unsigned m_ageSequenceNumber;
unsigned m_ageLanguage;
unsigned m_ageId;
unsigned m_ageInfoId;
VaultInitAgeTrans(
FNetCliAuthAgeInitCallback callback, // optional
void * param, // optional
const plUUID& ageInstId, // optional. is used in match
const plUUID& parentAgeInstId, // optional. is used in match
const plString ageFilename, // optional. is used in match
const plString ageInstName, // optional. not used in match
const plString ageUserName, // optional. not used in match
const plString ageDesc, // optional. not used in match
unsigned ageSequenceNumber, // optional. not used in match
unsigned ageLanguage // optional. not used in match
);
~VaultInitAgeTrans ();
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// VaultFetchNodeTrans
//============================================================================
struct VaultFetchNodeTrans : NetAuthTrans {
unsigned m_nodeId;
FNetCliAuthVaultNodeFetched m_callback;
void * m_param;
hsRef<NetVaultNode> m_node;
VaultFetchNodeTrans (
unsigned nodeId,
FNetCliAuthVaultNodeFetched callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// VaultFindNodeTrans
//============================================================================
struct VaultFindNodeTrans : NetAuthTrans {
ARRAY(unsigned) m_nodeIds;
FNetCliAuthVaultNodeFind m_callback;
void * m_param;
hsRef<NetVaultNode> m_node;
VaultFindNodeTrans (
NetVaultNode * templateNode,
FNetCliAuthVaultNodeFind callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// VaultCreateNodeTrans
//============================================================================
struct VaultCreateNodeTrans : NetAuthTrans {
hsRef<NetVaultNode> m_templateNode;
FNetCliAuthVaultNodeCreated m_callback;
void * m_param;
unsigned m_nodeId;
VaultCreateNodeTrans (
NetVaultNode * templateNode,
FNetCliAuthVaultNodeCreated callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// VaultSaveNodeTrans
//============================================================================
struct VaultSaveNodeTrans : NetAuthTrans {
unsigned m_nodeId;
plUUID m_revisionId;
ARRAY(uint8_t) m_buffer;
FNetCliAuthVaultNodeSaveCallback m_callback;
void * m_param;
VaultSaveNodeTrans (
unsigned nodeId,
const plUUID& revisionId,
unsigned dataCount,
const void * data,
FNetCliAuthVaultNodeSaveCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// VaultAddNodeTrans
//============================================================================
struct VaultAddNodeTrans : NetAuthTrans {
unsigned m_parentId;
unsigned m_childId;
unsigned m_ownerId;
FNetCliAuthVaultNodeAddCallback m_callback;
void * m_param;
VaultAddNodeTrans (
unsigned parentId,
unsigned childId,
unsigned ownerId,
FNetCliAuthVaultNodeAddCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// VaultRemoveNodeTrans
//============================================================================
struct VaultRemoveNodeTrans : NetAuthTrans {
unsigned m_parentId;
unsigned m_childId;
FNetCliAuthVaultNodeRemoveCallback m_callback;
void * m_param;
VaultRemoveNodeTrans (
unsigned parentId,
unsigned childId,
FNetCliAuthVaultNodeRemoveCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// NotifyNewBuildTrans
//============================================================================
struct NotifyNewBuildTrans : NetNotifyTrans {
NotifyNewBuildTrans () : NetNotifyTrans(kNotifyNewBuildTrans) {}
void Post ();
};
//============================================================================
// SetPlayerBanStatusRequestTrans
//============================================================================
struct SetPlayerBanStatusRequestTrans : NetAuthTrans {
FNetCliAuthSetPlayerBanStatusRequestCallback m_callback;
void * m_param;
// send
unsigned m_playerId;
unsigned m_banned;
SetPlayerBanStatusRequestTrans (
unsigned playerId,
unsigned banned,
FNetCliAuthSetPlayerBanStatusRequestCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// ChangePlayerNameRequestTrans
//============================================================================
struct ChangePlayerNameRequestTrans : NetAuthTrans {
FNetCliAuthChangePlayerNameRequestCallback m_callback;
void * m_param;
// send
unsigned m_playerId;
wchar_t m_newName[kMaxPlayerNameLength];
ChangePlayerNameRequestTrans (
unsigned playerId,
const wchar_t newName[],
FNetCliAuthChangePlayerNameRequestCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// SendFriendInviteTrans
//============================================================================
struct SendFriendInviteTrans : NetAuthTrans {
FNetCliAuthSendFriendInviteCallback m_callback;
void * m_param;
// send
plString m_emailAddress;
plString m_toName;
plUUID m_inviteUuid;
SendFriendInviteTrans(
const plString& emailAddr,
const plString& toName,
const plUUID& inviteUuid,
FNetCliAuthSendFriendInviteCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// AuthConnectedNotifyTrans
//============================================================================
struct AuthConnectedNotifyTrans : NetNotifyTrans {
AuthConnectedNotifyTrans () : NetNotifyTrans(kAuthConnectedNotifyTrans) {}
void Post ();
};
//============================================================================
// ScoreCreateTrans
//============================================================================
struct ScoreCreateTrans : NetAuthTrans {
FNetCliAuthCreateScoreCallback m_callback;
void * m_param;
// send
unsigned m_ownerId;
plString m_gameName;
unsigned m_gameType;
int m_value;
// recv
unsigned m_scoreId;
uint32_t m_createdTime;
ScoreCreateTrans (
unsigned ownerId,
const plString& gameName,
unsigned gameType,
int value,
FNetCliAuthCreateScoreCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// ScoreDeleteTrans
//============================================================================
struct ScoreDeleteTrans : NetAuthTrans {
FNetCliAuthScoreUpdateCallback m_callback;
void * m_param;
// send
unsigned m_scoreId;
ScoreDeleteTrans (
unsigned scoreId,
FNetCliAuthScoreUpdateCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// ScoreGetScoresTrans
//============================================================================
struct ScoreGetScoresTrans : NetAuthTrans {
FNetCliAuthGetScoresCallback m_callback;
void * m_param;
// send
unsigned m_ownerId;
plString m_gameName;
// recv
NetGameScore * m_scores;
unsigned m_scoreCount;
ScoreGetScoresTrans (
unsigned ownerId,
const plString& gameName,
FNetCliAuthGetScoresCallback callback,
void * param
);
~ScoreGetScoresTrans();
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// ScoreAddPointsTrans
//============================================================================
struct ScoreAddPointsTrans : NetAuthTrans {
FNetCliAuthScoreUpdateCallback m_callback;
void * m_param;
// send
unsigned m_scoreId;
int m_numPoints;
ScoreAddPointsTrans (
unsigned scoreId,
int numPoints,
FNetCliAuthScoreUpdateCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// ScoreTransferPointsTrans
//============================================================================
struct ScoreTransferPointsTrans : NetAuthTrans {
FNetCliAuthScoreUpdateCallback m_callback;
void * m_param;
// send
unsigned m_srcScoreId;
unsigned m_destScoreId;
int m_numPoints;
ScoreTransferPointsTrans (
unsigned srcScoreId,
unsigned destScoreId,
int numPoints,
FNetCliAuthScoreUpdateCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// ScoreSetPointsTrans
//============================================================================
struct ScoreSetPointsTrans : NetAuthTrans {
FNetCliAuthScoreUpdateCallback m_callback;
void * m_param;
// send
unsigned m_scoreId;
int m_numPoints;
ScoreSetPointsTrans (
unsigned scoreId,
int numPoints,
FNetCliAuthScoreUpdateCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// ScoreGetRanksTrans
//============================================================================
struct ScoreGetRanksTrans : NetAuthTrans {
FNetCliAuthGetRanksCallback m_callback;
void * m_param;
// send
unsigned m_ownerId;
unsigned m_scoreGroup;
unsigned m_parentFolderId;
plString m_gameName;
unsigned m_timePeriod;
unsigned m_numResults;
unsigned m_pageNumber;
unsigned m_sortDesc;
// recv
NetGameRank * m_ranks;
unsigned m_rankCount;
ScoreGetRanksTrans (
unsigned ownerId,
unsigned scoreGroup,
unsigned parentFolderId,
const plString& gameName,
unsigned timePeriod,
unsigned numResults,
unsigned pageNumber,
bool sortDesc,
FNetCliAuthGetRanksCallback callback,
void * param
);
bool Send ();
void Post ();
bool Recv (
const uint8_t msg[],
unsigned bytes
);
};
//============================================================================
// ScoreGetHighScoresTrans
//============================================================================
struct ScoreGetHighScoresTrans : NetAuthTrans {
FNetCliAuthGetScoresCallback m_callback;
void * m_param;
// send
unsigned m_ageId;
unsigned m_maxScores;
plString m_gameName;
// recv
NetGameScore * m_scores;
unsigned m_scoreCount;
ScoreGetHighScoresTrans(
unsigned ageId,
unsigned maxScores,
const plString& gameName,
FNetCliAuthGetScoresCallback callback,
void * param
);
~ScoreGetHighScoresTrans();
bool Send();
void Post();
bool Recv(
const uint8_t msg[],
unsigned bytes
);
};
/*****************************************************************************
*
* Private data
*
***/
enum {
kPerfConnCount,
kPingDisabled,
kAutoReconnectDisabled,
kNumPerf
};
static bool s_running;
static CCritSect s_critsect;
static LISTDECL(CliAuConn, link) s_conns;
static CliAuConn * s_active;
static plString s_accountName;
static ShaDigest s_accountNamePassHash;
static wchar_t s_authToken[kMaxPublisherAuthKeyLength];
static wchar_t s_os[kMaxGTOSIdLength];
static std::atomic<long> s_perf[kNumPerf];
static uint32_t s_encryptionKey[4];
static FNetCliAuthRecvBufferHandler s_bufRcvdCb;
static FNetCliAuthConnectCallback s_connectedCb;
// Vault notification handlers
static FNetCliAuthVaultNodeChanged s_vaultNodeChangedHandler;
static FNetCliAuthVaultNodeAdded s_vaultNodeAddedHandler;
static FNetCliAuthVaultNodeRemoved s_vaultNodeRemovedHandler;
static FNetCliAuthVaultNodeDeleted s_vaultNodeDeletedHandler;
static FNotifyNewBuildHandler s_notifyNewBuildHandler;
/*****************************************************************************
*
* Internal functions
*
***/
//===========================================================================
static ENetError FixupPlayerName (plString& name) {
ASSERT(!name.IsEmpty());
// Trim leading and trailing whitespace
name = name.Trim(" \t\n\r");
// Convert remaining internal whitespace to a single space.
// Kind of hacky, but meh.
std::vector<plString> things = name.Tokenize(" \t\n\r");
plStringStream ss;
for (auto it = things.begin(); it != things.end(); ++it) {
ss << *it;
if ((it + 1) != things.end())
ss << " ";
}
name = ss.GetString();
// Now, check to see if we have the appropriate length
// We could count the characters, but lazy...
if (name.Replace(" ", "").GetSize() < 3)
return kNetErrPlayerNameInvalid;
return kNetSuccess;
}
//===========================================================================
static unsigned GetNonZeroTimeMs () {
if (unsigned ms = hsTimer::GetMilliSeconds<uint32_t>())
return ms;
return 1;
}
//============================================================================
static CliAuConn * GetConnIncRef_CS (const char tag[]) {
if (CliAuConn * conn = s_active) {
conn->Ref(tag);
return conn;
}
return nil;
}
//============================================================================
static CliAuConn * GetConnIncRef (const char tag[]) {
CliAuConn * conn;
s_critsect.Enter();
{
conn = GetConnIncRef_CS(tag);
}
s_critsect.Leave();
return conn;
}
//============================================================================
static void UnlinkAndAbandonConn_CS (CliAuConn * conn) {
s_conns.Unlink(conn);
conn->abandoned = true;
conn->StopAutoReconnect();
if (conn->cancelId) {
AsyncSocketConnectCancel(nil, conn->cancelId);
conn->cancelId = 0;
}
else if (conn->sock) {
AsyncSocketDisconnect(conn->sock, true);
}
else {
conn->UnRef("Lifetime");
}
}
//============================================================================
static void SendClientRegisterRequest (CliAuConn * conn) {
const uintptr_t msg[] = {
kCli2Auth_ClientRegisterRequest,
plProduct::BuildId(),
};
conn->Send(msg, arrsize(msg));
}
//============================================================================
static bool ConnEncrypt (ENetError error, void * param) {
CliAuConn * conn = (CliAuConn *) param;
if (IS_NET_SUCCESS(error)) {
SendClientRegisterRequest(conn);
if (!s_perf[kPingDisabled])
conn->AutoPing();
AuthConnectedNotifyTrans * trans = new AuthConnectedNotifyTrans;
NetTransSend(trans);
}
return IS_NET_SUCCESS(error);
}
//============================================================================
static void NotifyConnSocketConnect (CliAuConn * conn) {
conn->TransferRef("Connecting", "Connected");
conn->cli = NetCliConnectAccept(
conn->sock,
kNetProtocolCli2Auth,
false,
ConnEncrypt,
0,
nil,
conn
);
}
//============================================================================
static void CheckedReconnect (CliAuConn * conn, ENetError error) {
unsigned disconnectedMs = GetNonZeroTimeMs() - conn->lastHeardTimeMs;
// no auto-reconnect or haven't heard from the server in a while?
if (!conn->AutoReconnectEnabled() || (int)disconnectedMs >= (int)kDisconnectedTimeoutMs) {
// Cancel all transactions in progress on this connection.
NetTransCancelByConnId(conn->seq, kNetErrTimeout);
// conn is dead.
conn->UnRef("Lifetime");
ReportNetError(kNetProtocolCli2Auth, error);
}
else {
if (conn->token != kNilUuid)
// previously encrypted; reconnect quickly
conn->reconnectStartMs = GetNonZeroTimeMs() + 500;
else
// never encrypted; reconnect slowly
conn->reconnectStartMs = GetNonZeroTimeMs() + kMaxReconnectIntervalMs;
// clean up the socket and start reconnect
if (conn->cli)
NetCliDelete(conn->cli, true);
conn->cli = nil;
conn->sock = nil;
conn->StartAutoReconnect();
}
}
//============================================================================
static void NotifyConnSocketConnectFailed (CliAuConn * conn) {
s_critsect.Enter();
{
conn->cancelId = 0;
s_conns.Unlink(conn);
if (conn == s_active)
s_active = nil;
}
s_critsect.Leave();
CheckedReconnect(conn, kNetErrConnectFailed);
conn->UnRef("Connecting");
}
//============================================================================
static void NotifyConnSocketDisconnect (CliAuConn * conn) {
conn->StopAutoPing();
s_critsect.Enter();
{
conn->cancelId = 0;
s_conns.Unlink(conn);
if (conn == s_active)
s_active = nil;
}
s_critsect.Leave();
CheckedReconnect(conn, kNetErrDisconnected);
conn->UnRef("Connected");
}
//============================================================================
static bool NotifyConnSocketRead (CliAuConn * conn, AsyncNotifySocketRead * read) {
// TODO: Only dispatch messages from the active auth server
conn->lastHeardTimeMs = GetNonZeroTimeMs();
bool result = NetCliDispatch(conn->cli, read->buffer, read->bytes, conn);
read->bytesProcessed += read->bytes;
return result;
}
//============================================================================
static bool SocketNotifyCallback (
AsyncSocket sock,
EAsyncNotifySocket code,
AsyncNotifySocket * notify,
void ** userState
) {
bool result = true;
CliAuConn * conn;
switch (code) {
case kNotifySocketConnectSuccess:
conn = (CliAuConn *) notify->param;
*userState = conn;
bool abandoned;
s_critsect.Enter();
{
conn->sock = sock;
conn->cancelId = 0;
abandoned = conn->abandoned;
}
s_critsect.Leave();
if (abandoned)
AsyncSocketDisconnect(sock, true);
else
NotifyConnSocketConnect(conn);
break;
case kNotifySocketConnectFailed:
conn = (CliAuConn *) notify->param;
NotifyConnSocketConnectFailed(conn);
break;
case kNotifySocketDisconnect:
conn = (CliAuConn *) *userState;
NotifyConnSocketDisconnect(conn);
break;
case kNotifySocketRead:
conn = (CliAuConn *) *userState;
result = NotifyConnSocketRead(conn, (AsyncNotifySocketRead *) notify);
break;
}
return result;
}
//============================================================================
static void Connect (
CliAuConn * conn
) {
ASSERT(s_running);
conn->pingSendTimeMs = 0;
s_critsect.Enter();
{
while (CliAuConn * oldConn = s_conns.Head()) {
if (oldConn != conn)
UnlinkAndAbandonConn_CS(oldConn);
else
s_conns.Unlink(oldConn);
}
s_conns.Link(conn);
}
s_critsect.Leave();
Cli2Auth_Connect connect;
connect.hdr.connType = kConnTypeCliToAuth;
connect.hdr.hdrBytes = sizeof(connect.hdr);
connect.hdr.buildId = plProduct::BuildId();
connect.hdr.buildType = plProduct::BuildType();
connect.hdr.branchId = plProduct::BranchId();
connect.hdr.productId = plProduct::UUID();
connect.data.token = conn->token;
connect.data.dataBytes = sizeof(connect.data);
AsyncSocketConnect(
&conn->cancelId,
conn->addr,
SocketNotifyCallback,
conn,
&connect,
sizeof(connect),
0,
0
);
}
//============================================================================
static void Connect (
const plString& name,
const plNetAddress& addr
) {
ASSERT(s_running);
CliAuConn * conn = new CliAuConn;
conn->addr = addr;
conn->seq = ConnNextSequence();
conn->lastHeardTimeMs = GetNonZeroTimeMs(); // used in connect timeout, and ping timeout
conn->name = name;
conn->Ref("Lifetime");
conn->AutoReconnect();
}
//============================================================================
static void AsyncLookupCallback (
void * param,
const char name[],
unsigned addrCount,
const plNetAddress addrs[]
) {
if (!addrCount) {
ReportNetError(kNetProtocolCli2Auth, kNetErrNameLookupFailed);
return;
}
for (unsigned i = 0; i < addrCount; ++i) {
Connect(name, addrs[i]);
}
}
/*****************************************************************************
*
* CliAuConn
*
***/
//===========================================================================
static unsigned CliAuConnTimerDestroyed (void * param) {
CliAuConn * conn = (CliAuConn *) param;
conn->UnRef("TimerDestroyed");
return kAsyncTimeInfinite;
}
//===========================================================================
static unsigned CliAuConnReconnectTimerProc (void * param) {
((CliAuConn *) param)->TimerReconnect();
return kAsyncTimeInfinite;
}
//===========================================================================
static unsigned CliAuConnPingTimerProc (void * param) {
((CliAuConn *) param)->TimerPing();
return kPingIntervalMs;
}
//============================================================================
CliAuConn::CliAuConn ()
: hsRefCnt(0), reconnectTimer(nil), reconnectStartMs(0)
, pingTimer(nil), pingSendTimeMs(0), lastHeardTimeMs(0)
, sock(nil), cli(nil), seq(0), serverChallenge(0)
, cancelId(nil), abandoned(false)
{
++s_perf[kPerfConnCount];
}
//============================================================================
CliAuConn::~CliAuConn () {
if (cli)
NetCliDelete(cli, true);
--s_perf[kPerfConnCount];
}
//===========================================================================
void CliAuConn::TimerReconnect () {
ASSERT(!sock);
ASSERT(!cancelId);
if (!s_running) {
s_critsect.Enter();
UnlinkAndAbandonConn_CS(this);
s_critsect.Leave();
}
else {
Ref("Connecting");
// Remember the time we started the reconnect attempt, guarding against
// TimeGetMs() returning zero (unlikely), as a value of zero indicates
// a first-time connect condition to StartAutoReconnect()
reconnectStartMs = GetNonZeroTimeMs();
Connect(this);
}
}
//===========================================================================
// This function is called when after a disconnect to start a new connection
void CliAuConn::StartAutoReconnect () {
critsect.Enter();
if (reconnectTimer && !s_perf[kAutoReconnectDisabled]) {
// Make reconnect attempts at regular intervals. If the last attempt
// took more than the specified max interval time then reconnect
// immediately; otherwise wait until the time interval is up again
// then reconnect.
unsigned remainingMs = 0;
if (reconnectStartMs) {
remainingMs = reconnectStartMs - GetNonZeroTimeMs();
if ((signed)remainingMs < 0)
remainingMs = 0;
LogMsg(kLogPerf, L"Auth auto-reconnecting in %u ms", remainingMs);
}
AsyncTimerUpdate(reconnectTimer, remainingMs);
}
critsect.Leave();
}
//===========================================================================
// This function should be called during object construction
// to initiate connection attempts to the remote host whenever
// the socket is disconnected.
void CliAuConn::AutoReconnect () {
ASSERT(!reconnectTimer);
Ref("ReconnectTimer");
critsect.Enter();
{
AsyncTimerCreate(
&reconnectTimer,
CliAuConnReconnectTimerProc,
0, // immediate callback
this
);
}
critsect.Leave();
}
//============================================================================
void CliAuConn::StopAutoReconnect () {
critsect.Enter();
{
if (AsyncTimer * timer = reconnectTimer) {
reconnectTimer = nil;
AsyncTimerDeleteCallback(timer, CliAuConnTimerDestroyed);
}
}
critsect.Leave();
}
//============================================================================
bool CliAuConn::AutoReconnectEnabled () {
return (reconnectTimer != nil) && !s_perf[kAutoReconnectDisabled];
}
//============================================================================
void CliAuConn::AutoPing () {
ASSERT(!pingTimer);
Ref("PingTimer");
critsect.Enter();
{
AsyncTimerCreate(
&pingTimer,
CliAuConnPingTimerProc,
sock ? 0 : kAsyncTimeInfinite,
this
);
}
critsect.Leave();
}
//============================================================================
void CliAuConn::StopAutoPing () {
critsect.Enter();
{
if (pingTimer) {
AsyncTimerDeleteCallback(pingTimer, CliAuConnTimerDestroyed);
pingTimer = nil;
}
}
critsect.Leave();
}
//============================================================================
void CliAuConn::TimerPing () {
// Send a ping request
pingSendTimeMs = GetNonZeroTimeMs();
const uintptr_t msg[] = {
kCli2Auth_PingRequest,
pingSendTimeMs,
0, // not a transaction
0, // no payload
reinterpret_cast<uintptr_t>(nullptr)
};
Send(msg, arrsize(msg));
}
//============================================================================
void CliAuConn::Send (const uintptr_t fields[], unsigned count) {
critsect.Enter();
{
NetCliSend(cli, fields, count);
NetCliFlush(cli);
}
critsect.Leave();
}
/*****************************************************************************
*
* Cli2Auth message handlers
*
***/
//============================================================================
static bool Recv_PingReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_PingReply & reply = *(const Auth2Cli_PingReply *)msg;
if (reply.transId)
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_AccountExistsReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_AccountExistsReply & reply = *(const Auth2Cli_AccountExistsReply *)msg;
if (reply.transId)
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_ClientRegisterReply (
const uint8_t msg[],
unsigned ,
void * param
) {
const Auth2Cli_ClientRegisterReply & reply = *(const Auth2Cli_ClientRegisterReply *)msg;
CliAuConn * conn = (CliAuConn *) param;
conn->serverChallenge = reply.serverChallenge;
// Make this the active server
s_critsect.Enter();
{
s_active = conn;
}
s_critsect.Leave();
return true;
}
//============================================================================
static bool Recv_AcctPlayerInfo (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_AcctPlayerInfo & reply = *(const Auth2Cli_AcctPlayerInfo *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_AcctLoginReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_AcctLoginReply & reply = *(const Auth2Cli_AcctLoginReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_AcctCreateReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_AcctCreateReply & reply = *(const Auth2Cli_AcctCreateReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_AcctCreateFromKeyReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_AcctCreateFromKeyReply & reply = *(const Auth2Cli_AcctCreateFromKeyReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_PlayerCreateReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_PlayerCreateReply & reply = *(const Auth2Cli_PlayerCreateReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_PlayerDeleteReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_PlayerDeleteReply & reply = *(const Auth2Cli_PlayerDeleteReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_UpgradeVisitorReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_UpgradeVisitorReply & reply = *(const Auth2Cli_UpgradeVisitorReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_AcctSetPlayerReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_AcctSetPlayerReply & reply = *(const Auth2Cli_AcctSetPlayerReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_AcctChangePasswordReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_AcctChangePasswordReply & reply = *(const Auth2Cli_AcctChangePasswordReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_AcctSetRolesReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_AcctSetRolesReply & reply = *(const Auth2Cli_AcctSetRolesReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_AcctSetBillingTypeReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_AcctSetBillingTypeReply & reply = *(const Auth2Cli_AcctSetBillingTypeReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_AcctActivateReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_AcctActivateReply & reply = *(const Auth2Cli_AcctActivateReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_AgeReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_AgeReply & reply = *(const Auth2Cli_AgeReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_FileListReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_FileListReply & reply = *(const Auth2Cli_FileListReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_FileDownloadChunk (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_FileDownloadChunk & reply = *(const Auth2Cli_FileDownloadChunk *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_KickedOff (
const uint8_t buffer[],
unsigned bytes,
void * param
) {
const Auth2Cli_KickedOff & msg = *(const Auth2Cli_KickedOff *)buffer;
ReportNetError(kNetProtocolCli2Auth, msg.reason);
NetCliAuthDisconnect();
return true;
}
//============================================================================
static bool Recv_VaultNodeRefsFetched (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_VaultNodeRefsFetched & reply = *(const Auth2Cli_VaultNodeRefsFetched *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_VaultNodeFetched (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_VaultNodeFetched & reply = *(const Auth2Cli_VaultNodeFetched *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_VaultNodeCreated (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_VaultNodeCreated & reply = *(const Auth2Cli_VaultNodeCreated *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_VaultNodeChanged (
const uint8_t msg[],
unsigned ,
void *
) {
const Auth2Cli_VaultNodeChanged & notify = *(const Auth2Cli_VaultNodeChanged *)msg;
VaultNodeChangedTrans * trans = new VaultNodeChangedTrans;
trans->m_nodeId = notify.nodeId;
trans->m_revId = notify.revisionId;
NetTransSend(trans);
return true;
}
//============================================================================
static bool Recv_VaultNodeAdded (
const uint8_t msg[],
unsigned ,
void *
) {
const Auth2Cli_VaultNodeAdded & notify = *(const Auth2Cli_VaultNodeAdded *)msg;
VaultNodeAddedTrans * trans = new VaultNodeAddedTrans;
trans->m_parentId = notify.parentId;
trans->m_childId = notify.childId;
trans->m_ownerId = notify.ownerId;
NetTransSend(trans);
return true;
}
//============================================================================
static bool Recv_VaultNodeRemoved (
const uint8_t msg[],
unsigned ,
void *
) {
const Auth2Cli_VaultNodeRemoved & notify = *(const Auth2Cli_VaultNodeRemoved *)msg;
VaultNodeRemovedTrans * trans = new VaultNodeRemovedTrans;
trans->m_parentId = notify.parentId;
trans->m_childId = notify.childId;
NetTransSend(trans);
return true;
}
//============================================================================
static bool Recv_VaultNodeDeleted (
const uint8_t msg[],
unsigned ,
void *
) {
const Auth2Cli_VaultNodeDeleted & notify = *(const Auth2Cli_VaultNodeDeleted *)msg;
VaultNodeDeletedTrans * trans = new VaultNodeDeletedTrans;
trans->m_nodeId = notify.nodeId;
NetTransSend(trans);
return true;
}
//============================================================================
static bool Recv_VaultSaveNodeReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_VaultSaveNodeReply & reply = *(const Auth2Cli_VaultSaveNodeReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_VaultAddNodeReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_VaultAddNodeReply & reply = *(const Auth2Cli_VaultAddNodeReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_VaultRemoveNodeReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_VaultRemoveNodeReply & reply = *(const Auth2Cli_VaultRemoveNodeReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_VaultInitAgeReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_VaultInitAgeReply & reply = *(const Auth2Cli_VaultInitAgeReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_VaultNodeFindReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_VaultNodeFindReply & reply = *(const Auth2Cli_VaultNodeFindReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_PublicAgeList (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_PublicAgeList & reply = *(const Auth2Cli_PublicAgeList *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_ServerAddr (
const uint8_t in[],
unsigned ,
void *
) {
// the auth server has given us its actual address (behind any load-balancer)
// so that when we attempt a reconnect, we'll reconnect with our state on
// the auth (but only if we reconnect in a short period of time!)
const Auth2Cli_ServerAddr & msg = *(const Auth2Cli_ServerAddr *)in;
s_critsect.Enter();
{
if (s_active) {
s_active->token = msg.token;
s_active->addr.SetHost(msg.srvAddr);
LogMsg(kLogPerf, "SrvAuth addr: %s", s_active->addr.GetHostString().c_str());
}
}
s_critsect.Leave();
return true;
}
//============================================================================
static bool Recv_NotifyNewBuild (
const uint8_t[],
unsigned ,
void *
) {
NotifyNewBuildTrans * trans = new NotifyNewBuildTrans;
NetTransSend(trans);
return true;
}
//============================================================================
static bool Recv_SetPlayerBanStatusReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_SetPlayerBanStatusReply & reply = *(const Auth2Cli_SetPlayerBanStatusReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_ChangePlayerNameReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_ChangePlayerNameReply & reply = *(const Auth2Cli_ChangePlayerNameReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_SendFriendInviteReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_SendFriendInviteReply & reply = *(const Auth2Cli_SendFriendInviteReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_ScoreCreateReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_ScoreCreateReply & reply = *(const Auth2Cli_ScoreCreateReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_ScoreDeleteReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_ScoreDeleteReply & reply = *(const Auth2Cli_ScoreDeleteReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_ScoreGetScoresReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_ScoreGetScoresReply & reply = *(const Auth2Cli_ScoreGetScoresReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_ScoreAddPointsReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_ScoreAddPointsReply & reply = *(const Auth2Cli_ScoreAddPointsReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_ScoreTransferPointsReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_ScoreTransferPointsReply & reply = *(const Auth2Cli_ScoreTransferPointsReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_ScoreSetPointsReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_ScoreSetPointsReply & reply = *(const Auth2Cli_ScoreSetPointsReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_ScoreGetRanksReply (
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_ScoreGetRanksReply & reply = *(const Auth2Cli_ScoreGetRanksReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
//============================================================================
static bool Recv_ScoreGetHighScoresReply(
const uint8_t msg[],
unsigned bytes,
void *
) {
const Auth2Cli_ScoreGetHighScoresReply & reply = *(const Auth2Cli_ScoreGetHighScoresReply *)msg;
NetTransRecv(reply.transId, msg, bytes);
return true;
}
/*****************************************************************************
*
* Cli2Auth protocol
*
***/
#define MSG(s) &kNetMsg_Cli2Auth_##s
static NetMsgInitSend s_send[] = {
{ MSG(PingRequest) },
{ MSG(ClientRegisterRequest) },
{ MSG(AcctLoginRequest) },
{ MSG(AcctCreateRequest) },
{ MSG(AcctCreateFromKeyRequest) },
{ MSG(PlayerCreateRequest) },
{ MSG(PlayerDeleteRequest) },
{ MSG(UpgradeVisitorRequest) },
{ MSG(AcctSetPlayerRequest) },
{ MSG(AcctChangePasswordRequest)},
{ MSG(AcctSetRolesRequest) },
{ MSG(AcctSetBillingTypeRequest)},
{ MSG(AcctActivateRequest) },
{ MSG(AgeRequest) },
{ MSG(FileListRequest) },
{ MSG(FileDownloadRequest) },
{ MSG(FileDownloadChunkAck) },
{ MSG(VaultFetchNodeRefs) },
{ MSG(VaultNodeAdd) },
{ MSG(VaultNodeRemove) },
{ MSG(VaultNodeFetch) },
{ MSG(VaultNodeCreate) },
{ MSG(VaultNodeSave) },
{ MSG(VaultInitAgeRequest) },
{ MSG(VaultNodeFind) },
{ MSG(VaultSetSeen) },
{ MSG(VaultSendNode) },
{ MSG(GetPublicAgeList) },
{ MSG(SetAgePublic) },
{ MSG(PropagateBuffer) },
{ MSG(ClientSetCCRLevel) },
{ MSG(LogPythonTraceback) },
{ MSG(LogStackDump) },
{ MSG(LogClientDebuggerConnect) },
{ MSG(SetPlayerBanStatusRequest)},
{ MSG(KickPlayer) },
{ MSG(ChangePlayerNameRequest) },
{ MSG(SendFriendInviteRequest) },
{ MSG(ScoreCreate) },
{ MSG(ScoreDelete) },
{ MSG(ScoreGetScores) },
{ MSG(ScoreAddPoints) },
{ MSG(ScoreTransferPoints) },
{ MSG(ScoreSetPoints) },
{ MSG(ScoreGetRanks) },
{ MSG(AccountExistsRequest) },
{ MSG(ScoreGetHighScores) },
};
#undef MSG
#define MSG(s) &kNetMsg_Auth2Cli_##s, Recv_##s
static NetMsgInitRecv s_recv[] = {
{ MSG(PingReply) },
{ MSG(ClientRegisterReply) },
{ MSG(AcctPlayerInfo) },
{ MSG(AcctLoginReply) },
{ MSG(AcctCreateReply) },
{ MSG(AcctCreateFromKeyReply) },
{ MSG(PlayerCreateReply) },
{ MSG(PlayerDeleteReply) },
{ MSG(UpgradeVisitorReply) },
{ MSG(AcctSetPlayerReply) },
{ MSG(AcctChangePasswordReply) },
{ MSG(AcctSetRolesReply) },
{ MSG(AcctSetBillingTypeReply) },
{ MSG(AcctActivateReply) },
{ MSG(AgeReply) },
{ MSG(FileListReply) },
{ MSG(FileDownloadChunk) },
{ MSG(KickedOff) },
{ MSG(VaultNodeRefsFetched) },
{ MSG(VaultNodeFetched) },
{ MSG(VaultNodeCreated) },
{ MSG(VaultNodeChanged) },
{ MSG(VaultNodeAdded) },
{ MSG(VaultNodeRemoved) },
{ MSG(VaultNodeDeleted) },
{ MSG(VaultSaveNodeReply) },
{ MSG(VaultAddNodeReply) },
{ MSG(VaultRemoveNodeReply) },
{ MSG(VaultInitAgeReply) },
{ MSG(VaultNodeFindReply) },
{ MSG(PublicAgeList) },
{ MSG(ServerAddr) },
{ MSG(NotifyNewBuild) },
{ MSG(SetPlayerBanStatusReply) },
{ MSG(ChangePlayerNameReply) },
{ MSG(SendFriendInviteReply) },
{ MSG(ScoreCreateReply) },
{ MSG(ScoreDeleteReply) },
{ MSG(ScoreGetScoresReply) },
{ MSG(ScoreAddPointsReply) },
{ MSG(ScoreTransferPointsReply) },
{ MSG(ScoreSetPointsReply) },
{ MSG(ScoreGetRanksReply) },
{ MSG(AccountExistsReply) },
{ MSG(ScoreGetHighScoresReply) },
};
#undef MSG
/*****************************************************************************
*
* PingRequestTrans
*
***/
//============================================================================
PingRequestTrans::PingRequestTrans (
FNetCliAuthPingRequestCallback callback,
void * param,
unsigned pingAtMs,
unsigned payloadBytes,
const void * payload
) : NetAuthTrans(kPingRequestTrans)
, m_callback(callback)
, m_param(param)
, m_pingAtMs(pingAtMs)
{
m_payload.Set((const uint8_t *)payload, payloadBytes);
}
//============================================================================
bool PingRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_PingRequest,
m_pingAtMs,
m_transId,
m_payload.Count(),
(uintptr_t) m_payload.Ptr(),
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void PingRequestTrans::Post () {
m_callback(
m_result,
m_param,
m_pingAtMs,
m_replyAtMs,
m_payload.Count(),
m_payload.Ptr()
);
}
//============================================================================
bool PingRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_PingReply & reply = *(const Auth2Cli_PingReply *)msg;
m_payload.Set(reply.payload, reply.payloadBytes);
m_replyAtMs = hsTimer::GetMilliSeconds<uint32_t>();
m_result = kNetSuccess;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* AccountExistsRequestTrans
*
***/
//============================================================================
AccountExistsRequestTrans::AccountExistsRequestTrans (
FNetCliAuthAccountExistsRequestCallback callback,
void * param,
const wchar_t accountName[]
) : NetAuthTrans(kPingRequestTrans)
, m_callback(callback)
, m_param(param)
{
StrCopy(m_accountName, accountName, kMaxAccountNameLength);
}
//============================================================================
bool AccountExistsRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_AccountExistsRequest,
m_transId,
(uintptr_t)m_accountName
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void AccountExistsRequestTrans::Post () {
m_callback(
m_result,
m_param,
m_exists
);
}
//============================================================================
bool AccountExistsRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_AccountExistsReply & reply = *(const Auth2Cli_AccountExistsReply *)msg;
m_exists = reply.exists;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* LoginRequestTrans
*
***/
//============================================================================
LoginRequestTrans::LoginRequestTrans (
FNetCliAuthLoginRequestCallback callback,
void * param
) : NetAuthTrans(kLoginRequestTrans)
, m_callback(callback)
, m_param(param)
, m_accountId(kNilUuid)
, m_accountFlags(0)
, m_playerCount(0)
{
memset(&m_players, 0, sizeof(m_players));
}
//============================================================================
void LoginRequestTrans::AddPlayer (
unsigned playerInt,
const wchar_t playerName[],
const wchar_t avatarShape[],
unsigned explorer
) {
unsigned index = m_playerCount++;
ASSERT(index < kMaxPlayersPerAccount);
m_players[index].playerInt = playerInt;
m_players[index].explorer = explorer;
m_players[index].playerName = plString::FromWchar(playerName);
m_players[index].avatarShape = plString::FromWchar(avatarShape);
}
//============================================================================
bool LoginRequestTrans::Send () {
if (!AcquireConn())
return false;
ShaDigest challengeHash;
uint32_t clientChallenge = 0;
// Regex search for primary email domain
std::vector<plString> match = s_accountName.RESearch("[^@]+@([^.]+\\.)*([^.]+)\\.[^.]+");
if (match.empty() || match[2].CompareI("gametap") == 0) {
memcpy(challengeHash, s_accountNamePassHash, sizeof(ShaDigest));
} else {
CryptCreateRandomSeed(
sizeof(clientChallenge),
(uint8_t *) &clientChallenge
);
CryptHashPasswordChallenge(
clientChallenge,
s_active->serverChallenge,
s_accountNamePassHash,
challengeHash
);
}
plStringBuffer<uint16_t> accountName = s_accountName.ToUtf16();
const uintptr_t msg[] = {
kCli2Auth_AcctLoginRequest,
m_transId,
clientChallenge,
(uintptr_t) accountName.GetData(),
(uintptr_t) &challengeHash,
(uintptr_t) s_authToken,
(uintptr_t) s_os,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void LoginRequestTrans::Post () {
m_callback(
m_result,
m_param,
m_accountId,
m_accountFlags,
m_billingType,
m_players,
m_playerCount
);
}
//============================================================================
bool LoginRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
uint32_t msgId = (uint32_t)*msg;
switch (msgId) {
case kAuth2Cli_AcctPlayerInfo: {
const Auth2Cli_AcctPlayerInfo & reply = *(const Auth2Cli_AcctPlayerInfo *) msg;
AddPlayer(reply.playerInt, reply.playerName, reply.avatarShape, reply.explorer);
}
break;
case kAuth2Cli_AcctLoginReply: {
const Auth2Cli_AcctLoginReply & reply = *(const Auth2Cli_AcctLoginReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
m_accountId = reply.accountId;
m_accountFlags = reply.accountFlags;
m_billingType = reply.billingType;
unsigned memSize = std::min(arrsize(s_encryptionKey), arrsize(reply.encryptionKey));
memSize *= sizeof(uint32_t);
memcpy(s_encryptionKey, reply.encryptionKey, memSize);
}
break;
DEFAULT_FATAL(msgId);
};
return true;
}
/*****************************************************************************
*
* AgeRequestTrans
*
***/
//============================================================================
AgeRequestTrans::AgeRequestTrans (
const plString& ageName,
const plUUID& ageInstId,
FNetCliAuthAgeRequestCallback callback,
void * param
) : NetAuthTrans(kAgeRequestTrans)
, m_ageName(ageName)
, m_ageInstId(ageInstId)
, m_callback(callback)
, m_param(param)
{
}
//============================================================================
AgeRequestTrans::~AgeRequestTrans () {
}
//============================================================================
bool AgeRequestTrans::Send () {
if (!AcquireConn())
return true;
plStringBuffer<uint16_t> ageName = m_ageName.ToUtf16();
const uintptr_t msg[] = {
kCli2Auth_AgeRequest,
m_transId,
(uintptr_t) ageName.GetData(),
(uintptr_t) &m_ageInstId,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void AgeRequestTrans::Post () {
plNetAddress addr;
addr.SetHost(htonl(m_gameSrvNode));
m_callback(
m_result,
m_param,
m_ageMcpId,
m_ageVaultId,
m_ageInstId,
addr
);
}
//============================================================================
bool AgeRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_AgeReply & reply = *(const Auth2Cli_AgeReply *) msg;
m_gameSrvNode = reply.gameSrvNode;
m_ageMcpId = reply.ageMcpId;
m_ageVaultId = reply.ageVaultId;
m_ageInstId = reply.ageInstId;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* AccountCreateRequestTrans
*
***/
//============================================================================
AccountCreateRequestTrans::AccountCreateRequestTrans (
const wchar_t accountName[],
const wchar_t password[],
unsigned accountFlags,
unsigned billingType,
FNetCliAuthAccountCreateRequestCallback callback,
void * param
) : NetAuthTrans(kAccountCreateRequestTrans)
, m_callback(callback)
, m_param(param)
, m_accountFlags(accountFlags)
, m_billingType(billingType)
{
StrCopy(m_accountName, accountName, arrsize(m_accountName));
CryptHashPassword(
plString::FromWchar(m_accountName),
plString::FromWchar(password),
m_namePassHash
);
}
//============================================================================
bool AccountCreateRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_AcctCreateRequest,
m_transId,
(uintptr_t) m_accountName,
(uintptr_t) &m_namePassHash,
m_accountFlags,
m_billingType,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void AccountCreateRequestTrans::Post () {
m_callback(
m_result,
m_param,
m_accountId
);
}
//============================================================================
bool AccountCreateRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_AcctCreateReply & reply = *(const Auth2Cli_AcctCreateReply *) msg;
m_result = reply.result;
m_accountId = reply.accountId;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* AccountCreateFromKeyRequestTrans
*
***/
//============================================================================
AccountCreateFromKeyRequestTrans::AccountCreateFromKeyRequestTrans (
const wchar_t accountName[],
const wchar_t password[],
const plUUID& key,
unsigned billingType,
FNetCliAuthAccountCreateFromKeyRequestCallback callback,
void * param
) : NetAuthTrans(kAccountCreateFromKeyRequestTrans)
, m_callback(callback)
, m_param(param)
, m_billingType(billingType)
, m_key(key)
{
StrCopy(m_accountName, accountName, arrsize(m_accountName));
CryptHashPassword(
plString::FromWchar(m_accountName),
plString::FromWchar(password),
m_namePassHash
);
}
//============================================================================
bool AccountCreateFromKeyRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_AcctCreateFromKeyRequest,
m_transId,
(uintptr_t) m_accountName,
(uintptr_t) &m_namePassHash,
(uintptr_t) &m_key,
m_billingType,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void AccountCreateFromKeyRequestTrans::Post () {
m_callback(
m_result,
m_param,
m_accountId,
m_activationKey
);
}
//============================================================================
bool AccountCreateFromKeyRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_AcctCreateFromKeyReply & reply = *(const Auth2Cli_AcctCreateFromKeyReply *) msg;
m_result = reply.result;
m_accountId = reply.accountId;
m_activationKey = reply.activationKey;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* PlayerCreateRequestTrans
*
***/
//============================================================================
PlayerCreateRequestTrans::PlayerCreateRequestTrans (
const plString& playerName,
const plString& avatarShape,
const plString& friendInvite,
FNetCliAuthPlayerCreateRequestCallback callback,
void * param
) : NetAuthTrans(kPlayerCreateRequestTrans)
, m_playerName(playerName)
, m_avatarShape(avatarShape)
, m_friendInvite(friendInvite)
, m_callback(callback)
, m_param(param)
{
memset(&m_playerInfo, 0, sizeof(m_playerInfo));
}
//============================================================================
bool PlayerCreateRequestTrans::Send () {
if (!AcquireConn())
return false;
plStringBuffer<uint16_t> playerName = m_playerName.ToUtf16();
plStringBuffer<uint16_t> avatarShape = m_avatarShape.ToUtf16();
plStringBuffer<uint16_t> friendInvite = m_friendInvite.ToUtf16();
const uintptr_t msg[] = {
kCli2Auth_PlayerCreateRequest,
m_transId,
(uintptr_t) playerName.GetData(),
(uintptr_t) avatarShape.GetData(),
(uintptr_t) friendInvite.GetData(),
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void PlayerCreateRequestTrans::Post () {
m_callback(
m_result,
m_param,
m_playerInfo
);
}
//============================================================================
bool PlayerCreateRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_PlayerCreateReply & reply = *(const Auth2Cli_PlayerCreateReply *) msg;
if (!IS_NET_ERROR(reply.result)) {
m_playerInfo.playerInt = reply.playerInt;
m_playerInfo.explorer = reply.explorer;
m_playerInfo.playerName = plString::FromWchar(reply.playerName);
m_playerInfo.avatarShape = plString::FromWchar(reply.avatarShape);
}
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* PlayerDeleteRequestTrans
*
***/
//============================================================================
PlayerDeleteRequestTrans::PlayerDeleteRequestTrans (
unsigned playerId,
FNetCliAuthPlayerDeleteRequestCallback callback,
void * param
) : NetAuthTrans(kPlayerDeleteRequestTrans)
, m_callback(callback)
, m_param(param)
, m_playerId(playerId)
{
}
//============================================================================
bool PlayerDeleteRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_PlayerDeleteRequest,
m_transId,
m_playerId
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void PlayerDeleteRequestTrans::Post () {
m_callback(
m_result,
m_param
);
}
//============================================================================
bool PlayerDeleteRequestTrans::Recv (
const uint8_t msg[],
unsigned
) {
const Auth2Cli_PlayerDeleteReply & reply = *(const Auth2Cli_PlayerDeleteReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* UpgradeVisitorRequestTrans
*
***/
//============================================================================
UpgradeVisitorRequestTrans::UpgradeVisitorRequestTrans (
unsigned playerId,
FNetCliAuthUpgradeVisitorRequestCallback callback,
void * param
) : NetAuthTrans(kUpgradeVisitorRequestTrans)
, m_callback(callback)
, m_param(param)
, m_playerId(playerId)
{
}
//============================================================================
bool UpgradeVisitorRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_UpgradeVisitorRequest,
m_transId,
m_playerId
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void UpgradeVisitorRequestTrans::Post () {
m_callback(
m_result,
m_param
);
}
//============================================================================
bool UpgradeVisitorRequestTrans::Recv (
const uint8_t msg[],
unsigned
) {
const Auth2Cli_UpgradeVisitorReply & reply = *(const Auth2Cli_UpgradeVisitorReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* SetPlayerRequestTrans
*
***/
//============================================================================
SetPlayerRequestTrans::SetPlayerRequestTrans (
unsigned playerInt,
FNetCliAuthSetPlayerRequestCallback callback,
void * param
) : NetAuthTrans(kSetPlayerRequestTrans)
, m_playerInt(playerInt)
, m_callback(callback)
, m_param(param)
{
}
//============================================================================
bool SetPlayerRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_AcctSetPlayerRequest,
m_transId,
m_playerInt,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void SetPlayerRequestTrans::Post () {
m_callback(m_result, m_param);
}
//============================================================================
bool SetPlayerRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_AcctSetPlayerReply & reply = *(const Auth2Cli_AcctSetPlayerReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* AccountChangePasswordRequestTrans
*
***/
//============================================================================
AccountChangePasswordRequestTrans::AccountChangePasswordRequestTrans (
const plString& accountName,
const plString& password,
FNetCliAuthAccountChangePasswordRequestCallback callback,
void * param
) : NetAuthTrans(kAccountChangePasswordRequestTrans)
, m_accountName(accountName)
, m_callback(callback)
, m_param(param)
{
CryptHashPassword(
m_accountName,
password,
m_namePassHash
);
}
//============================================================================
bool AccountChangePasswordRequestTrans::Send () {
if (!AcquireConn())
return false;
plStringBuffer<uint16_t> accountName = m_accountName.ToUtf16();
const uintptr_t msg[] = {
kCli2Auth_AcctChangePasswordRequest,
m_transId,
(uintptr_t) accountName.GetData(),
(uintptr_t) &m_namePassHash,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void AccountChangePasswordRequestTrans::Post () {
m_callback(
m_result,
m_param
);
}
//============================================================================
bool AccountChangePasswordRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_AcctChangePasswordReply & reply = *(const Auth2Cli_AcctChangePasswordReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* GetPublicAgeListTrans
*
***/
//============================================================================
GetPublicAgeListTrans::GetPublicAgeListTrans (
const plString& ageName,
FNetCliAuthGetPublicAgeListCallback callback,
void * param
) : NetAuthTrans(kGetPublicAgeListTrans)
, m_ageName(ageName)
, m_callback(callback)
, m_param(param)
{
}
//============================================================================
bool GetPublicAgeListTrans::Send () {
if (!AcquireConn())
return false;
plStringBuffer<uint16_t> ageName = m_ageName.ToUtf16();
const uintptr_t msg[] = {
kCli2Auth_GetPublicAgeList,
m_transId,
(uintptr_t) ageName.GetData(),
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void GetPublicAgeListTrans::Post () {
m_callback(
m_result,
m_param,
m_ages
);
}
//============================================================================
bool GetPublicAgeListTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_PublicAgeList & reply = *(const Auth2Cli_PublicAgeList *) msg;
if (IS_NET_SUCCESS(reply.result))
m_ages.Set(reply.ages, reply.ageCount);
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* AccountSetRolesRequestTrans
*
***/
//============================================================================
AccountSetRolesRequestTrans::AccountSetRolesRequestTrans (
const wchar_t accountName[],
unsigned accountFlags,
FNetCliAuthAccountSetRolesRequestCallback callback,
void * param
) : NetAuthTrans(kAccountSetRolesRequestTrans)
, m_callback(callback)
, m_param(param)
, m_accountFlags(accountFlags)
{
StrCopy(m_accountName, accountName, arrsize(m_accountName));
}
//============================================================================
bool AccountSetRolesRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_AcctSetRolesRequest,
m_transId,
(uintptr_t) m_accountName,
m_accountFlags,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void AccountSetRolesRequestTrans::Post () {
m_callback(
m_result,
m_param
);
}
//============================================================================
bool AccountSetRolesRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_AcctSetRolesReply & reply = *(const Auth2Cli_AcctSetRolesReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* AccountSetBillingTypeRequestTrans
*
***/
//============================================================================
AccountSetBillingTypeRequestTrans::AccountSetBillingTypeRequestTrans (
const wchar_t accountName[],
unsigned billingType,
FNetCliAuthAccountSetBillingTypeRequestCallback callback,
void * param
) : NetAuthTrans(kAccountSetBillingTypeRequestTrans)
, m_callback(callback)
, m_param(param)
, m_billingType(billingType)
{
StrCopy(m_accountName, accountName, arrsize(m_accountName));
}
//============================================================================
bool AccountSetBillingTypeRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_AcctSetBillingTypeRequest,
m_transId,
(uintptr_t) m_accountName,
m_billingType,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void AccountSetBillingTypeRequestTrans::Post () {
m_callback(
m_result,
m_param
);
}
//============================================================================
bool AccountSetBillingTypeRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_AcctSetBillingTypeReply & reply = *(const Auth2Cli_AcctSetBillingTypeReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* AccountActivateRequestTrans
*
***/
//============================================================================
AccountActivateRequestTrans::AccountActivateRequestTrans (
const plUUID& activationKey,
FNetCliAuthAccountActivateRequestCallback callback,
void * param
) : NetAuthTrans(kAccountActivateRequestTrans)
, m_callback(callback)
, m_param(param)
{
m_activationKey = activationKey;
}
//============================================================================
bool AccountActivateRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_AcctActivateRequest,
m_transId,
(uintptr_t) &m_activationKey,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void AccountActivateRequestTrans::Post () {
m_callback(
m_result,
m_param
);
}
//============================================================================
bool AccountActivateRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_AcctActivateReply & reply = *(const Auth2Cli_AcctActivateReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* FileListRequestTrans
*
***/
//============================================================================
FileListRequestTrans::FileListRequestTrans (
FNetCliAuthFileListRequestCallback callback,
void * param,
const wchar_t directory[],
const wchar_t ext[]
) : NetAuthTrans(kFileListRequestTrans)
, m_callback(callback)
, m_param(param)
{
StrCopy(m_directory, directory, arrsize(m_directory));
StrCopy(m_ext, ext, arrsize(m_ext));
}
//============================================================================
bool FileListRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_FileListRequest,
m_transId,
(uintptr_t) m_directory,
(uintptr_t) m_ext,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void FileListRequestTrans::Post () {
m_callback(m_result, m_param, m_fileInfoArray.Ptr(), m_fileInfoArray.Count());
}
//============================================================================
bool FileListRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_FileListReply & reply = *(const Auth2Cli_FileListReply *) msg;
uint32_t wchar_tCount = reply.wchar_tCount;
const wchar_t* curChar = reply.fileData;
// if wchar_tCount is 2, the data only contains the terminator "\0\0" and we
// don't need to convert anything
if (wchar_tCount == 2)
m_fileInfoArray.Clear();
else
{
// fileData format: "filename\0size\0filename\0size\0...\0\0"
bool done = false;
while (!done) {
if (wchar_tCount == 0)
{
done = true;
break;
}
// read in the filename
wchar_t filename[MAX_PATH];
StrCopy(filename, curChar, arrsize(filename));
filename[arrsize(filename) - 1] = L'\0'; // make sure it's terminated
unsigned filenameLen = StrLen(filename);
curChar += filenameLen; // advance the pointer
wchar_tCount -= filenameLen; // keep track of the amount remaining
if ((*curChar != L'\0') || (wchar_tCount <= 0))
return false; // something is screwy, abort and disconnect
curChar++; // point it at the first part of the size value (format: 0xHHHHLLLL)
wchar_tCount--;
if (wchar_tCount < 4) // we have to have 2 chars for the size, and 2 for terminator at least
return false; // screwy data
unsigned size = ((*curChar) << 16) + (*(curChar + 1));
curChar += 2;
wchar_tCount -= 2;
if ((*curChar != L'\0') || (wchar_tCount <= 0))
return false; // screwy data
// save the data in our array
NetCliAuthFileInfo* info = m_fileInfoArray.New();
StrCopy(info->filename, filename, arrsize(info->filename));
info->filesize = size;
// point it at either the second part of the terminator, or the next filename
curChar++;
wchar_tCount--;
if (*curChar == L'\0')
{
// we hit the terminator
if (wchar_tCount != 1)
return false; // invalid data, we shouldn't have any more
done = true; // we're done
}
else if (wchar_tCount < 6) // we must have at least a 1 char string, '\0', size, and "\0\0" terminator left
return false; // screwy data
}
}
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* FileDownloadRequestTrans
*
***/
//============================================================================
FileDownloadRequestTrans::FileDownloadRequestTrans (
FNetCliAuthFileRequestCallback callback,
void * param,
const plFileName & filename,
hsStream * writer
) : NetAuthTrans(kFileDownloadRequestTrans)
, m_callback(callback)
, m_param(param)
, m_filename(filename)
, m_writer(writer)
{
// This transaction issues "sub transactions" which must complete
// before this one even though they were issued after us.
m_hasSubTrans = true;
}
//============================================================================
bool FileDownloadRequestTrans::Send () {
if (!AcquireConn())
return false;
wchar_t filename[MAX_PATH];
wcsncpy(filename, m_filename.AsString().ToWchar(), arrsize(filename));
const uintptr_t msg[] = {
kCli2Auth_FileDownloadRequest,
m_transId,
reinterpret_cast<uintptr_t>(filename),
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void FileDownloadRequestTrans::Post () {
m_callback(m_result, m_param, m_filename, m_writer);
}
//============================================================================
bool FileDownloadRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_FileDownloadChunk & reply = *(const Auth2Cli_FileDownloadChunk *) msg;
if (IS_NET_ERROR(reply.result)) {
// we have a problem... indicate we are done and abort
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
// we have data to write, so queue it for write in the main thread (we're
// currently in a net recv thread)
if (reply.chunkSize) {
RcvdFileDownloadChunkTrans * writeTrans = new RcvdFileDownloadChunkTrans;
writeTrans->writer = m_writer;
writeTrans->bytes = reply.chunkSize;
writeTrans->offset = reply.chunkOffset;
writeTrans->data = (uint8_t *)malloc(reply.chunkSize);
memcpy(writeTrans->data, reply.chunkData, reply.chunkSize);
NetTransSend(writeTrans);
}
if (reply.chunkOffset + reply.chunkSize >= reply.fileSize) {
// all bytes received, mark as complete
m_result = reply.result;
m_state = kTransStateComplete;
}
// Ack the data
const uintptr_t ack[] = {
kCli2Auth_FileDownloadChunkAck,
m_transId
};
m_conn->Send(ack, arrsize(ack));
return true;
}
/*****************************************************************************
*
* RcvdFileDownloadChunkTrans
*
***/
//============================================================================
RcvdFileDownloadChunkTrans::~RcvdFileDownloadChunkTrans () {
free(data);
}
//============================================================================
void RcvdFileDownloadChunkTrans::Post () {
if (writer->GetPosition() != offset)
writer->SetPosition(offset);
writer->Write(bytes, data);
m_result = kNetSuccess;
m_state = kTransStateComplete;
}
/*****************************************************************************
*
* RcvdPropagatedBufferTrans
*
***/
//============================================================================
RcvdPropagatedBufferTrans::~RcvdPropagatedBufferTrans () {
free(bufferData);
}
//============================================================================
void RcvdPropagatedBufferTrans::Post () {
if (s_bufRcvdCb)
s_bufRcvdCb(bufferType, bufferBytes, bufferData);
}
/*****************************************************************************
*
* VaultNodeChangedTrans
*
***/
//============================================================================
void VaultNodeChangedTrans::Post () {
if (s_vaultNodeChangedHandler)
s_vaultNodeChangedHandler(m_nodeId, m_revId);
}
/*****************************************************************************
*
* VaultNodeAddedTrans
*
***/
//============================================================================
void VaultNodeAddedTrans::Post () {
if (s_vaultNodeAddedHandler)
s_vaultNodeAddedHandler(m_parentId, m_childId, m_ownerId);
}
/*****************************************************************************
*
* VaultNodeRemovedTrans
*
***/
//============================================================================
void VaultNodeRemovedTrans::Post () {
if (s_vaultNodeRemovedHandler)
s_vaultNodeRemovedHandler(m_parentId, m_childId);
}
/*****************************************************************************
*
* VaultNodeDeletedTrans
*
***/
//============================================================================
void VaultNodeDeletedTrans::Post () {
if (s_vaultNodeDeletedHandler)
s_vaultNodeDeletedHandler(m_nodeId);
}
/*****************************************************************************
*
* VaultFetchNodeRefsTrans
*
***/
//============================================================================
VaultFetchNodeRefsTrans::VaultFetchNodeRefsTrans (
unsigned nodeId,
FNetCliAuthVaultNodeRefsFetched callback,
void * param
) : NetAuthTrans(kVaultFetchNodeRefsTrans)
, m_nodeId(nodeId)
, m_callback(callback)
, m_param(param)
{
}
//============================================================================
bool VaultFetchNodeRefsTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_VaultFetchNodeRefs,
m_transId,
m_nodeId,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void VaultFetchNodeRefsTrans::Post () {
if (m_callback)
m_callback(
m_result,
m_param,
m_refs.Ptr(),
m_refs.Count()
);
}
//============================================================================
bool VaultFetchNodeRefsTrans::Recv (
const uint8_t msg[],
unsigned
) {
const Auth2Cli_VaultNodeRefsFetched & reply = *(const Auth2Cli_VaultNodeRefsFetched *) msg;
if (IS_NET_SUCCESS(reply.result))
m_refs.Set(reply.refs, reply.refCount);
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* VaultInitAgeTrans
*
***/
//============================================================================
VaultInitAgeTrans::VaultInitAgeTrans (
FNetCliAuthAgeInitCallback callback, // optional
void * param, // optional
const plUUID& ageInstId, // optional. is used in match
const plUUID& parentAgeInstId, // optional. is used in match
const plString ageFilename, // optional. is used in match
const plString ageInstName, // optional. not used in match
const plString ageUserName, // optional. not used in match
const plString ageDesc, // optional. not used in match
unsigned ageSequenceNumber, // optional. not used in match
unsigned ageLanguage // optional. not used in match
) : NetAuthTrans(kVaultInitAgeTrans)
, m_callback(callback)
, m_param(param)
, m_ageInstId(ageInstId)
, m_parentAgeInstId(parentAgeInstId)
, m_ageFilename(ageFilename)
, m_ageInstName(ageInstName)
, m_ageUserName(ageUserName)
, m_ageDesc(ageDesc)
, m_ageSequenceNumber(ageSequenceNumber)
, m_ageLanguage(ageLanguage)
, m_ageId(0)
, m_ageInfoId(0)
{
}
//============================================================================
VaultInitAgeTrans::~VaultInitAgeTrans () {
}
//============================================================================
bool VaultInitAgeTrans::Send () {
if (!AcquireConn())
return false;
plStringBuffer<uint16_t> ageFilename = m_ageFilename.ToUtf16();
plStringBuffer<uint16_t> ageInstName = m_ageInstName.ToUtf16();
plStringBuffer<uint16_t> ageUserName = m_ageUserName.ToUtf16();
plStringBuffer<uint16_t> ageDesc = m_ageDesc.ToUtf16();
const uintptr_t msg[] = {
kCli2Auth_VaultInitAgeRequest,
m_transId,
(uintptr_t) &m_ageInstId,
(uintptr_t) &m_parentAgeInstId,
(uintptr_t) ageFilename.GetData(),
(uintptr_t) ageInstName.GetData(),
(uintptr_t) ageUserName.GetData(),
(uintptr_t) ageDesc.GetData(),
m_ageSequenceNumber,
m_ageLanguage,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void VaultInitAgeTrans::Post () {
if (m_callback)
m_callback(
m_result,
m_param,
m_ageId,
m_ageInfoId
);
}
//============================================================================
bool VaultInitAgeTrans::Recv (
const uint8_t msg[],
unsigned
) {
const Auth2Cli_VaultInitAgeReply & reply = *(const Auth2Cli_VaultInitAgeReply *) msg;
m_ageId = reply.ageVaultId;
m_ageInfoId = reply.ageInfoVaultId;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* VaultFetchNodeTrans
*
***/
//============================================================================
VaultFetchNodeTrans::VaultFetchNodeTrans (
unsigned nodeId,
FNetCliAuthVaultNodeFetched callback,
void * param
) : NetAuthTrans(kVaultFetchNodeTrans)
, m_nodeId(nodeId)
, m_callback(callback)
, m_param(param)
, m_node(nil)
{
}
//============================================================================
bool VaultFetchNodeTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_VaultNodeFetch,
m_transId,
m_nodeId,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void VaultFetchNodeTrans::Post () {
m_callback(
m_result,
m_param,
m_node
);
}
//============================================================================
bool VaultFetchNodeTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_VaultNodeFetched & reply = *(const Auth2Cli_VaultNodeFetched *) msg;
if (IS_NET_SUCCESS(reply.result)) {
m_node = new NetVaultNode;
m_node->Read(reply.nodeBuffer, reply.nodeBytes);
}
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* VaultFindNodeTrans
*
***/
//============================================================================
VaultFindNodeTrans::VaultFindNodeTrans (
NetVaultNode * templateNode,
FNetCliAuthVaultNodeFind callback,
void * param
) : NetAuthTrans(kVaultFindNodeTrans)
, m_callback(callback)
, m_param(param)
, m_node(templateNode)
{
}
//============================================================================
bool VaultFindNodeTrans::Send () {
if (!AcquireConn())
return false;
ARRAY(uint8_t) buffer;
m_node->Write(&buffer);
const uintptr_t msg[] = {
kCli2Auth_VaultNodeFind,
m_transId,
buffer.Count(),
(uintptr_t) buffer.Ptr(),
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void VaultFindNodeTrans::Post () {
m_callback(
m_result,
m_param,
m_nodeIds.Count(),
m_nodeIds.Ptr()
);
}
//============================================================================
bool VaultFindNodeTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_VaultNodeFindReply & reply = *(const Auth2Cli_VaultNodeFindReply *) msg;
if (IS_NET_SUCCESS(reply.result)) {
static_assert(sizeof(unsigned) == sizeof(uint32_t), "unsigned is not the same size as uint32_t");
m_nodeIds.Set((unsigned *)reply.nodeIds, reply.nodeIdCount);
}
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* VaultCreateNodeTrans
*
***/
//============================================================================
VaultCreateNodeTrans::VaultCreateNodeTrans (
NetVaultNode * templateNode,
FNetCliAuthVaultNodeCreated callback,
void * param
) : NetAuthTrans(kVaultCreateNodeTrans)
, m_templateNode(templateNode)
, m_callback(callback)
, m_param(param)
, m_nodeId(0)
{
}
//============================================================================
bool VaultCreateNodeTrans::Send () {
if (!AcquireConn())
return false;
ARRAY(uint8_t) buffer;
m_templateNode->Write(&buffer, 0);
const uintptr_t msg[] = {
kCli2Auth_VaultNodeCreate,
m_transId,
buffer.Count(),
(uintptr_t) buffer.Ptr()
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void VaultCreateNodeTrans::Post () {
m_callback(
m_result,
m_param,
m_nodeId
);
}
//============================================================================
bool VaultCreateNodeTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_VaultNodeCreated & reply = *(const Auth2Cli_VaultNodeCreated *) msg;
if (IS_NET_SUCCESS(reply.result))
m_nodeId = reply.nodeId;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* VaultSaveNodeTrans
*
***/
//============================================================================
VaultSaveNodeTrans::VaultSaveNodeTrans (
unsigned nodeId,
const plUUID& revisionId,
unsigned dataCount,
const void * data,
FNetCliAuthVaultNodeSaveCallback callback,
void * param
) : NetAuthTrans(kVaultSaveNodeTrans)
, m_nodeId(nodeId)
, m_revisionId(revisionId)
, m_callback(callback)
, m_param(param)
{
m_buffer.Set((const uint8_t *)data, dataCount);
}
//============================================================================
bool VaultSaveNodeTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_VaultNodeSave,
m_transId,
m_nodeId,
(uintptr_t) &m_revisionId,
m_buffer.Count(),
(uintptr_t) m_buffer.Ptr(),
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void VaultSaveNodeTrans::Post () {
if (m_callback) {
m_callback(
m_result,
m_param
);
}
}
//============================================================================
bool VaultSaveNodeTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_VaultSaveNodeReply & reply = *(const Auth2Cli_VaultSaveNodeReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* VaultAddNodeTrans
*
***/
//============================================================================
VaultAddNodeTrans::VaultAddNodeTrans (
unsigned parentId,
unsigned childId,
unsigned ownerId,
FNetCliAuthVaultNodeAddCallback callback,
void * param
) : NetAuthTrans(kVaultAddNodeTrans)
, m_parentId(parentId)
, m_childId(childId)
, m_ownerId(ownerId)
, m_callback(callback)
, m_param(param)
{
}
//============================================================================
bool VaultAddNodeTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_VaultNodeAdd,
m_transId,
m_parentId,
m_childId,
m_ownerId,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void VaultAddNodeTrans::Post () {
if (m_callback) {
m_callback(
m_result,
m_param
);
}
}
//============================================================================
bool VaultAddNodeTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_VaultAddNodeReply & reply = *(const Auth2Cli_VaultAddNodeReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* VaultRemoveNodeTrans
*
***/
//============================================================================
VaultRemoveNodeTrans::VaultRemoveNodeTrans (
unsigned parentId,
unsigned childId,
FNetCliAuthVaultNodeRemoveCallback callback,
void * param
) : NetAuthTrans(kVaultRemoveNodeTrans)
, m_parentId(parentId)
, m_childId(childId)
, m_callback(callback)
, m_param(param)
{
}
//============================================================================
bool VaultRemoveNodeTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_VaultNodeRemove,
m_transId,
m_parentId,
m_childId,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void VaultRemoveNodeTrans::Post () {
if (m_callback) {
m_callback(
m_result,
m_param
);
}
}
//============================================================================
bool VaultRemoveNodeTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_VaultRemoveNodeReply & reply = *(const Auth2Cli_VaultRemoveNodeReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* NotifyNewBuildTrans
*
***/
//============================================================================
void NotifyNewBuildTrans::Post () {
if (s_notifyNewBuildHandler)
s_notifyNewBuildHandler();
}
/*****************************************************************************
*
* SetPlayerBanStatusRequestTrans
*
***/
//============================================================================
SetPlayerBanStatusRequestTrans::SetPlayerBanStatusRequestTrans (
unsigned playerId,
unsigned banned,
FNetCliAuthSetPlayerBanStatusRequestCallback callback,
void * param
) : NetAuthTrans(kSetPlayerBanStatusRequestTrans)
, m_callback(callback)
, m_param(param)
, m_playerId(playerId)
, m_banned(banned)
{
}
//============================================================================
bool SetPlayerBanStatusRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_SetPlayerBanStatusRequest,
m_transId,
m_playerId,
m_banned,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void SetPlayerBanStatusRequestTrans::Post () {
m_callback(
m_result,
m_param
);
}
//============================================================================
bool SetPlayerBanStatusRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_SetPlayerBanStatusReply & reply = *(const Auth2Cli_SetPlayerBanStatusReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* ChangePlayerNameRequestTrans
*
***/
//============================================================================
ChangePlayerNameRequestTrans::ChangePlayerNameRequestTrans (
unsigned playerId,
const wchar_t newName[],
FNetCliAuthChangePlayerNameRequestCallback callback,
void * param
) : NetAuthTrans(kChangePlayerNameRequestTrans)
, m_callback(callback)
, m_param(param)
, m_playerId(playerId)
{
StrCopy(m_newName, newName, arrsize(m_newName));
}
//============================================================================
bool ChangePlayerNameRequestTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_ChangePlayerNameRequest,
m_transId,
m_playerId,
(uintptr_t) m_newName,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void ChangePlayerNameRequestTrans::Post () {
m_callback(
m_result,
m_param
);
}
//============================================================================
bool ChangePlayerNameRequestTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_ChangePlayerNameReply & reply = *(const Auth2Cli_ChangePlayerNameReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* SendFriendInviteTrans
*
***/
//============================================================================
SendFriendInviteTrans::SendFriendInviteTrans (
const plString& emailAddr,
const plString& toName,
const plUUID& inviteUuid,
FNetCliAuthSendFriendInviteCallback callback,
void * param
) : NetAuthTrans(kSendFriendInviteTrans)
, m_callback(callback)
, m_param(param)
, m_inviteUuid(inviteUuid)
, m_toName(toName)
, m_emailAddress(emailAddr)
{
}
//============================================================================
bool SendFriendInviteTrans::Send () {
if (!AcquireConn())
return false;
plStringBuffer<uint16_t> emailAddress = m_emailAddress.ToUtf16();
plStringBuffer<uint16_t> toName = m_toName.ToUtf16();
const uintptr_t msg[] = {
kCli2Auth_SendFriendInviteRequest,
m_transId,
(uintptr_t) &m_inviteUuid,
(uintptr_t) emailAddress.GetData(),
(uintptr_t) toName.GetData(),
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void SendFriendInviteTrans::Post () {
m_callback(
m_result,
m_param
);
}
//============================================================================
bool SendFriendInviteTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_SendFriendInviteReply & reply = *(const Auth2Cli_SendFriendInviteReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* AuthConnectedNotifyTrans
*
***/
//============================================================================
void AuthConnectedNotifyTrans::Post() {
if (s_connectedCb != nil)
s_connectedCb();
}
/*****************************************************************************
*
* ScoreCreateTrans
*
***/
//============================================================================
ScoreCreateTrans::ScoreCreateTrans (
unsigned ownerId,
const plString& gameName,
unsigned gameType,
int value,
FNetCliAuthCreateScoreCallback callback,
void * param
) : NetAuthTrans(kScoreCreateTrans)
, m_callback(callback)
, m_param(param)
, m_ownerId(ownerId)
, m_gameName(gameName)
, m_gameType(gameType)
, m_value(value)
, m_scoreId(0)
, m_createdTime(0)
{
}
//============================================================================
bool ScoreCreateTrans::Send () {
if (!AcquireConn())
return false;
plStringBuffer<uint16_t> gameName = m_gameName.ToUtf16();
const uintptr_t msg[] = {
kCli2Auth_ScoreCreate,
m_transId,
m_ownerId,
(uintptr_t) gameName.GetData(),
m_gameType,
(uintptr_t) m_value
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void ScoreCreateTrans::Post () {
if (m_callback) {
m_callback(
m_result,
m_param,
m_scoreId,
m_createdTime,
m_ownerId,
m_gameName,
m_gameType,
m_value
);
}
}
//============================================================================
bool ScoreCreateTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_ScoreCreateReply & reply = *(const Auth2Cli_ScoreCreateReply *) msg;
m_scoreId = reply.scoreId;
m_createdTime = reply.createdTime;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* ScoreDeleteTrans
*
***/
//============================================================================
ScoreDeleteTrans::ScoreDeleteTrans (
unsigned scoreId,
FNetCliAuthScoreUpdateCallback callback,
void * param
) : NetAuthTrans(kScoreDeleteTrans)
, m_callback(callback)
, m_param(param)
, m_scoreId(scoreId)
{
}
//============================================================================
bool ScoreDeleteTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_ScoreDelete,
m_transId,
m_scoreId,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void ScoreDeleteTrans::Post () {
if (m_callback) {
m_callback(
m_result,
m_param
);
}
}
//============================================================================
bool ScoreDeleteTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_ScoreDeleteReply & reply = *(const Auth2Cli_ScoreDeleteReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* ScoreGetScoresTrans
*
***/
//============================================================================
ScoreGetScoresTrans::ScoreGetScoresTrans (
unsigned ownerId,
const plString& gameName,
FNetCliAuthGetScoresCallback callback,
void * param
) : NetAuthTrans(kScoreGetScoresTrans)
, m_callback(callback)
, m_param(param)
, m_ownerId(ownerId)
, m_gameName(gameName)
, m_scores(nullptr)
, m_scoreCount(0)
{
}
//============================================================================
ScoreGetScoresTrans::~ScoreGetScoresTrans () {
delete[] m_scores;
}
//============================================================================
bool ScoreGetScoresTrans::Send () {
if (!AcquireConn())
return false;
plStringBuffer<uint16_t> gameName = m_gameName.ToUtf16();
const uintptr_t msg[] = {
kCli2Auth_ScoreGetScores,
m_transId,
m_ownerId,
(uintptr_t) gameName.GetData()
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void ScoreGetScoresTrans::Post () {
if (m_callback) {
m_callback(
m_result,
m_param,
m_scores,
m_scoreCount
);
}
}
//============================================================================
bool ScoreGetScoresTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_ScoreGetScoresReply & reply = *(const Auth2Cli_ScoreGetScoresReply *) msg;
if (reply.scoreCount > 0) {
m_scoreCount = reply.scoreCount;
m_scores = new NetGameScore[m_scoreCount];
uint8_t* bufferPos = const_cast<uint8_t*>(reply.buffer);
unsigned bufferLength = reply.byteCount;
for (unsigned i = 0; i < m_scoreCount; ++i) {
bufferLength -= m_scores[i].Read(bufferPos, bufferLength, &bufferPos);
}
}
else {
m_scoreCount = 0;
m_scores = nil;
}
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* ScoreAddPointsTrans
*
***/
//============================================================================
ScoreAddPointsTrans::ScoreAddPointsTrans (
unsigned scoreId,
int numPoints,
FNetCliAuthScoreUpdateCallback callback,
void * param
) : NetAuthTrans(kScoreAddPointsTrans)
, m_callback(callback)
, m_param(param)
, m_scoreId(scoreId)
, m_numPoints(numPoints)
{
}
//============================================================================
bool ScoreAddPointsTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_ScoreAddPoints,
m_transId,
m_scoreId,
(uintptr_t)m_numPoints,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void ScoreAddPointsTrans::Post () {
if (m_callback) {
m_callback(
m_result,
m_param
);
}
}
//============================================================================
bool ScoreAddPointsTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_ScoreAddPointsReply & reply = *(const Auth2Cli_ScoreAddPointsReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* ScoreTransferPointsTrans
*
***/
//============================================================================
ScoreTransferPointsTrans::ScoreTransferPointsTrans (
unsigned srcScoreId,
unsigned destScoreId,
int numPoints,
FNetCliAuthScoreUpdateCallback callback,
void * param
) : NetAuthTrans(kScoreTransferPointsTrans)
, m_callback(callback)
, m_param(param)
, m_srcScoreId(srcScoreId)
, m_destScoreId(destScoreId)
, m_numPoints(numPoints)
{
}
//============================================================================
bool ScoreTransferPointsTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_ScoreTransferPoints,
m_transId,
m_srcScoreId,
m_destScoreId,
(uintptr_t)m_numPoints,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void ScoreTransferPointsTrans::Post () {
if (m_callback) {
m_callback(
m_result,
m_param
);
}
}
//============================================================================
bool ScoreTransferPointsTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_ScoreTransferPointsReply & reply = *(const Auth2Cli_ScoreTransferPointsReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* ScoreSetPointsTrans
*
***/
//============================================================================
ScoreSetPointsTrans::ScoreSetPointsTrans (
unsigned scoreId,
int numPoints,
FNetCliAuthScoreUpdateCallback callback,
void * param
) : NetAuthTrans(kScoreSetPointsTrans)
, m_callback(callback)
, m_param(param)
, m_scoreId(scoreId)
, m_numPoints(numPoints)
{
}
//============================================================================
bool ScoreSetPointsTrans::Send () {
if (!AcquireConn())
return false;
const uintptr_t msg[] = {
kCli2Auth_ScoreSetPoints,
m_transId,
m_scoreId,
(uintptr_t)m_numPoints,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void ScoreSetPointsTrans::Post () {
if (m_callback) {
m_callback(
m_result,
m_param
);
}
}
//============================================================================
bool ScoreSetPointsTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_ScoreSetPointsReply & reply = *(const Auth2Cli_ScoreSetPointsReply *) msg;
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* ScoreGetRanksTrans
*
***/
//============================================================================
ScoreGetRanksTrans::ScoreGetRanksTrans (
unsigned ownerId,
unsigned scoreGroup,
unsigned parentFolderId,
const plString& gameName,
unsigned timePeriod,
unsigned numResults,
unsigned pageNumber,
bool sortDesc,
FNetCliAuthGetRanksCallback callback,
void * param
) : NetAuthTrans(kScoreGetRanksTrans)
, m_callback(callback)
, m_param(param)
, m_ownerId(ownerId)
, m_scoreGroup(scoreGroup)
, m_parentFolderId(parentFolderId)
, m_gameName(gameName)
, m_timePeriod(timePeriod)
, m_numResults(numResults)
, m_pageNumber(pageNumber)
, m_sortDesc(sortDesc)
{
}
//============================================================================
bool ScoreGetRanksTrans::Send () {
if (!AcquireConn())
return false;
plStringBuffer<uint16_t> gameName = m_gameName.ToUtf16();
const uintptr_t msg[] = {
kCli2Auth_ScoreGetRanks,
m_transId,
m_ownerId,
m_scoreGroup,
m_parentFolderId,
(uintptr_t) gameName.GetData(),
m_timePeriod,
m_numResults,
m_pageNumber,
m_sortDesc,
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void ScoreGetRanksTrans::Post () {
if (m_callback) {
m_callback(
m_result,
m_param,
m_ranks,
m_rankCount
);
}
}
//============================================================================
bool ScoreGetRanksTrans::Recv (
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_ScoreGetRanksReply & reply = *(const Auth2Cli_ScoreGetRanksReply *) msg;
if (reply.rankCount > 0) {
m_rankCount = reply.rankCount;
m_ranks = new NetGameRank[m_rankCount];
uint8_t* bufferPos = const_cast<uint8_t*>(reply.buffer);
unsigned bufferLength = reply.byteCount;
for (unsigned i = 0; i < m_rankCount; ++i) {
bufferLength -= m_ranks[i].Read(bufferPos, bufferLength, &bufferPos);
}
}
else {
m_rankCount = 0;
m_ranks = nil;
}
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
/*****************************************************************************
*
* ScoreGetHighScoresTrans
*
***/
//============================================================================
ScoreGetHighScoresTrans::ScoreGetHighScoresTrans(
unsigned ageId,
unsigned maxScores,
const plString& gameName,
FNetCliAuthGetScoresCallback callback,
void * param
) : NetAuthTrans(kScoreGetHighScoresTrans)
, m_callback(callback)
, m_param(param)
, m_ageId(ageId)
, m_maxScores(maxScores)
, m_gameName(gameName)
, m_scores(nullptr)
, m_scoreCount(0)
{
}
//============================================================================
ScoreGetHighScoresTrans::~ScoreGetHighScoresTrans() {
delete[] m_scores;
}
//============================================================================
bool ScoreGetHighScoresTrans::Send() {
if (!AcquireConn())
return false;
plStringBuffer<uint16_t> gameName = m_gameName.ToUtf16();
const uintptr_t msg[] = {
kCli2Auth_ScoreGetHighScores,
m_transId,
m_ageId,
m_maxScores,
(uintptr_t)gameName.GetData()
};
m_conn->Send(msg, arrsize(msg));
return true;
}
//============================================================================
void ScoreGetHighScoresTrans::Post() {
if (m_callback) {
m_callback(
m_result,
m_param,
m_scores,
m_scoreCount
);
}
}
//============================================================================
bool ScoreGetHighScoresTrans::Recv(
const uint8_t msg[],
unsigned bytes
) {
const Auth2Cli_ScoreGetHighScoresReply & reply = *(const Auth2Cli_ScoreGetHighScoresReply *)msg;
if (reply.scoreCount > 0) {
m_scoreCount = reply.scoreCount;
m_scores = new NetGameScore[m_scoreCount];
uint8_t* bufferPos = const_cast<uint8_t*>(reply.buffer);
unsigned bufferLength = reply.byteCount;
for (unsigned i = 0; i < m_scoreCount; ++i) {
bufferLength -= m_scores[i].Read(bufferPos, bufferLength, &bufferPos);
}
}
else {
m_scoreCount = 0;
m_scores = nullptr;
}
m_result = reply.result;
m_state = kTransStateComplete;
return true;
}
} using namespace Auth;
/*****************************************************************************
*
* NetAuthTrans
*
***/
//============================================================================
NetAuthTrans::NetAuthTrans (ETransType transType)
: NetTrans(kNetProtocolCli2Auth, transType)
, m_conn(nil)
{
}
//============================================================================
NetAuthTrans::~NetAuthTrans () {
ReleaseConn();
}
//============================================================================
bool NetAuthTrans::AcquireConn () {
if (!m_conn)
m_conn = GetConnIncRef("AcquireConn");
return m_conn != nil;
}
//============================================================================
void NetAuthTrans::ReleaseConn () {
if (m_conn) {
m_conn->UnRef("AcquireConn");
m_conn = nil;
}
}
/*****************************************************************************
*
* Protected functions
*
***/
//============================================================================
void AuthInitialize () {
s_running = true;
NetMsgProtocolRegister(
kNetProtocolCli2Auth,
false,
s_send, arrsize(s_send),
s_recv, arrsize(s_recv),
kAuthDhGValue,
plBigNum(sizeof(kAuthDhXData), kAuthDhXData),
plBigNum(sizeof(kAuthDhNData), kAuthDhNData)
);
}
//============================================================================
void AuthDestroy (bool wait) {
s_running = false;
s_bufRcvdCb = nil;
s_connectedCb = nil;
s_vaultNodeChangedHandler = nil;
s_vaultNodeAddedHandler = nil;
s_vaultNodeRemovedHandler = nil;
s_vaultNodeDeletedHandler = nil;
s_notifyNewBuildHandler = nil;
NetTransCancelByProtocol(
kNetProtocolCli2Auth,
kNetErrRemoteShutdown
);
NetMsgProtocolDestroy(
kNetProtocolCli2Auth,
false
);
s_critsect.Enter();
{
while (CliAuConn * conn = s_conns.Head())
UnlinkAndAbandonConn_CS(conn);
s_active = nil;
}
s_critsect.Leave();
if (!wait)
return;
while (s_perf[kPerfConnCount]) {
NetTransUpdate();
AsyncSleep(10);
}
}
//============================================================================
bool AuthQueryConnected () {
bool result;
s_critsect.Enter();
{
result = (s_active && s_active->cli);
}
s_critsect.Leave();
return result;
}
//============================================================================
unsigned AuthGetConnId () {
unsigned connId;
s_critsect.Enter();
connId = (s_active) ? s_active->seq : 0;
s_critsect.Leave();
return connId;
}
//============================================================================
void AuthPingEnable (bool enable) {
s_perf[kPingDisabled] = !enable;
s_critsect.Enter();
for (;;) {
if (!s_active)
break;
if (enable)
s_active->AutoPing();
else
s_active->StopAutoPing();
break;
}
s_critsect.Leave();
}
} using namespace Ngl;
/*****************************************************************************
*
* Exported functions
*
***/
//============================================================================
void NetCliAuthStartConnect (
const plString authAddrList[],
uint32_t authAddrCount
) {
// TEMP: Only connect to one auth server until we fill out this module
// to choose the "best" auth connection.
authAddrCount = std::min(authAddrCount, 1u);
for (unsigned i = 0; i < authAddrCount; ++i) {
// Do we need to lookup the address?
const char* name = authAddrList[i].c_str();
while (unsigned ch = *name) {
++name;
if (!(isdigit(ch) || ch == L'.' || ch == L':')) {
AsyncCancelId cancelId;
AsyncAddressLookupName(
&cancelId,
AsyncLookupCallback,
authAddrList[i].c_str(),
GetClientPort(),
nil
);
break;
}
}
if (!name[0]) {
plNetAddress addr(authAddrList[i], GetClientPort());
Connect(authAddrList[i], addr);
}
}
}
//============================================================================
bool NetCliAuthQueryConnected () {
return AuthQueryConnected();
}
//============================================================================
void NetCliAuthAutoReconnectEnable (bool enable) {
s_perf[kAutoReconnectDisabled] = !enable;
}
//============================================================================
void NetCliAuthDisconnect () {
s_critsect.Enter();
{
while (CliAuConn * conn = s_conns.Head())
UnlinkAndAbandonConn_CS(conn);
s_active = nil;
}
s_critsect.Leave();
}
//============================================================================
void NetCliAuthUnexpectedDisconnect () {
s_critsect.Enter();
{
if (s_active && s_active->sock)
AsyncSocketDisconnect(s_active->sock, true);
}
s_critsect.Leave();
}
//============================================================================
void NetCliAuthSetConnectCallback (
FNetCliAuthConnectCallback callback
) {
s_connectedCb = callback;
}
//============================================================================
void NetCliAuthPingRequest (
unsigned pingTimeMs,
unsigned payloadBytes,
const void * payload,
FNetCliAuthPingRequestCallback callback,
void * param
) {
PingRequestTrans * trans = new PingRequestTrans(
callback,
param,
pingTimeMs,
payloadBytes,
payload
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthAccountExistsRequest (
const wchar_t accountName[],
FNetCliAuthAccountExistsRequestCallback callback,
void * param
) {
AccountExistsRequestTrans * trans = new AccountExistsRequestTrans(
callback,
param,
accountName
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthLoginRequest (
const plString& accountName,
const ShaDigest * accountNamePassHash,
const wchar_t authToken[],
const wchar_t os[],
FNetCliAuthLoginRequestCallback callback,
void * param
) {
// Cache updated login info if provided.
if (!accountName.IsEmpty())
s_accountName = accountName;
if (accountNamePassHash)
memcpy(s_accountNamePassHash, *accountNamePassHash, sizeof(ShaDigest));
if (authToken)
StrCopy(s_authToken, authToken, arrsize(s_authToken));
if (os)
StrCopy(s_os, os, arrsize(s_os));
LoginRequestTrans * trans = new LoginRequestTrans(callback, param);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthAgeRequest (
const plString& ageName,
const plUUID& ageInstId,
FNetCliAuthAgeRequestCallback callback,
void * param
) {
AgeRequestTrans * trans = new AgeRequestTrans(
ageName,
ageInstId,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthGetEncryptionKey (
uint32_t key[],
size_t size
) {
unsigned memSize = std::min(arrsize(s_encryptionKey), size);
memSize *= sizeof(uint32_t);
memcpy(key, s_encryptionKey, memSize);
}
//============================================================================
void NetCliAuthAccountCreateRequest (
const wchar_t accountName[],
const wchar_t password[],
unsigned accountFlags,
unsigned billingType,
FNetCliAuthAccountCreateRequestCallback callback,
void * param
) {
AccountCreateRequestTrans * trans = new AccountCreateRequestTrans(
accountName,
password,
accountFlags,
billingType,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthAccountCreateFromKeyRequest (
const wchar_t accountName[],
const wchar_t password[],
plUUID key,
unsigned billingType,
FNetCliAuthAccountCreateFromKeyRequestCallback callback,
void * param
) {
AccountCreateFromKeyRequestTrans * trans = new AccountCreateFromKeyRequestTrans(
accountName,
password,
key,
billingType,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthPlayerCreateRequest (
const plString& playerName,
const plString& avatarShape,
const plString& friendInvite,
FNetCliAuthPlayerCreateRequestCallback callback,
void * param
) {
plString name = playerName;
ENetError error = FixupPlayerName(name);
if (IS_NET_ERROR(error)) {
NetCliAuthPlayerInfo playerInfo;
callback(error, param, playerInfo);
}
else {
PlayerCreateRequestTrans * trans = new PlayerCreateRequestTrans(
name,
avatarShape,
friendInvite,
callback,
param
);
NetTransSend(trans);
}
}
//============================================================================
void NetCliAuthPlayerDeleteRequest (
unsigned playerId,
FNetCliAuthPlayerDeleteRequestCallback callback,
void * param
) {
PlayerDeleteRequestTrans * trans = new PlayerDeleteRequestTrans(
playerId,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthUpgradeVisitorRequest (
unsigned playerId,
FNetCliAuthUpgradeVisitorRequestCallback callback,
void * param
) {
UpgradeVisitorRequestTrans * trans = new UpgradeVisitorRequestTrans(
playerId,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthSetCCRLevel (
unsigned ccrLevel
) {
CliAuConn * conn = GetConnIncRef("SetCCRLevel");
if (!conn)
return;
const uintptr_t msg[] = {
kCli2Auth_ClientSetCCRLevel,
ccrLevel,
};
conn->Send(msg, arrsize(msg));
conn->UnRef("SetCCRLevel");
}
//============================================================================
void NetCliAuthSetPlayerRequest (
unsigned playerInt,
FNetCliAuthSetPlayerRequestCallback callback,
void * param
) {
SetPlayerRequestTrans * trans = new SetPlayerRequestTrans(
playerInt,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthSetAgePublic (
unsigned ageInfoId,
bool publicOrNot
) {
CliAuConn * conn = GetConnIncRef("SetAgePublic");
if (!conn)
return;
const uintptr_t msg[] = {
kCli2Auth_SetAgePublic,
ageInfoId,
publicOrNot,
};
conn->Send(msg, arrsize(msg));
conn->UnRef("SetAgePublic");
}
//============================================================================
void NetCliAuthGetPublicAgeList (
const plString& ageName,
FNetCliAuthGetPublicAgeListCallback callback,
void * param
) {
GetPublicAgeListTrans * trans = new GetPublicAgeListTrans(
ageName,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthAccountChangePasswordRequest (
const plString& accountName,
const plString& password,
FNetCliAuthAccountChangePasswordRequestCallback callback,
void * param
) {
AccountChangePasswordRequestTrans * trans = new AccountChangePasswordRequestTrans(
accountName,
password,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthAccountSetRolesRequest (
const wchar_t accountName[],
unsigned accountFlags,
FNetCliAuthAccountSetRolesRequestCallback callback,
void * param
) {
AccountSetRolesRequestTrans * trans = new AccountSetRolesRequestTrans(
accountName,
accountFlags,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthAccountSetBillingTypeRequest (
const wchar_t accountName[],
unsigned billingType,
FNetCliAuthAccountSetBillingTypeRequestCallback callback,
void * param
) {
AccountSetBillingTypeRequestTrans * trans = new AccountSetBillingTypeRequestTrans(
accountName,
billingType,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthAccountActivateRequest (
const plUUID& activationKey,
FNetCliAuthAccountActivateRequestCallback callback,
void * param
) {
AccountActivateRequestTrans * trans = new AccountActivateRequestTrans(
activationKey,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthFileListRequest (
const wchar_t dir[],
const wchar_t ext[],
FNetCliAuthFileListRequestCallback callback,
void * param
) {
FileListRequestTrans * trans = new FileListRequestTrans(
callback,
param,
dir,
ext
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthFileRequest (
const plFileName & filename,
hsStream * writer,
FNetCliAuthFileRequestCallback callback,
void * param
) {
FileDownloadRequestTrans * trans = new FileDownloadRequestTrans(
callback,
param,
filename,
writer
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthVaultSetRecvNodeChangedHandler (
FNetCliAuthVaultNodeChanged handler
) {
s_vaultNodeChangedHandler = handler;
}
//============================================================================
void NetCliAuthVaultSetRecvNodeAddedHandler (
FNetCliAuthVaultNodeAdded handler
) {
s_vaultNodeAddedHandler = handler;
}
//============================================================================
void NetCliAuthVaultSetRecvNodeRemovedHandler (
FNetCliAuthVaultNodeRemoved handler
) {
s_vaultNodeRemovedHandler = handler;
}
//============================================================================
void NetCliAuthVaultSetRecvNodeDeletedHandler (
FNetCliAuthVaultNodeDeleted handler
) {
s_vaultNodeDeletedHandler = handler;
}
//============================================================================
void NetCliAuthVaultNodeCreate (
NetVaultNode * templateNode,
FNetCliAuthVaultNodeCreated callback,
void * param
) {
VaultCreateNodeTrans * trans = new VaultCreateNodeTrans(
templateNode,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthVaultNodeFetch (
unsigned nodeId,
FNetCliAuthVaultNodeFetched callback,
void * param
) {
VaultFetchNodeTrans * trans = new VaultFetchNodeTrans(
nodeId,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthVaultNodeFind (
NetVaultNode * templateNode,
FNetCliAuthVaultNodeFind callback,
void * param
) {
VaultFindNodeTrans * trans = new VaultFindNodeTrans(
templateNode,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
unsigned NetCliAuthVaultNodeSave (
NetVaultNode * node,
FNetCliAuthVaultNodeSaveCallback callback,
void * param
) {
if (!node->IsDirty())
return 0;
if (!node->GetNodeId())
return 0;
// We're definitely saving this node, so assign a revisionId
node->GenerateRevision();
// Lots of hacks for MOULa :(
uint32_t ioFlags = NetVaultNode::kDirtyOnly | NetVaultNode::kClearDirty;
if (node->GetNodeType() == plVault::kNodeType_SDL)
ioFlags |= NetVaultNode::kDirtyString64_1;
ioFlags |= NetVaultNode::kDirtyNodeType;
ARRAY(uint8_t) buffer;
node->Write(&buffer, ioFlags);
VaultSaveNodeTrans * trans = new VaultSaveNodeTrans(
node->GetNodeId(),
node->GetRevision(),
buffer.Count(),
buffer.Ptr(),
callback,
param
);
NetTransSend(trans);
return buffer.Count();
}
//============================================================================
void NetCliAuthVaultNodeDelete (
unsigned nodeId
) {
hsAssert(false, "eric, implement me");
}
//============================================================================
void NetCliAuthVaultNodeAdd (
unsigned parentId,
unsigned childId,
unsigned ownerId,
FNetCliAuthVaultNodeAddCallback callback,
void * param
) {
VaultAddNodeTrans * trans = new VaultAddNodeTrans(
parentId,
childId,
ownerId,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthVaultNodeRemove (
unsigned parentId,
unsigned childId,
FNetCliAuthVaultNodeRemoveCallback callback,
void * param
) {
VaultRemoveNodeTrans * trans = new VaultRemoveNodeTrans(
parentId,
childId,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthVaultFetchNodeRefs (
unsigned nodeId,
FNetCliAuthVaultNodeRefsFetched callback,
void * param
) {
VaultFetchNodeRefsTrans * trans = new VaultFetchNodeRefsTrans(
nodeId,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthVaultSetSeen (
unsigned parentId,
unsigned childId,
bool seen
) {
CliAuConn * conn = GetConnIncRef("SetSeen");
if (!conn)
return;
const uintptr_t msg[] = {
kCli2Auth_VaultSetSeen,
parentId,
childId,
seen,
};
conn->Send(msg, arrsize(msg));
conn->UnRef("SetSeen");
}
//============================================================================
void NetCliAuthVaultSendNode (
unsigned srcNodeId,
unsigned dstPlayerId
) {
CliAuConn * conn = GetConnIncRef("SendNode");
if (!conn)
return;
const uintptr_t msg[] = {
kCli2Auth_VaultSendNode,
srcNodeId,
dstPlayerId,
};
conn->Send(msg, arrsize(msg));
conn->UnRef("SendNode");
}
//============================================================================
void NetCliAuthVaultInitAge (
const plUUID& ageInstId, // optional. is used in match
const plUUID& parentAgeInstId, // optional. is used in match
const plString& ageFilename, // optional. is used in match
const plString& ageInstName, // optional. not used in match
const plString& ageUserName, // optional. not used in match
const plString& ageDesc, // optional. not used in match
unsigned ageSequenceNumber, // optional. not used in match
unsigned ageLanguage, // optional. not used in match
FNetCliAuthAgeInitCallback callback, // optional
void * param // optional
) {
VaultInitAgeTrans * trans = new VaultInitAgeTrans(
callback,
param,
ageInstId,
parentAgeInstId,
ageFilename,
ageInstName,
ageUserName,
ageDesc,
ageSequenceNumber,
ageLanguage
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthSetRecvBufferHandler (
FNetCliAuthRecvBufferHandler handler
) {
s_bufRcvdCb = handler;
}
//============================================================================
void NetCliAuthSendCCRPetition (
const plString& petitionText
) {
hsAssert(false, "eric, implement me.");
}
//============================================================================
void NetCliAuthPropagateBuffer (
unsigned type,
unsigned bytes,
const uint8_t buffer[]
) {
CliAuConn * conn = GetConnIncRef("PropBuffer");
if (!conn)
return;
const uintptr_t msg[] = {
kCli2Auth_PropagateBuffer,
type,
bytes,
(uintptr_t) buffer,
};
conn->Send(msg, arrsize(msg));
conn->UnRef("PropBuffer");
}
//============================================================================
void NetCliAuthLogPythonTraceback (const wchar_t traceback[]) {
CliAuConn * conn = GetConnIncRef("LogTraceback");
if (!conn)
return;
const uintptr_t msg[] = {
kCli2Auth_LogPythonTraceback,
(uintptr_t) traceback
};
conn->Send(msg, arrsize(msg));
conn->UnRef("LogTraceback");
}
//============================================================================
void NetCliAuthLogStackDump (const wchar_t stackdump[]) {
CliAuConn * conn = GetConnIncRef("LogStackDump");
if (!conn)
return;
const uintptr_t msg[] = {
kCli2Auth_LogStackDump,
(uintptr_t) stackdump
};
conn->Send(msg, arrsize(msg));
conn->UnRef("LogStackDump");
}
//============================================================================
void NetCliAuthLogClientDebuggerConnect () {
CliAuConn * conn = GetConnIncRef("");
if (!conn)
return;
unsigned nothing = 0;
const uintptr_t msg[] = {
kCli2Auth_LogClientDebuggerConnect,
nothing
};
conn->Send(msg, arrsize(msg));
conn->UnRef();
}
//============================================================================
void NetCliAuthSetNotifyNewBuildHandler (FNotifyNewBuildHandler handler) {
s_notifyNewBuildHandler = handler;
}
//============================================================================
void NetCliAuthSetPlayerBanStatusRequest (
unsigned playerId,
unsigned banned,
FNetCliAuthSetPlayerBanStatusRequestCallback callback,
void * param
) {
SetPlayerBanStatusRequestTrans * trans = new SetPlayerBanStatusRequestTrans(
playerId,
banned,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthKickPlayer (
unsigned playerId
) {
CliAuConn * conn = GetConnIncRef("KickPlayer");
if (!conn)
return;
const uintptr_t msg[] = {
kCli2Auth_KickPlayer,
playerId
};
conn->Send(msg, arrsize(msg));
conn->UnRef("KickPlayer");
}
//============================================================================
void NetCliAuthChangePlayerNameRequest (
unsigned playerId,
const wchar_t newName[],
FNetCliAuthChangePlayerNameRequestCallback callback,
void * param
) {
ChangePlayerNameRequestTrans * trans = new ChangePlayerNameRequestTrans(
playerId,
newName,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthSendFriendInvite (
const plString& emailAddress,
const plString& toName,
const plUUID& inviteUuid,
FNetCliAuthSendFriendInviteCallback callback,
void * param
) {
SendFriendInviteTrans * trans = new SendFriendInviteTrans(
emailAddress,
toName,
inviteUuid,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthScoreCreate (
unsigned ownerId,
const plString& gameName,
unsigned gameType,
int value,
FNetCliAuthCreateScoreCallback callback,
void * param
) {
ScoreCreateTrans * trans = new ScoreCreateTrans(
ownerId,
gameName,
gameType,
value,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthScoreDelete(
unsigned scoreId,
FNetCliAuthScoreUpdateCallback callback,
void * param
) {
ScoreDeleteTrans * trans = new ScoreDeleteTrans(
scoreId,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthScoreGetScores(
unsigned ownerId,
const plString& gameName,
FNetCliAuthGetScoresCallback callback,
void * param
) {
ScoreGetScoresTrans * trans = new ScoreGetScoresTrans(
ownerId,
gameName,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthScoreAddPoints(
unsigned scoreId,
int numPoints,
FNetCliAuthScoreUpdateCallback callback,
void * param
) {
ScoreAddPointsTrans * trans = new ScoreAddPointsTrans(
scoreId,
numPoints,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthScoreTransferPoints(
unsigned srcScoreId,
unsigned destScoreId,
int numPoints,
FNetCliAuthScoreUpdateCallback callback,
void * param
) {
ScoreTransferPointsTrans * trans = new ScoreTransferPointsTrans(
srcScoreId,
destScoreId,
numPoints,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthScoreSetPoints(
unsigned scoreId,
int numPoints,
FNetCliAuthScoreUpdateCallback callback,
void * param
) {
ScoreSetPointsTrans * trans = new ScoreSetPointsTrans(
scoreId,
numPoints,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthScoreGetRankList(
unsigned ownerId,
unsigned scoreGroup,
unsigned parentFolderId,
const plString& gameName,
unsigned timePeriod,
unsigned numResults,
unsigned pageNumber,
bool sortDesc,
FNetCliAuthGetRanksCallback callback,
void * param
) {
ScoreGetRanksTrans * trans = new ScoreGetRanksTrans(
ownerId,
scoreGroup,
parentFolderId,
gameName,
timePeriod,
numResults,
pageNumber,
sortDesc,
callback,
param
);
NetTransSend(trans);
}
//============================================================================
void NetCliAuthScoreGetHighScores(
unsigned ageId,
unsigned maxScores,
const plString& gameName,
FNetCliAuthGetScoresCallback callback,
void * param
) {
ScoreGetHighScoresTrans * trans = new ScoreGetHighScoresTrans(
ageId,
maxScores,
gameName,
callback,
param
);
NetTransSend(trans);
}