CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plNetGameLib/Private/plNglAuth.cpp

/*==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/>.

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

// This file excluded from pre-compiled header because it is auto-generated by the build server.
#include "pnNetBase/pnNbAuthKey.hpp"

namespace Ngl { namespace Auth {
/*****************************************************************************
*
*   Private
*
***/

struct CliAuConn : AtomicRef {
    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 unsigned_ptr fields[], unsigned count);

	CCritSect		critsect;
    LINK(CliAuConn) link;
    AsyncSocket     sock;
    NetCli *        cli;
    wchar           name[MAX_PATH];
    NetAddress      addr;
    Uuid			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(byte)						m_payload;
	
	PingRequestTrans (
		FNetCliAuthPingRequestCallback	callback,
		void *							param,
		unsigned						pingAtMs,
		unsigned						payloadBytes,
		const void *					payload
	);

    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// AccountExistsRequestTrans
//============================================================================
struct AccountExistsRequestTrans : NetAuthTrans {
	FNetCliAuthAccountExistsRequestCallback		m_callback;
	void *										m_param;

	// send    
    wchar										m_accountName[kMaxAccountNameLength];

	// recv
	byte										m_exists;
	

	
    AccountExistsRequestTrans (
		FNetCliAuthAccountExistsRequestCallback	callback,
		void *							param,
		const wchar						accountName[]
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// LoginRequestTrans
//============================================================================
struct LoginRequestTrans : NetAuthTrans {
    FNetCliAuthLoginRequestCallback m_callback;
    void *                          m_param;

    Uuid                            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 playerName[],
        const wchar avatarShape[],
		unsigned	explorer
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// AgeRequestTrans
//============================================================================
struct AgeRequestTrans : NetAuthTrans {
    FNetCliAuthAgeRequestCallback       m_callback;
    void *                              m_param;
    wchar								m_ageName[kMaxAgeNameLength];
    unsigned							m_ageMcpId;
    Uuid                                m_ageInstId;
    unsigned							m_ageVaultId;
    NetAddressNode                      m_gameSrvNode;

    AgeRequestTrans (
        const wchar							ageName[],
        const Uuid &                        ageInstId,
        FNetCliAuthAgeRequestCallback       callback,
        void *                              param
    );
    ~AgeRequestTrans ();

    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// AccountCreateRequestTrans
//============================================================================
struct AccountCreateRequestTrans : NetAuthTrans {
    FNetCliAuthAccountCreateRequestCallback	m_callback;
    void *									m_param;

	// send    
    wchar									m_accountName[kMaxAccountNameLength];
    ShaDigest								m_namePassHash;
    unsigned								m_accountFlags;
	unsigned								m_billingType;

	// recv
	Uuid									m_accountId;

    AccountCreateRequestTrans (
		const wchar								accountName[],
		const wchar								password[],
		unsigned								accountFlags,
		unsigned								billingType,
        FNetCliAuthAccountCreateRequestCallback	callback,
        void *									param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// AccountCreateFromKeyRequestTrans
//============================================================================
struct AccountCreateFromKeyRequestTrans : NetAuthTrans {
    FNetCliAuthAccountCreateFromKeyRequestCallback	m_callback;
    void *											m_param;

	// send    
    wchar									m_accountName[kMaxAccountNameLength];
    ShaDigest								m_namePassHash;
    Uuid									m_key;
	unsigned								m_billingType;

	// recv
	Uuid									m_accountId;
	Uuid									m_activationKey;

    AccountCreateFromKeyRequestTrans (
		const wchar										accountName[],
		const wchar										password[],
		const Uuid &									key,
		unsigned										billingType,
        FNetCliAuthAccountCreateFromKeyRequestCallback	callback,
        void *											param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// PlayerCreateRequestTrans
//============================================================================
struct PlayerCreateRequestTrans : NetAuthTrans {
    FNetCliAuthPlayerCreateRequestCallback	m_callback;
    void *									m_param;

	// send    
    wchar									m_playerName[kMaxPlayerNameLength];
    wchar									m_avatarShape[MAX_PATH];
    wchar									m_friendInvite[MAX_PATH];

    // recv
	NetCliAuthPlayerInfo					m_playerInfo;


    PlayerCreateRequestTrans (
		const wchar								playerName[],
		const wchar								avatarShape[],
		const wchar								friendInvite[],
        FNetCliAuthPlayerCreateRequestCallback	callback,
        void *									param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  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 byte  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 byte  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 byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// AccountChangePasswordRequestTrans
//============================================================================
struct AccountChangePasswordRequestTrans : NetAuthTrans {
	FNetCliAuthAccountChangePasswordRequestCallback	m_callback;
	void *											m_param;

	// send    
    wchar									m_accountName[kMaxAccountNameLength];
    ShaDigest								m_namePassHash;

    AccountChangePasswordRequestTrans (
		const wchar										accountName[],
		const wchar										password[],
        FNetCliAuthAccountChangePasswordRequestCallback	callback,
        void *											param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// GetPublicAgeListTrans
//============================================================================
struct GetPublicAgeListTrans : NetAuthTrans {
	FNetCliAuthGetPublicAgeListCallback		m_callback;
	void *									m_param;
	
	// send
	wchar									m_ageName[MAX_PATH];
	
	// recv
	ARRAY(NetAgeInfo)						m_ages;
	
	GetPublicAgeListTrans (
		const wchar							ageName[],
		FNetCliAuthGetPublicAgeListCallback	callback,
		void *								param
	);
		
    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// AccountSetRolesRequestTrans
//============================================================================
struct AccountSetRolesRequestTrans : NetAuthTrans {
	FNetCliAuthAccountSetRolesRequestCallback	m_callback;
	void *										m_param;

	// send    
    wchar									m_accountName[kMaxAccountNameLength];
    unsigned								m_accountFlags;

    AccountSetRolesRequestTrans (
		const wchar									accountName[],
		unsigned									accountFlags,
        FNetCliAuthAccountSetRolesRequestCallback	callback,
        void *										param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// AccountSetBillingTypeRequestTrans
//============================================================================
struct AccountSetBillingTypeRequestTrans : NetAuthTrans {
	FNetCliAuthAccountSetBillingTypeRequestCallback	m_callback;
	void *											m_param;

	// send    
    wchar									m_accountName[kMaxAccountNameLength];
    unsigned								m_billingType;

    AccountSetBillingTypeRequestTrans (
		const wchar										accountName[],
		unsigned										billingType,
        FNetCliAuthAccountSetBillingTypeRequestCallback	callback,
        void *											param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// AccountActivateRequestTrans
//============================================================================
struct AccountActivateRequestTrans : NetAuthTrans {
	FNetCliAuthAccountActivateRequestCallback	m_callback;
	void *										m_param;

	// send    
    Uuid										m_activationKey;

    AccountActivateRequestTrans (
		const Uuid &								activationKey,
        FNetCliAuthAccountActivateRequestCallback	callback,
        void *										param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// FileListRequestTrans
//============================================================================
struct FileListRequestTrans : NetAuthTrans {
	FNetCliAuthFileListRequestCallback	m_callback;
	void *								m_param;

	wchar								m_directory[MAX_PATH];
	wchar								m_ext[MAX_EXT];

	ARRAY(NetCliAuthFileInfo)			m_fileInfoArray;

	FileListRequestTrans (
		FNetCliAuthFileListRequestCallback	callback,
		void *								param,
		const wchar							directory[],
		const wchar							ext[]
	);

	bool Send ();
	void Post ();
	bool Recv (
		const byte	msg[],
		unsigned	bytes
	);
};

//============================================================================
// FileDownloadRequestTrans
//============================================================================
struct FileDownloadRequestTrans : NetAuthTrans {
	FNetCliAuthFileRequestCallback	m_callback;
	void *							m_param;

	wchar							m_filename[MAX_PATH];
	hsStream *						m_writer;

	FileDownloadRequestTrans (
		FNetCliAuthFileRequestCallback	callback,
		void *							param,
		const wchar						filename[],
		hsStream *						writer
	);

	bool Send ();
	void Post ();
	bool Recv (
		const byte	msg[],
		unsigned	bytes
	);
};

//============================================================================
// RcvdFileDownloadChunkTrans
//============================================================================
struct RcvdFileDownloadChunkTrans : NetNotifyTrans {

	unsigned	bytes;
	unsigned	offset;
	byte *		data;
	hsStream *	writer;

	RcvdFileDownloadChunkTrans () : NetNotifyTrans(kRcvdFileDownloadChunkTrans) {}
	~RcvdFileDownloadChunkTrans ();
    void Post ();
};


//============================================================================
// RcvdPropagatedBufferTrans
//============================================================================
struct RcvdPropagatedBufferTrans : NetNotifyTrans {

	unsigned		bufferType;
	unsigned		bufferBytes;
	byte *			bufferData;

	RcvdPropagatedBufferTrans () : NetNotifyTrans(kRcvdPropagatedBufferTrans) {}
	~RcvdPropagatedBufferTrans ();
    void Post ();
};

//============================================================================
// VaultNodeChangedTrans
//============================================================================
struct VaultNodeChangedTrans : NetNotifyTrans {

	unsigned		m_nodeId;
	Uuid			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 byte	msg[],
		unsigned	bytes
	);
};

//============================================================================
// VaultInitAgeTrans
//============================================================================
struct VaultInitAgeTrans : NetAuthTrans {
	FNetCliAuthAgeInitCallback	m_callback;
	void *						m_param;

	Uuid						m_ageInstId;
	Uuid						m_parentAgeInstId;
	wchar *						m_ageFilename;
	wchar *						m_ageInstName;
	wchar *						m_ageUserName;
	wchar *						m_ageDesc;
	unsigned					m_ageSequenceNumber;
	unsigned					m_ageLanguage;
	
	unsigned					m_ageId;
	unsigned					m_ageInfoId;
	
	VaultInitAgeTrans (
		FNetCliAuthAgeInitCallback	callback,			// optional
		void *						param,				// optional
		const Uuid &				ageInstId,			// optional. is used in match
		const Uuid &				parentAgeInstId,	// optional. is used in match
		const wchar					ageFilename[],		// optional. is used in match
		const wchar					ageInstName[],		// optional. not used in match
		const wchar					ageUserName[],		// optional. not used in match
		const wchar					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 byte	msg[],
		unsigned	bytes
	);
};

//============================================================================
// VaultFetchNodeTrans
//============================================================================
struct VaultFetchNodeTrans : NetAuthTrans {

	unsigned					m_nodeId;
	FNetCliAuthVaultNodeFetched	m_callback;
	void *						m_param;
	
	NetVaultNode *				m_node;
	
	VaultFetchNodeTrans (
		unsigned					nodeId,
		FNetCliAuthVaultNodeFetched	callback,
		void *						param
	);
	
	bool Send ();
	void Post ();
	bool Recv (
		const byte	msg[],
		unsigned	bytes
	);
};

//============================================================================
// VaultFindNodeTrans
//============================================================================
struct VaultFindNodeTrans : NetAuthTrans {

	ARRAY(unsigned)				m_nodeIds;
	FNetCliAuthVaultNodeFind	m_callback;
	void *						m_param;
	
	NetVaultNode *				m_node;
	
	VaultFindNodeTrans (
		NetVaultNode *				templateNode,
		FNetCliAuthVaultNodeFind	callback,
		void *						param
	);
	~VaultFindNodeTrans ();

	
	bool Send ();
	void Post ();
	bool Recv (
		const byte	msg[],
		unsigned	bytes
	);
};

//============================================================================
// VaultCreateNodeTrans
//============================================================================
struct VaultCreateNodeTrans : NetAuthTrans {

	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 byte	msg[],
		unsigned	bytes
	);
};

//============================================================================
// VaultSaveNodeTrans
//============================================================================
struct VaultSaveNodeTrans : NetAuthTrans {

	unsigned							m_nodeId;
	Uuid								m_revisionId;
	ARRAY(byte)							m_buffer;
	FNetCliAuthVaultNodeSaveCallback	m_callback;
	void *								m_param;
	
	VaultSaveNodeTrans (
		unsigned							nodeId,
		const Uuid &						revisionId,
		unsigned							dataCount,
		const void *						data,
		FNetCliAuthVaultNodeSaveCallback	callback,
		void *								param
	);
	
	bool Send ();
	void Post ();
	bool Recv (
		const byte	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 byte	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 byte	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 byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// ChangePlayerNameRequestTrans
//============================================================================
struct ChangePlayerNameRequestTrans : NetAuthTrans {
	FNetCliAuthChangePlayerNameRequestCallback	m_callback;
	void *										m_param;

	// send    
    unsigned										m_playerId;
	wchar											m_newName[kMaxPlayerNameLength];

    ChangePlayerNameRequestTrans (
		unsigned									playerId,
		const wchar									newName[],
        FNetCliAuthChangePlayerNameRequestCallback	callback,
        void *										param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// SendFriendInviteTrans
//============================================================================
struct SendFriendInviteTrans : NetAuthTrans {
	FNetCliAuthSendFriendInviteCallback	m_callback;
	void *								m_param;

	// send    
	wchar								m_emailAddress[kMaxEmailAddressLength];
	wchar								m_toName[kMaxPlayerNameLength];
	Uuid								m_inviteUuid;

    SendFriendInviteTrans (
		const wchar								emailAddr[],
		const wchar								toName[],
		const Uuid &							inviteUuid,
        FNetCliAuthSendFriendInviteCallback		callback,
        void *									param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  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;
	char							m_gameName[kMaxGameScoreNameLength];
	unsigned						m_gameType;
	int								m_value;

	// recv
	unsigned						m_scoreId;
	UInt32							m_createdTime;

    ScoreCreateTrans (
		unsigned						ownerId,
		const char*						gameName,
		unsigned						gameType,
		int								value,
		FNetCliAuthCreateScoreCallback	callback,
		void *							param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  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 byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// ScoreGetScoresTrans
//============================================================================
struct ScoreGetScoresTrans : NetAuthTrans {
	FNetCliAuthGetScoresCallback	m_callback;
	void *							m_param;

	// send    
    unsigned						m_ownerId;
	char							m_gameName[kMaxGameScoreNameLength];

	// recv
	NetGameScore *					m_scores;
	unsigned						m_scoreCount;

    ScoreGetScoresTrans (
		unsigned						ownerId,
		const char*						gameName,
		FNetCliAuthGetScoresCallback	callback,
		void *							param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  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 byte  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 byte  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 byte  msg[],
        unsigned    bytes
    );
};

//============================================================================
// ScoreGetRanksTrans
//============================================================================
struct ScoreGetRanksTrans : NetAuthTrans {
	FNetCliAuthGetRanksCallback		m_callback;
	void *							m_param;

	// send    
    unsigned						m_ownerId;
	unsigned						m_scoreGroup;
	unsigned						m_parentFolderId;
	wchar							m_gameName[kMaxGameScoreNameLength];
	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 char *				cGameName,
		unsigned					timePeriod,
		unsigned					numResults,
		unsigned					pageNumber,
		bool						sortDesc,
		FNetCliAuthGetRanksCallback	callback,
		void *						param
    );

    bool Send ();
    void Post ();
    bool Recv (
        const byte  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 wchar                        s_accountName[kMaxAccountNameLength];
static ShaDigest                    s_accountNamePassHash;
static wchar						s_authToken[kMaxPublisherAuthKeyLength];
static wchar						s_os[kMaxGTOSIdLength];

static long                         s_perf[kNumPerf];

static UInt32						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 inline bool ICharIsSpace (unsigned ch) {
    return ch == ' ';
}

//===========================================================================
static ENetError FixupPlayerName (wchar * name) {
	ASSERT(name);

	// Trim leading and trailing whitespace and convert
	// multiple internal spaces into only one space
	unsigned nonSpaceChars = 0;
	for (wchar *src = name, *dst = name; *src; ) {
		// Skip whitespace
		while (*src && ICharIsSpace(*src))
			src++;

		// If the block skipped was not at the beginning
		// of the string then add one space character
		if (*src && (dst != name))
			*dst++ = ' ';

		// Copy characters until end-of-string or next whitespace
		while (*src && !ICharIsSpace(*src)) {
			++nonSpaceChars;
			*dst++ = *src++;
		}
	}

	// Ensure destination string is terminated
	*dst = 0;

	// Check for minimum name length
	if (nonSpaceChars < 3)
		return kNetErrPlayerNameInvalid;

	return kNetSuccess;
}

//===========================================================================
static unsigned GetNonZeroTimeMs () {
	if (unsigned ms = TimeGetMs())
		return ms;
	return 1;
}

//============================================================================
static CliAuConn * GetConnIncRef_CS (const char tag[]) {
    if (CliAuConn * conn = s_active) {
        conn->IncRef(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->DecRef("Lifetime");
	}
}

//============================================================================
static void SendClientRegisterRequest (CliAuConn * conn) {
    const unsigned_ptr msg[] = {
        kCli2Auth_ClientRegisterRequest,
        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->DecRef("Lifetime");
		ReportNetError(kNetProtocolCli2Auth, error);
	}
	else {
		if (conn->token != kNilGuid)
			// 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->DecRef("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->DecRef("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			= BuildId();
    connect.hdr.buildType		= BuildType();
    connect.hdr.branchId		= BranchId();
    connect.hdr.productId		= ProductId();
    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 wchar         name[],
    const NetAddress &  addr
) {
	ASSERT(s_running);
	
    CliAuConn * conn		= NEWZERO(CliAuConn);
    conn->addr				= addr;
    conn->seq				= ConnNextSequence();
    conn->lastHeardTimeMs	= GetNonZeroTimeMs();	// used in connect timeout, and ping timeout
    StrCopy(conn->name, name, arrsize(conn->name));

    conn->IncRef("Lifetime");
	conn->AutoReconnect();
}

//============================================================================
static void AsyncLookupCallback (
    void *              param,
    const wchar         name[],
    unsigned            addrCount,
    const NetAddress    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->DecRef("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 () {
    AtomicAdd(&s_perf[kPerfConnCount], 1);
}

//============================================================================
CliAuConn::~CliAuConn () {
    if (cli)
        NetCliDelete(cli, true);
    AtomicAdd(&s_perf[kPerfConnCount], -1);
}

//===========================================================================
void CliAuConn::TimerReconnect () {
	ASSERT(!sock);
	ASSERT(!cancelId);
	
	if (!s_running) {
		s_critsect.Enter();
		UnlinkAndAbandonConn_CS(this);
		s_critsect.Leave();
	}
	else {
		IncRef("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);
	IncRef("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);
	IncRef("PingTimer");
	critsect.Enter();
	{
		AsyncTimerCreate(
			&pingTimer,
			CliAuConnPingTimerProc,
			sock ? 0 : kAsyncTimeInfinite,
			this
		);
	}
	critsect.Leave();
}

//============================================================================
void CliAuConn::StopAutoPing () {
	critsect.Enter();
	{
		if (AsyncTimer * timer = pingTimer) {
			pingTimer = nil;
			AsyncTimerDeleteCallback(timer, CliAuConnTimerDestroyed);
		}
	}
	critsect.Leave();
}

//============================================================================
void CliAuConn::TimerPing () {

#if 0
	// if the time difference between when we last sent a ping and when we last
	// heard from the server is >= 3x the ping interval, the socket is stale.
	if (pingSendTimeMs && abs(int(pingSendTimeMs - lastHeardTimeMs)) >= kPingTimeoutMs) {
		// ping timed out, disconnect the socket
		AsyncSocketDisconnect(sock, true);
	}
	else
#endif
	{
		// Send a ping request
		pingSendTimeMs = GetNonZeroTimeMs();
		
		const unsigned_ptr msg[] = {
			kCli2Auth_PingRequest,
			pingSendTimeMs,
			0,		// not a transaction
			0,		// no payload
			nil
		};
		
		Send(msg, arrsize(msg));
	}		
}

//============================================================================
void CliAuConn::Send (const unsigned_ptr fields[], unsigned count) {
	critsect.Enter();
	{
		NetCliSend(cli, fields, count);
		NetCliFlush(cli);
	}
	critsect.Leave();
}


/*****************************************************************************
*
*   Cli2Auth message handlers
*
***/

//============================================================================
static bool Recv_PingReply (
    const byte      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 byte      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 byte      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 byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_AcctPlayerInfo & reply = *(const Auth2Cli_AcctPlayerInfo *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_AcctLoginReply (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_AcctLoginReply & reply = *(const Auth2Cli_AcctLoginReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_AcctCreateReply (
	const byte		msg[],
	unsigned		bytes,
	void *
) {
	const Auth2Cli_AcctCreateReply & reply = *(const Auth2Cli_AcctCreateReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_AcctCreateFromKeyReply (
	const byte		msg[],
	unsigned		bytes,
	void *
) {
	const Auth2Cli_AcctCreateFromKeyReply & reply = *(const Auth2Cli_AcctCreateFromKeyReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_PlayerCreateReply (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_PlayerCreateReply & reply = *(const Auth2Cli_PlayerCreateReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_PlayerDeleteReply (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_PlayerDeleteReply & reply = *(const Auth2Cli_PlayerDeleteReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_UpgradeVisitorReply (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_UpgradeVisitorReply & reply = *(const Auth2Cli_UpgradeVisitorReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_AcctSetPlayerReply (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_AcctSetPlayerReply & reply = *(const Auth2Cli_AcctSetPlayerReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_AcctChangePasswordReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_AcctChangePasswordReply & reply = *(const Auth2Cli_AcctChangePasswordReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_AcctSetRolesReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_AcctSetRolesReply & reply = *(const Auth2Cli_AcctSetRolesReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_AcctSetBillingTypeReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_AcctSetBillingTypeReply & reply = *(const Auth2Cli_AcctSetBillingTypeReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_AcctActivateReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_AcctActivateReply & reply = *(const Auth2Cli_AcctActivateReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

	return true;
}

//============================================================================
static bool Recv_AgeReply (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_AgeReply & reply = *(const Auth2Cli_AgeReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_FileListReply (
	const byte		msg[],
	unsigned		bytes,
	void *
) {
	const Auth2Cli_FileListReply & reply = *(const Auth2Cli_FileListReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_FileDownloadChunk (
	const byte		msg[],
	unsigned		bytes,
	void *
) {
	const Auth2Cli_FileDownloadChunk & reply = *(const Auth2Cli_FileDownloadChunk *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_KickedOff (
    const byte      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 byte      msg[],
    unsigned        bytes,
    void *
) {
	const Auth2Cli_VaultNodeRefsFetched & reply = *(const Auth2Cli_VaultNodeRefsFetched *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_VaultNodeFetched (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
	const Auth2Cli_VaultNodeFetched & reply = *(const Auth2Cli_VaultNodeFetched *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_VaultNodeCreated (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
	const Auth2Cli_VaultNodeCreated & reply = *(const Auth2Cli_VaultNodeCreated *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_VaultNodeChanged (
    const byte      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 byte      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 byte      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 byte      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 byte      msg[],
    unsigned        bytes,
    void *
) {
	const Auth2Cli_VaultSaveNodeReply & reply = *(const Auth2Cli_VaultSaveNodeReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_VaultAddNodeReply (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
	const Auth2Cli_VaultAddNodeReply & reply = *(const Auth2Cli_VaultAddNodeReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_VaultRemoveNodeReply (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
	const Auth2Cli_VaultRemoveNodeReply & reply = *(const Auth2Cli_VaultRemoveNodeReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_VaultInitAgeReply (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
	const Auth2Cli_VaultInitAgeReply & reply = *(const Auth2Cli_VaultInitAgeReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_VaultNodeFindReply (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
	const Auth2Cli_VaultNodeFindReply & reply = *(const Auth2Cli_VaultNodeFindReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_PublicAgeList (
    const byte      msg[],
    unsigned        bytes,
    void *
) {
	const Auth2Cli_PublicAgeList & reply = *(const Auth2Cli_PublicAgeList *)msg;

    NetTransRecv(reply.transId, msg, bytes);

    return true;
}

//============================================================================
static bool Recv_ServerAddr	(
	const byte	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;
			NetAddressFromNode(
				msg.srvAddr,
				NetAddressGetPort(s_active->addr),
				&s_active->addr
			);
			wchar addrStr[64];
			NetAddressNodeToString(
				msg.srvAddr,
				addrStr,
				arrsize(addrStr)
			);
			LogMsg(kLogPerf, L"SrvAuth addr: %s", addrStr);
		}
	}
	s_critsect.Leave();
	
	return true;
}

//============================================================================
static bool Recv_NotifyNewBuild (
	const byte[],
	unsigned	,
	void *
) {
	NotifyNewBuildTrans * trans = NEW(NotifyNewBuildTrans);
	NetTransSend(trans);

	return true;
}

//============================================================================
static bool Recv_SetPlayerBanStatusReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_SetPlayerBanStatusReply & reply = *(const Auth2Cli_SetPlayerBanStatusReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

	return true;
}

//============================================================================
static bool Recv_ChangePlayerNameReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_ChangePlayerNameReply & reply = *(const Auth2Cli_ChangePlayerNameReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

	return true;
}

//============================================================================
static bool Recv_SendFriendInviteReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_SendFriendInviteReply & reply = *(const Auth2Cli_SendFriendInviteReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

	return true;
}

//============================================================================
static bool Recv_ScoreCreateReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_ScoreCreateReply & reply = *(const Auth2Cli_ScoreCreateReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

	return true;
}

//============================================================================
static bool Recv_ScoreDeleteReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_ScoreDeleteReply & reply = *(const Auth2Cli_ScoreDeleteReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

	return true;
}

//============================================================================
static bool Recv_ScoreGetScoresReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_ScoreGetScoresReply & reply = *(const Auth2Cli_ScoreGetScoresReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

	return true;
}

//============================================================================
static bool Recv_ScoreAddPointsReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_ScoreAddPointsReply & reply = *(const Auth2Cli_ScoreAddPointsReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

	return true;
}

//============================================================================
static bool Recv_ScoreTransferPointsReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_ScoreTransferPointsReply & reply = *(const Auth2Cli_ScoreTransferPointsReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

	return true;
}

//============================================================================
static bool Recv_ScoreSetPointsReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_ScoreSetPointsReply & reply = *(const Auth2Cli_ScoreSetPointsReply *)msg;

    NetTransRecv(reply.transId, msg, bytes);

	return true;
}

//============================================================================
static bool Recv_ScoreGetRanksReply (
	const byte      msg[],
    unsigned        bytes,
    void *
) {
    const Auth2Cli_ScoreGetRanksReply & reply = *(const Auth2Cli_ScoreGetRanksReply *)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)		},
};
#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)		},
};
#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 byte *)payload, payloadBytes);
}

//============================================================================
bool PingRequestTrans::Send () {

    if (!AcquireConn())
        return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_PingRequest,
						m_pingAtMs,
						m_transId,
						m_payload.Count(),
		(unsigned_ptr)	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 byte  msg[],
    unsigned    bytes
) {
	const Auth2Cli_PingReply & reply = *(const Auth2Cli_PingReply *)msg;

	m_payload.Set(reply.payload, reply.payloadBytes);
    m_replyAtMs		= TimeGetMs();
    m_result        = kNetSuccess;
    m_state         = kTransStateComplete;

	return true;
}


/*****************************************************************************
*
*   AccountExistsRequestTrans
*
***/

//============================================================================
AccountExistsRequestTrans::AccountExistsRequestTrans (
	FNetCliAuthAccountExistsRequestCallback	callback,
	void *							param,
	const wchar						accountName[]
) :	NetAuthTrans(kPingRequestTrans)
,	m_callback(callback)
,	m_param(param)
{
	StrCopy(m_accountName, accountName, kMaxAccountNameLength);
}

//============================================================================
bool AccountExistsRequestTrans::Send () {

    if (!AcquireConn())
        return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_AccountExistsRequest,
						m_transId,
						(unsigned_ptr)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 byte  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(kNilGuid)
,	m_accountFlags(0)
,   m_playerCount(0)
{
    ZERO(m_players);
}

//============================================================================
void LoginRequestTrans::AddPlayer (
    unsigned    playerInt,
    const wchar playerName[],
    const wchar	avatarShape[],
	unsigned	explorer
) {
    unsigned index = m_playerCount++;
    ASSERT(index < kMaxPlayersPerAccount);
    m_players[index].playerInt	= playerInt;
	m_players[index].explorer	= explorer;
    StrCopy(m_players[index].playerName, playerName, arrsize(m_players[index].playerName));
    StrCopy(m_players[index].avatarShape, avatarShape, arrsize(m_players[index].avatarShape));
}

//============================================================================
bool LoginRequestTrans::Send () {

    if (!AcquireConn())
        return false;

	ShaDigest challengeHash;
    dword clientChallenge = 0;

	wchar domain[15];
	PathSplitEmail(s_accountName, nil, 0, domain, arrsize(domain), nil, 0, nil, 0, 0);

	if (StrLen(domain) == 0 || StrCmpI(domain, L"gametap") == 0) {
		challengeHash = s_accountNamePassHash;
	}
	else {
		CryptCreateRandomSeed(
			sizeof(clientChallenge),
			(byte *) &clientChallenge
		);

		CryptHashPasswordChallenge(
			clientChallenge,
			s_active->serverChallenge,
			s_accountNamePassHash,
			&challengeHash
		);
	}

    const unsigned_ptr msg[] = {
        kCli2Auth_AcctLoginRequest,
        m_transId,
		clientChallenge,
        (unsigned_ptr) s_accountName,
        (unsigned_ptr) &challengeHash,
		(unsigned_ptr) s_authToken,
		(unsigned_ptr) 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 byte  msg[],
    unsigned    bytes
) {
    dword msgId = (dword)*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 = min(arrsize(s_encryptionKey), arrsize(reply.encryptionKey));
			memSize *= sizeof(UInt32);
			MemCopy(s_encryptionKey, reply.encryptionKey, memSize);
        }
        break;

        DEFAULT_FATAL(msgId);
    };

    return true;
}


/*****************************************************************************
*
*   AgeRequestTrans
*
***/

//============================================================================
AgeRequestTrans::AgeRequestTrans (
    const wchar							ageName[],
    const Uuid &                        ageInstId,
    FNetCliAuthAgeRequestCallback       callback,
    void *                              param
) : NetAuthTrans(kAgeRequestTrans)
,   m_ageInstId(ageInstId)
,   m_callback(callback)
,   m_param(param)
{
	StrCopy(m_ageName, ageName, arrsize(m_ageName));
}

//============================================================================
AgeRequestTrans::~AgeRequestTrans () {
}

//============================================================================
bool AgeRequestTrans::Send () {
    if (!AcquireConn())
        return true;

    const unsigned_ptr msg[] = {
        kCli2Auth_AgeRequest,
						m_transId,
        (unsigned_ptr)	m_ageName,
        (unsigned_ptr) &m_ageInstId,
    };

	m_conn->Send(msg, arrsize(msg));
    
    return true;
}

//============================================================================
void AgeRequestTrans::Post () {
    m_callback(
        m_result,
        m_param,
        m_ageMcpId,
        m_ageVaultId,
        m_ageInstId,
        m_gameSrvNode
    );
}

//============================================================================
bool AgeRequestTrans::Recv (
    const byte  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								accountName[],
	const wchar								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(
        m_accountName,
        password,
        &m_namePassHash
    );
}

//============================================================================
bool AccountCreateRequestTrans::Send () {
	if (!AcquireConn())
		return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_AcctCreateRequest,
						m_transId,
		(unsigned_ptr)	m_accountName,
		(unsigned_ptr)	&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 byte  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										accountName[],
	const wchar										password[],
	const Uuid &									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(
        m_accountName,
        password,
        &m_namePassHash
    );
}

//============================================================================
bool AccountCreateFromKeyRequestTrans::Send () {
	if (!AcquireConn())
		return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_AcctCreateFromKeyRequest,
						m_transId,
		(unsigned_ptr)	m_accountName,
		(unsigned_ptr)	&m_namePassHash,
		(unsigned_ptr)	&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 byte  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 wchar								playerName[],
	const wchar								avatarShape[],
	const wchar								friendInvite[],
    FNetCliAuthPlayerCreateRequestCallback	callback,
    void *									param
) :	NetAuthTrans(kPlayerCreateRequestTrans)
,	m_callback(callback)
,	m_param(param)
{
	StrCopy(m_playerName, playerName, arrsize(m_playerName));
	StrCopy(m_avatarShape, avatarShape, arrsize(m_avatarShape));
	if (friendInvite)
		StrCopy(m_friendInvite, friendInvite, arrsize(m_friendInvite));
	else
		m_friendInvite[0] = 0;
	ZERO(m_playerInfo);
}

//============================================================================
bool PlayerCreateRequestTrans::Send () {
	if (!AcquireConn())
		return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_PlayerCreateRequest,
						m_transId,
		(unsigned_ptr)	m_playerName,
		(unsigned_ptr)	m_avatarShape,
		(unsigned_ptr)	m_friendInvite,
	};

	m_conn->Send(msg, arrsize(msg));
	
	return true;
}

//============================================================================
void PlayerCreateRequestTrans::Post () {
    m_callback(
		m_result,
		m_param,
		m_playerInfo
	);
}

//============================================================================
bool PlayerCreateRequestTrans::Recv (
    const byte  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;
		StrCopy(m_playerInfo.playerName, reply.playerName, arrsize(m_playerInfo.playerName));
		StrCopy(m_playerInfo.avatarShape, reply.avatarShape, arrsize(m_playerInfo.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 unsigned_ptr 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 byte  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 unsigned_ptr 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 byte  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 unsigned_ptr 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 byte  msg[],
    unsigned    bytes
) {
    const Auth2Cli_AcctSetPlayerReply & reply = *(const Auth2Cli_AcctSetPlayerReply *) msg;
    m_result        = reply.result;
    m_state         = kTransStateComplete;
    return true;
}

/*****************************************************************************
*
*   AccountChangePasswordRequestTrans
*
***/

//============================================================================
AccountChangePasswordRequestTrans::AccountChangePasswordRequestTrans (
	const wchar										accountName[],
	const wchar										password[],
    FNetCliAuthAccountChangePasswordRequestCallback	callback,
    void *											param
) : NetAuthTrans(kAccountChangePasswordRequestTrans)
,	m_callback(callback)
,	m_param(param)
{
	StrCopy(m_accountName, accountName, arrsize(m_accountName));
	
	CryptHashPassword(
        m_accountName,
        password,
        &m_namePassHash
    );
}

//============================================================================
bool AccountChangePasswordRequestTrans::Send () {
	if (!AcquireConn())
		return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_AcctChangePasswordRequest,
						m_transId,
		(unsigned_ptr)	m_accountName,
		(unsigned_ptr)	&m_namePassHash,
	};

	m_conn->Send(msg, arrsize(msg));

	return true;
}

//============================================================================
void AccountChangePasswordRequestTrans::Post () {
    m_callback(
		m_result,
		m_param
	);
}

//============================================================================
bool AccountChangePasswordRequestTrans::Recv (
    const byte  msg[],
    unsigned    bytes
) {
    const Auth2Cli_AcctChangePasswordReply & reply = *(const Auth2Cli_AcctChangePasswordReply *) msg;

	m_result    = reply.result;
    m_state		= kTransStateComplete;
    return true;
}

/*****************************************************************************
*
*   GetPublicAgeListTrans
*
***/

//============================================================================
GetPublicAgeListTrans::GetPublicAgeListTrans (
	const wchar							ageName[],
	FNetCliAuthGetPublicAgeListCallback	callback,
	void *								param
) : NetAuthTrans(kGetPublicAgeListTrans)
,	m_callback(callback)
,	m_param(param)
{
	StrCopy(m_ageName, ageName, arrsize(m_ageName));
}

//============================================================================
bool GetPublicAgeListTrans::Send () {
	if (!AcquireConn())
		return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_GetPublicAgeList,
						m_transId,
		(unsigned_ptr)	&m_ageName,
	};

	m_conn->Send(msg, arrsize(msg));

	return true;
}

//============================================================================
void GetPublicAgeListTrans::Post () {
    m_callback(
		m_result,
		m_param,
		m_ages
	);
}

//============================================================================
bool GetPublicAgeListTrans::Recv (
    const byte  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									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 unsigned_ptr msg[] = {
		kCli2Auth_AcctSetRolesRequest,
						m_transId,
		(unsigned_ptr)	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 byte  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										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 unsigned_ptr msg[] = {
		kCli2Auth_AcctSetBillingTypeRequest,
						m_transId,
		(unsigned_ptr)	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 byte  msg[],
    unsigned    bytes
) {
    const Auth2Cli_AcctSetBillingTypeReply & reply = *(const Auth2Cli_AcctSetBillingTypeReply *) msg;

	m_result    = reply.result;
    m_state		= kTransStateComplete;
    return true;
}

/*****************************************************************************
*
*   AccountActivateRequestTrans
*
***/

//============================================================================
AccountActivateRequestTrans::AccountActivateRequestTrans (
	const Uuid &								activationKey,
    FNetCliAuthAccountActivateRequestCallback	callback,
    void *										param
) : NetAuthTrans(kAccountActivateRequestTrans)
,	m_callback(callback)
,	m_param(param)
{
	m_activationKey = activationKey;
}

//============================================================================
bool AccountActivateRequestTrans::Send () {
	if (!AcquireConn())
		return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_AcctActivateRequest,
						m_transId,
		(unsigned_ptr)	&m_activationKey,
	};

	m_conn->Send(msg, arrsize(msg));

	return true;
}

//============================================================================
void AccountActivateRequestTrans::Post () {
    m_callback(
		m_result,
		m_param
	);
}

//============================================================================
bool AccountActivateRequestTrans::Recv (
    const byte  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							directory[],
	const wchar							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 unsigned_ptr msg[] = {
		kCli2Auth_FileListRequest,
		m_transId,
        (unsigned_ptr) m_directory,
		(unsigned_ptr) 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 byte	msg[],
	unsigned	bytes
) {
	const Auth2Cli_FileListReply & reply = *(const Auth2Cli_FileListReply *) msg;

	dword wcharCount = reply.wcharCount;
	const wchar* curChar = reply.fileData;
	// if wcharCount is 2, the data only contains the terminator "\0\0" and we
	// don't need to convert anything
	if (wcharCount == 2)
		m_fileInfoArray.Clear();
	else
	{
		// fileData format: "filename\0size\0filename\0size\0...\0\0"
		bool done = false;
		while (!done) {
			if (wcharCount == 0)
			{
				done = true;
				break;
			}

			// read in the filename
			wchar 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
			wcharCount -= filenameLen; // keep track of the amount remaining
			if ((*curChar != L'\0') || (wcharCount <= 0))
				return false; // something is screwy, abort and disconnect

			curChar++; // point it at the first part of the size value (format: 0xHHHHLLLL)
			wcharCount--;
			if (wcharCount < 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;
			wcharCount -= 2;
			if ((*curChar != L'\0') || (wcharCount <= 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++;
			wcharCount--;
			if (*curChar == L'\0')
			{
				// we hit the terminator
				if (wcharCount != 1)
					return false; // invalid data, we shouldn't have any more
				done = true; // we're done
			}
			else if (wcharCount < 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 wchar						filename[],
	hsStream *						writer
) : NetAuthTrans(kFileDownloadRequestTrans)
,	m_callback(callback)
,	m_param(param)
,	m_writer(writer)
{
	StrCopy(m_filename, filename, arrsize(m_filename));
	// 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;

	const unsigned_ptr msg[] = {
		kCli2Auth_FileDownloadRequest,
		m_transId,
		(unsigned_ptr) m_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 byte	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	= (byte *)ALLOC(reply.chunkSize);
		MemCopy(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 unsigned_ptr 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 unsigned_ptr 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 byte	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 Uuid &				ageInstId,			// optional. is used in match
	const Uuid &				parentAgeInstId,	// optional. is used in match
	const wchar					ageFilename[],		// optional. is used in match
	const wchar					ageInstName[],		// optional. not used in match
	const wchar					ageUserName[],		// optional. not used in match
	const wchar					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(StrDup(ageFilename ? ageFilename : L""))
,	m_ageInstName(StrDup(ageInstName ? ageInstName : L""))
,	m_ageUserName(StrDup(ageUserName ? ageUserName : L""))
,	m_ageDesc(StrDup(ageDesc ? ageDesc : L""))
,	m_ageSequenceNumber(ageSequenceNumber)
,	m_ageLanguage(ageLanguage)
{
}

//============================================================================
VaultInitAgeTrans::~VaultInitAgeTrans () {
	FREE(m_ageFilename);
	FREE(m_ageInstName);
	FREE(m_ageUserName);
	FREE(m_ageDesc);
}

//============================================================================
bool VaultInitAgeTrans::Send () {
	if (!AcquireConn())
		return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_VaultInitAgeRequest,
						m_transId,
		(unsigned_ptr) &m_ageInstId,
		(unsigned_ptr) &m_parentAgeInstId,
		(unsigned_ptr)	m_ageFilename,
		(unsigned_ptr)	m_ageInstName,
		(unsigned_ptr)	m_ageUserName,
		(unsigned_ptr)	m_ageDesc,
						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 byte	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)
{
}

//============================================================================
bool VaultFetchNodeTrans::Send () {
	if (!AcquireConn())
		return false;

	const unsigned_ptr 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
	);
	if (m_node)
		m_node->DecRef("Recv");
}

//============================================================================
bool VaultFetchNodeTrans::Recv (
	const byte	msg[],
	unsigned	bytes
) {
	const Auth2Cli_VaultNodeFetched & reply = *(const Auth2Cli_VaultNodeFetched *) msg;
	
	if (IS_NET_SUCCESS(reply.result)) {
		m_node = NEWZERO(NetVaultNode);
		m_node->Read_LCS(reply.nodeBuffer, reply.nodeBytes, 0);
		m_node->IncRef("Recv");
	}

	m_result = reply.result;
	m_state	 = kTransStateComplete;
	
	return true;
}


/*****************************************************************************
*
*   VaultFindNodeTrans
*
***/

//============================================================================
VaultFindNodeTrans::VaultFindNodeTrans (
	NetVaultNode *				templateNode,
	FNetCliAuthVaultNodeFind	callback,
	void *						param
) : NetAuthTrans(kVaultFindNodeTrans)
,	m_node(templateNode)
,	m_callback(callback)
,	m_param(param)
{
	m_node->IncRef();
}

//============================================================================
VaultFindNodeTrans::~VaultFindNodeTrans () {
	m_node->DecRef();
}

//============================================================================
bool VaultFindNodeTrans::Send () {
	if (!AcquireConn())
		return false;
		
	ARRAY(byte)	buffer;
	m_node->critsect.Enter();
	m_node->Write_LCS(&buffer, 0);
	m_node->critsect.Leave();

	const unsigned_ptr msg[] = {
		kCli2Auth_VaultNodeFind,
						m_transId,
						buffer.Count(),
		(unsigned_ptr)	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 byte	msg[],
	unsigned	bytes
) {
	const Auth2Cli_VaultNodeFindReply & reply = *(const Auth2Cli_VaultNodeFindReply *) msg;

	if (IS_NET_SUCCESS(reply.result)) {
		COMPILER_ASSERT(sizeof(unsigned) == sizeof(dword));
		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_templateNode->IncRef();
}

//============================================================================
bool VaultCreateNodeTrans::Send () {
	if (!AcquireConn())
		return false;
		
	ARRAY(byte)	buffer;
	m_templateNode->Write_LCS(&buffer, 0);

	const unsigned_ptr msg[] = {
		kCli2Auth_VaultNodeCreate,
						m_transId,
						buffer.Count(),
		(unsigned_ptr)	buffer.Ptr()
	};
			
	m_conn->Send(msg, arrsize(msg));
	
	return true;
}

//============================================================================
void VaultCreateNodeTrans::Post () {
	m_callback(
		m_result,
		m_param,
		m_nodeId
	);
	m_templateNode->DecRef();
}

//============================================================================
bool VaultCreateNodeTrans::Recv (
	const byte	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 Uuid &						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 byte *)data, dataCount);
}

//============================================================================
bool VaultSaveNodeTrans::Send () {
	if (!AcquireConn())
		return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_VaultNodeSave,
						m_transId,
						m_nodeId,
		(unsigned_ptr)	&m_revisionId,
						m_buffer.Count(),
		(unsigned_ptr)	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 byte	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 unsigned_ptr 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 byte	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 unsigned_ptr 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 byte	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 unsigned_ptr 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 byte  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									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 unsigned_ptr msg[] = {
		kCli2Auth_ChangePlayerNameRequest,
						m_transId,
						m_playerId,
		(unsigned_ptr)  m_newName,
	};

	m_conn->Send(msg, arrsize(msg));

	return true;
}

//============================================================================
void ChangePlayerNameRequestTrans::Post () {
    m_callback(
		m_result,
		m_param
	);
}

//============================================================================
bool ChangePlayerNameRequestTrans::Recv (
    const byte  msg[],
    unsigned    bytes
) {
    const Auth2Cli_ChangePlayerNameReply & reply = *(const Auth2Cli_ChangePlayerNameReply *) msg;

	m_result    = reply.result;
    m_state		= kTransStateComplete;
    return true;
}


/*****************************************************************************
*
*   SendFriendInviteTrans
*
***/

//============================================================================
SendFriendInviteTrans::SendFriendInviteTrans (
	const wchar								emailAddr[],
	const wchar								toName[],
	const Uuid &							inviteUuid,
    FNetCliAuthSendFriendInviteCallback		callback,
    void *									param
) : NetAuthTrans(kSendFriendInviteTrans)
,	m_callback(callback)
,	m_param(param)
,	m_inviteUuid(inviteUuid)
{
	StrCopy(m_emailAddress, emailAddr, arrsize(m_emailAddress));
	StrCopy(m_toName, toName, arrsize(m_toName));
}

//============================================================================
bool SendFriendInviteTrans::Send () {
	if (!AcquireConn())
		return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_SendFriendInviteRequest,
						m_transId,
		(unsigned_ptr) &m_inviteUuid,
		(unsigned_ptr)  m_emailAddress,
		(unsigned_ptr)  m_toName,
	};

	m_conn->Send(msg, arrsize(msg));

	return true;
}

//============================================================================
void SendFriendInviteTrans::Post () {
    m_callback(
		m_result,
		m_param
	);
}

//============================================================================
bool SendFriendInviteTrans::Recv (
    const byte  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 char*						gameName,
	unsigned						gameType,
	int								value,
	FNetCliAuthCreateScoreCallback	callback,
	void *							param
) : NetAuthTrans(kScoreCreateTrans)
,	m_callback(callback)
,	m_param(param)
,	m_ownerId(ownerId)
,	m_gameType(gameType)
,	m_value(value)
,	m_scoreId(0)
,	m_createdTime(0)
{
	StrCopy(m_gameName, gameName, arrsize(m_gameName));
}

//============================================================================
bool ScoreCreateTrans::Send () {
	if (!AcquireConn())
		return false;

	wchar wgameName[kMaxGameScoreNameLength];
	StrToUnicode(wgameName, m_gameName, arrsize(wgameName));

	const unsigned_ptr msg[] = {
			kCli2Auth_ScoreCreate,
						m_transId,
						m_ownerId,
		(unsigned_ptr)  wgameName,
						m_gameType,
						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 byte  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 unsigned_ptr 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 byte  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 char*						gameName,
	FNetCliAuthGetScoresCallback	callback,
	void *							param
) : NetAuthTrans(kScoreGetScoresTrans)
,	m_callback(callback)
,	m_param(param)
,	m_ownerId(ownerId)
,	m_scores(nil)
,	m_scoreCount(0)
{
	StrCopy(m_gameName, gameName, arrsize(m_gameName));
}

//============================================================================
bool ScoreGetScoresTrans::Send () {
	if (!AcquireConn())
		return false;

	wchar wgameName[kMaxGameScoreNameLength];
	StrToUnicode(wgameName, m_gameName, arrsize(wgameName));

	const unsigned_ptr msg[] = {
		kCli2Auth_ScoreGetScores,
						m_transId,
						m_ownerId,
		(unsigned_ptr)  wgameName
	};

	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 byte  msg[],
    unsigned    bytes
) {
    const Auth2Cli_ScoreGetScoresReply & reply = *(const Auth2Cli_ScoreGetScoresReply *) msg;

	if (reply.scoreCount > 0) {
		m_scoreCount	= reply.scoreCount;
		m_scores		= TRACKED_NEW NetGameScore[m_scoreCount];

		byte*		bufferPos = const_cast<byte*>(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 unsigned_ptr msg[] = {
		kCli2Auth_ScoreAddPoints,
						m_transId,
						m_scoreId,
						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 byte  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 unsigned_ptr msg[] = {
		kCli2Auth_ScoreTransferPoints,
						m_transId,
						m_srcScoreId,
						m_destScoreId,
						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 byte  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 unsigned_ptr msg[] = {
		kCli2Auth_ScoreSetPoints,
						m_transId,
						m_scoreId,
						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 byte  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 char *				cGameName,
	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_timePeriod(timePeriod)
,	m_numResults(numResults)
,	m_pageNumber(pageNumber)
,	m_sortDesc(sortDesc)
{
	StrToUnicode(m_gameName, cGameName, arrsize(m_gameName));
}

//============================================================================
bool ScoreGetRanksTrans::Send () {
	if (!AcquireConn())
		return false;

	const unsigned_ptr msg[] = {
		kCli2Auth_ScoreGetRanks,
						m_transId,
						m_ownerId,
						m_scoreGroup,
						m_parentFolderId,
		(unsigned_ptr)	m_gameName,
						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 byte  msg[],
    unsigned    bytes
) {
    const Auth2Cli_ScoreGetRanksReply & reply = *(const Auth2Cli_ScoreGetRanksReply *) msg;

	if (reply.rankCount > 0) {
		m_rankCount	= reply.rankCount;
		m_ranks		= TRACKED_NEW NetGameRank[m_rankCount];

		byte*		bufferPos = const_cast<byte*>(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;
}

} 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->DecRef("AcquireConn");
        m_conn = nil;
    }
}


/*****************************************************************************
*
*   Protected functions
*
***/

//============================================================================
void AuthInitialize () {
    s_running = true;
    NetMsgProtocolRegister(
        kNetProtocolCli2Auth,
        false,
        s_send, arrsize(s_send),
        s_recv, arrsize(s_recv),
        kDhGValue,
        BigNum(sizeof(kDhXData), kDhXData),
        BigNum(sizeof(kDhNData), kDhNData)
    );
}

//============================================================================
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();
    {
		if (nil != (result = s_active))
			result &= (nil != 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 wchar *   authAddrList[],
    unsigned        authAddrCount
) {
    // TEMP: Only connect to one auth server until we fill out this module
    // to choose the "best" auth connection.
    authAddrCount = min(authAddrCount, 1);

    for (unsigned i = 0; i < authAddrCount; ++i) {
        // Do we need to lookup the address?
        const wchar * name = authAddrList[i];
        while (unsigned ch = *name) {
            ++name;
			if (!(isdigit(ch) || ch == L'.' || ch == L':')) {
                AsyncCancelId cancelId;
                AsyncAddressLookupName(
                    &cancelId,
                    AsyncLookupCallback,
                    authAddrList[i],
                    kNetDefaultClientPort,
                    nil
                );
                break;
            }
        }
        if (!name[0]) {
            NetAddress addr;
            NetAddressFromString(&addr, authAddrList[i], kNetDefaultClientPort);
            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									accountName[],
    FNetCliAuthAccountExistsRequestCallback		callback,
    void *										param
) {
	AccountExistsRequestTrans * trans = NEW(AccountExistsRequestTrans)(
		callback,
		param,
		accountName
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthLoginRequest (
    const wchar                     accountName[],
    const ShaDigest *				accountNamePassHash,
	const wchar						authToken[],
	const wchar						os[],
    FNetCliAuthLoginRequestCallback callback,
    void *                          param
) {
    // Cache updated login info if provided.
    if (accountName)
        StrCopy(s_accountName, accountName, arrsize(s_accountName));
    if (accountNamePassHash)
        s_accountNamePassHash = *accountNamePassHash;
	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 wchar							ageName[],
    const Uuid &                        ageInstId,
    FNetCliAuthAgeRequestCallback       callback,
    void *                              param
) {
    AgeRequestTrans * trans = NEW(AgeRequestTrans)(
        ageName,
        ageInstId,
        callback,
        param
    );
    NetTransSend(trans);
}

//============================================================================
void NetCliAuthGetEncryptionKey (
	UInt32		key[],
	unsigned	size
) {
	unsigned memSize = min(arrsize(s_encryptionKey), size);
	memSize *= sizeof(UInt32);
	MemCopy(key, s_encryptionKey, memSize);
}

//============================================================================
void NetCliAuthAccountCreateRequest (
	const wchar								accountName[],
	const wchar								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										accountName[],
	const wchar										password[],
	Uuid											key,
	unsigned										billingType,
	FNetCliAuthAccountCreateFromKeyRequestCallback	callback,
	void *											param
) {
	AccountCreateFromKeyRequestTrans * trans = NEW(AccountCreateFromKeyRequestTrans)(
		accountName,
		password,
		key,
		billingType,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthPlayerCreateRequest (
	const wchar								playerName[],
	const wchar								avatarShape[],
	const wchar								friendInvite[],
	FNetCliAuthPlayerCreateRequestCallback	callback,
	void *									param
) {
	wchar name[kMaxPlayerNameLength];
	StrCopy(name, playerName, arrsize(name));
	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 unsigned_ptr msg[] = {
		kCli2Auth_ClientSetCCRLevel,
					ccrLevel,
	};
	
	conn->Send(msg, arrsize(msg));
    conn->DecRef("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 unsigned_ptr msg[] = {
		kCli2Auth_SetAgePublic,
					ageInfoId,
					publicOrNot,
	};
	
	conn->Send(msg, arrsize(msg));

    conn->DecRef("SetAgePublic");
}

//============================================================================
void NetCliAuthGetPublicAgeList (
	const wchar							ageName[],
	FNetCliAuthGetPublicAgeListCallback	callback,
	void *								param
) {
	GetPublicAgeListTrans * trans = NEW(GetPublicAgeListTrans)(
		ageName,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthAccountChangePasswordRequest (
	const wchar										accountName[],
	const wchar										password[],
	FNetCliAuthAccountChangePasswordRequestCallback	callback,
	void *											param
) {
	AccountChangePasswordRequestTrans * trans = NEW(AccountChangePasswordRequestTrans)(
		accountName,
		password,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthAccountSetRolesRequest (
	const wchar									accountName[],
	unsigned									accountFlags,
	FNetCliAuthAccountSetRolesRequestCallback	callback,
	void *										param
) {
	AccountSetRolesRequestTrans * trans = NEW(AccountSetRolesRequestTrans)(
		accountName,
		accountFlags,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthAccountSetBillingTypeRequest (
	const wchar										accountName[],
	unsigned										billingType,
	FNetCliAuthAccountSetBillingTypeRequestCallback	callback,
	void *											param
) {
	AccountSetBillingTypeRequestTrans * trans = NEW(AccountSetBillingTypeRequestTrans)(
		accountName,
		billingType,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthAccountActivateRequest (
	const Uuid &								activationKey,
	FNetCliAuthAccountActivateRequestCallback	callback,
	void *										param
) {
	AccountActivateRequestTrans * trans = NEW(AccountActivateRequestTrans)(
		activationKey,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthFileListRequest (
    const wchar                         dir[],
    const wchar                         ext[],
    FNetCliAuthFileListRequestCallback  callback,
    void *                              param
) {
	FileListRequestTrans * trans = NEW(FileListRequestTrans)(
		callback,
		param,
		dir,
		ext
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthFileRequest (
    const wchar                     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 = NEWZERO(VaultCreateNodeTrans)(
		templateNode,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthVaultNodeFetch (
	unsigned					nodeId,
	FNetCliAuthVaultNodeFetched	callback,
	void *						param
) {
	VaultFetchNodeTrans * trans = NEWZERO(VaultFetchNodeTrans)(
		nodeId,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthVaultNodeFind (
	NetVaultNode *				templateNode,
	FNetCliAuthVaultNodeFind	callback,
	void *						param
) {
	VaultFindNodeTrans * trans = NEWZERO(VaultFindNodeTrans)(
		templateNode,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
unsigned NetCliAuthVaultNodeSave (
	NetVaultNode *						node,
	FNetCliAuthVaultNodeSaveCallback	callback,
	void *								param
) {
	ASSERTMSG(!(node->dirtyFlags & NetVaultNode::kNodeType), "Node type may not be changed");
	
	// Clear dirty bits of read-only fields before we write the node to the msg buffer
	node->dirtyFlags &= ~(
		NetVaultNode::kNodeId |
		NetVaultNode::kNodeType |
		NetVaultNode::kCreatorAcct |
		NetVaultNode::kCreatorId |
		NetVaultNode::kCreateTime
	);
	
	if (!node->dirtyFlags)
		return 0;
		
	if (!node->nodeId)
		return 0;
		
	// force sending of the nodeType value, since the auth needs it.
	// auth will clear the field before sending it on to the vault.
	node->dirtyFlags |= NetVaultNode::kNodeType;

	// We're definitely saving this node, so assign a revisionId
    node->revisionId = GuidGenerate();

	ARRAY(byte)	buffer;
	unsigned bytes = node->Write_LCS(&buffer, NetVaultNode::kRwDirtyOnly | NetVaultNode::kRwUpdateDirty);
	
	VaultSaveNodeTrans * trans = NEWZERO(VaultSaveNodeTrans)(
		node->nodeId,
		node->revisionId,
		buffer.Count(),
		buffer.Ptr(),
		callback,
		param
	);
	NetTransSend(trans);
    return bytes;
}

//============================================================================
void NetCliAuthVaultNodeDelete (
	unsigned					nodeId
) {
	hsAssert(false, "eric, implement me");
}

//============================================================================
void NetCliAuthVaultNodeAdd (
	unsigned						parentId,
	unsigned						childId,
	unsigned						ownerId,
	FNetCliAuthVaultNodeAddCallback	callback,
	void *							param
) {
	VaultAddNodeTrans * trans = NEWZERO(VaultAddNodeTrans)(
		parentId,
		childId,
		ownerId,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthVaultNodeRemove (
	unsigned							parentId,
	unsigned							childId,
	FNetCliAuthVaultNodeRemoveCallback	callback,
	void *								param
) {
    VaultRemoveNodeTrans * trans = NEWZERO(VaultRemoveNodeTrans)(
		parentId,
		childId,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthVaultFetchNodeRefs (
	unsigned						nodeId,
	FNetCliAuthVaultNodeRefsFetched	callback,
	void *							param
) {
	VaultFetchNodeRefsTrans * trans = NEWZERO(VaultFetchNodeRefsTrans)(
		nodeId,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthVaultSetSeen (
	unsigned	parentId,
	unsigned	childId,
	bool		seen
) {
    CliAuConn * conn = GetConnIncRef("SetSeen");
    if (!conn)
        return;

	const unsigned_ptr msg[] = {
		kCli2Auth_VaultSetSeen,
					parentId,
					childId,
					seen,
	};
	
	conn->Send(msg, arrsize(msg));

    conn->DecRef("SetSeen");
}

//============================================================================
void NetCliAuthVaultSendNode (
	unsigned	srcNodeId,
	unsigned	dstPlayerId
) {
    CliAuConn * conn = GetConnIncRef("SendNode");
    if (!conn)
        return;

	const unsigned_ptr msg[] = {
		kCli2Auth_VaultSendNode,
					srcNodeId,
					dstPlayerId,
	};
	
	conn->Send(msg, arrsize(msg));

    conn->DecRef("SendNode");
}

//============================================================================
void NetCliAuthVaultInitAge (
	const Uuid &				ageInstId,			// optional. is used in match
	const Uuid &				parentAgeInstId,	// optional. is used in match
	const wchar					ageFilename[],		// optional. is used in match
	const wchar					ageInstName[],		// optional. not used in match
	const wchar					ageUserName[],		// optional. not used in match
	const wchar					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 = NEWZERO(VaultInitAgeTrans)(
		callback,
		param,
		ageInstId,
		parentAgeInstId,
		ageFilename,
		ageInstName,
		ageUserName,
		ageDesc,
		ageSequenceNumber,
		ageLanguage
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthSetRecvBufferHandler (
    FNetCliAuthRecvBufferHandler    handler
) {
    s_bufRcvdCb = handler;
}

//============================================================================
void NetCliAuthSendCCRPetition (
	const wchar *		petitionText
) {
	hsAssert(false, "eric, implement me.");
}

//============================================================================
void NetCliAuthPropagateBuffer (
    unsigned                        type,
    unsigned                        bytes,
    const byte                      buffer[]
) {
    CliAuConn * conn = GetConnIncRef("PropBuffer");
    if (!conn)
        return;

    const unsigned_ptr msg[] = {
        kCli2Auth_PropagateBuffer,
        type,
        bytes,
        (unsigned_ptr) buffer,
    };

	conn->Send(msg, arrsize(msg));

    conn->DecRef("PropBuffer");

}

//============================================================================
void NetCliAuthLogPythonTraceback (const wchar traceback[]) {
	CliAuConn * conn = GetConnIncRef("LogTraceback");
	if (!conn)
        return;

    const unsigned_ptr msg[] = {
       kCli2Auth_LogPythonTraceback,
       (unsigned_ptr) traceback
    };

	conn->Send(msg, arrsize(msg));

    conn->DecRef("LogTraceback");
}


//============================================================================
void NetCliAuthLogStackDump (const wchar stackdump[]) {
	CliAuConn * conn = GetConnIncRef("LogStackDump");
	if (!conn)
        return;

    const unsigned_ptr msg[] = {
       kCli2Auth_LogStackDump,
       (unsigned_ptr) stackdump
    };

	conn->Send(msg, arrsize(msg));

    conn->DecRef("LogStackDump");
}

//============================================================================
void NetCliAuthLogClientDebuggerConnect () {
	CliAuConn * conn = GetConnIncRef("");
	if (!conn)
        return;

	unsigned nothing = 0;

    const unsigned_ptr msg[] = {
       kCli2Auth_LogClientDebuggerConnect,
		nothing
    };

	conn->Send(msg, arrsize(msg));

    conn->DecRef();
}

//============================================================================
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 unsigned_ptr msg[] = {
       kCli2Auth_KickPlayer,
					playerId
    };

	conn->Send(msg, arrsize(msg));
    conn->DecRef("KickPlayer");
}

//============================================================================
void NetCliAuthChangePlayerNameRequest (
	unsigned									playerId,
	const wchar									newName[],
	FNetCliAuthChangePlayerNameRequestCallback	callback,
	void *										param
) {
    ChangePlayerNameRequestTrans * trans = NEW(ChangePlayerNameRequestTrans)(
		playerId,
		newName,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthSendFriendInvite (
	const wchar							emailAddress[],
	const wchar							toName[],
	const Uuid&							inviteUuid,
	FNetCliAuthSendFriendInviteCallback	callback,
	void *								param
) {
	SendFriendInviteTrans * trans = NEW(SendFriendInviteTrans)(
		emailAddress,
		toName,
		inviteUuid,
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliAuthScoreCreate (
	unsigned						ownerId,
	const char*						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 char*						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 char *				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);
}