CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plNetGameLib/Private/plNglFile.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/plNglFile.cpp
*   
***/

#include "../Pch.h"
#pragma hdrstop

// Define this if the file servers are running behind load-balancing hardware.
// It changes the logic by which the decision to attempt a reconnect is made.
#define LOAD_BALANCER_HARDWARE


namespace Ngl { namespace File {
/*****************************************************************************
*
*   Private
*
***/

struct CliFileConn : AtomicRef {
	LINK(CliFileConn)	link;
	CLock				sockLock; // to protect the socket pointer so we don't nuke it while using it
	AsyncSocket			sock;
	wchar				name[MAX_PATH];
	NetAddress			addr;
	unsigned			seq;
	ARRAY(byte)			recvBuffer;
	AsyncCancelId		cancelId;
	bool				abandoned;
	unsigned			buildId;
	unsigned			serverType;

	CCritSect			timerCritsect; // critsect for both timers

	// Reconnection
	AsyncTimer *		reconnectTimer;
	unsigned			reconnectStartMs;
	unsigned			connectStartMs;
	unsigned			numImmediateDisconnects;
	unsigned			numFailedConnects;

	// Ping
	AsyncTimer *		pingTimer;
	unsigned			pingSendTimeMs;
	unsigned			lastHeardTimeMs;

	CliFileConn ();
	~CliFileConn ();

	// 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 () {return (reconnectTimer != nil);}
	void StopAutoReconnect (); // call before destruction
	void StartAutoReconnect ();
	void TimerReconnect ();

	// ping
	void AutoPing ();
	void StopAutoPing ();
	void TimerPing ();
	
	void Send (const void * data, unsigned bytes);

	void Destroy(); // cleans up the socket and buffer

	void Dispatch (const Cli2File_MsgHeader * msg);
	bool Recv_PingReply (const File2Cli_PingReply * msg);
	bool Recv_BuildIdReply (const File2Cli_BuildIdReply * msg);
	bool Recv_BuildIdUpdate (const File2Cli_BuildIdUpdate * msg);
	bool Recv_ManifestReply (const File2Cli_ManifestReply * msg);
	bool Recv_FileDownloadReply (const File2Cli_FileDownloadReply * msg);
};


//============================================================================
// BuildIdRequestTrans
//============================================================================
struct BuildIdRequestTrans : NetFileTrans {
	FNetCliFileBuildIdRequestCallback	m_callback;
	void *								m_param;

	unsigned							m_buildId;
	
	BuildIdRequestTrans (
		FNetCliFileBuildIdRequestCallback	callback,
		void *								param
	);

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

//============================================================================
// ManifestRequestTrans
//============================================================================
struct ManifestRequestTrans : NetFileTrans {
	FNetCliFileManifestRequestCallback	m_callback;
	void *								m_param;
	wchar								m_group[MAX_PATH];
	unsigned							m_buildId;

	ARRAY(NetCliFileManifestEntry)		m_manifest;
	unsigned							m_numEntriesReceived;

	ManifestRequestTrans (
		FNetCliFileManifestRequestCallback	callback,
		void *								param,
		const wchar							group[],
		unsigned							buildId
	);

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

//============================================================================
// DownloadRequestTrans
//============================================================================
struct DownloadRequestTrans : NetFileTrans {
	FNetCliFileDownloadRequestCallback	m_callback;
	void *								m_param;

	wchar								m_filename[MAX_PATH];
	hsStream *							m_writer;
	unsigned							m_buildId;
	
	unsigned							m_totalBytesReceived;

	DownloadRequestTrans (
		FNetCliFileDownloadRequestCallback	callback,
		void *								param,
		const wchar							filename[],
		hsStream *							writer,
		unsigned							buildId
	);

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

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

	unsigned	bytes;
	byte *		data;
	hsStream *	writer;

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


/*****************************************************************************
*
*   Private data
*
***/

enum {
	kPerfConnCount,
	kNumPerf
};

static bool							s_running;
static CCritSect					s_critsect;
static LISTDECL(CliFileConn, link)	s_conns;
static CliFileConn *				s_active;
static long							s_perf[kNumPerf];
static unsigned						s_connectBuildId;
static unsigned						s_serverType;

static FNetCliFileBuildIdUpdateCallback	s_buildIdCallback = nil;

const unsigned kMinValidConnectionMs				= 25 * 1000;



/*****************************************************************************
*
*   Internal functions
*
***/

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

//============================================================================
static CliFileConn * GetConnIncRef_CS (const char tag[]) {
	if (CliFileConn * conn = s_active) {
		conn->IncRef(tag);
		return conn;
	}
	return nil;
}

//============================================================================
static CliFileConn * GetConnIncRef (const char tag[]) {
	CliFileConn * conn;
	s_critsect.Enter();
	{
		conn = GetConnIncRef_CS(tag);
	}
	s_critsect.Leave();
	return conn;
}

//============================================================================
static void UnlinkAndAbandonConn_CS (CliFileConn * conn) {
	s_conns.Unlink(conn);
	conn->abandoned = true;

	if (conn->AutoReconnectEnabled())
		conn->StopAutoReconnect();

	bool needsDecref = true;
	if (conn->cancelId) {
		AsyncSocketConnectCancel(nil, conn->cancelId);
		conn->cancelId  = 0;
		needsDecref = false;
	}
	else {
		conn->sockLock.EnterRead();
		if (conn->sock) {
			AsyncSocketDisconnect(conn->sock, true);
			needsDecref = false;
		}
		conn->sockLock.LeaveRead();
	}
	if (needsDecref) {
		conn->DecRef("Lifetime");
	}
}

//============================================================================
static void NotifyConnSocketConnect (CliFileConn * conn) {

	conn->TransferRef("Connecting", "Connected");
	conn->connectStartMs = TimeGetMs();
    conn->numFailedConnects = 0;

    // Make this the active server
	s_critsect.Enter();
	{
		if (!conn->abandoned) {
			conn->AutoPing();
			s_active = conn;
		}
		else
		{
			conn->sockLock.EnterRead();
			AsyncSocketDisconnect(conn->sock, true);
			conn->sockLock.LeaveRead();
		}
	}
	s_critsect.Leave();
}

//============================================================================
static void NotifyConnSocketConnectFailed (CliFileConn * conn) {
    s_critsect.Enter();
    {
		conn->cancelId = 0;
        s_conns.Unlink(conn);

        if (conn == s_active)
            s_active = nil;
    }
    s_critsect.Leave();
    
    // Cancel all transactions in progress on this connection.
    NetTransCancelByConnId(conn->seq, kNetErrTimeout);
	
#ifndef SERVER
	// Client apps fail if unable to connect for a time
    if (++conn->numFailedConnects >= kMaxFailedConnects) {
		ReportNetError(kNetProtocolCli2File, kNetErrConnectFailed);
	}
	else
#endif // ndef SERVER
	{
		// start reconnect, if we are doing that
		if (s_running && conn->AutoReconnectEnabled())
			conn->StartAutoReconnect();
		else
			conn->DecRef("Lifetime"); // if we are not reconnecting, this socket is done, so remove the lifetime ref
	}
	conn->DecRef("Connecting");
}

//============================================================================
static void NotifyConnSocketDisconnect (CliFileConn * conn) {
	conn->StopAutoPing();
    s_critsect.Enter();
    {
		conn->cancelId = 0;
        s_conns.Unlink(conn);
			
        if (conn == s_active)
            s_active = nil;
    }
    s_critsect.Leave();

    // Cancel all transactions in progress on this connection.
    NetTransCancelByConnId(conn->seq, kNetErrTimeout);


	bool notify = false;

#ifdef SERVER
	{
		if (TimeGetMs() - conn->connectStartMs > kMinValidConnectionMs)
			conn->reconnectStartMs = 0;
		else
			conn->reconnectStartMs = GetNonZeroTimeMs() + kMaxReconnectIntervalMs;
	}
#else
	{
	#ifndef LOAD_BALANCER_HARDWARE
		// If the connection to the remote server was open for longer than
		// kMinValidConnectionMs then assume that the connection was to
		// a valid server and try to perform reconnection immediately. If
		// less time elapsed then the connection was likely to a server
		// with an open port but with no notification procedure registered
		// for this type of communication channel.
		if (TimeGetMs() - conn->connectStartMs > kMinValidConnectionMs) {
			conn->reconnectStartMs = 0;
		}
		else {
			if (++conn->numImmediateDisconnects < kMaxImmediateDisconnects)
				conn->reconnectStartMs = GetNonZeroTimeMs() + kMaxReconnectIntervalMs;
			else
				notify = true;
		}
	#else
		// File server is running behind a load-balancer, so the next connection may
		// send us to a new server, therefore attempt a reconnection to the same
		// address even if the disconnect was immediate.  This is safe because the
		// file server is stateless with respect to clients.
		if (TimeGetMs() - conn->connectStartMs <= kMinValidConnectionMs) {
			if (++conn->numImmediateDisconnects < kMaxImmediateDisconnects)
				conn->reconnectStartMs = GetNonZeroTimeMs() + kMaxReconnectIntervalMs;
			else
				notify = true;
		}
		else {
			// disconnect was not immediate. attempt a reconnect unless we're shutting down
			conn->numImmediateDisconnects = 0;
			conn->reconnectStartMs = 0;
		}
	#endif	// LOAD_BALANCER
	}
#endif // ndef SERVER

	if (notify) {
		ReportNetError(kNetProtocolCli2File, kNetErrDisconnected);
	}
	else {	
		// clean up the socket and start reconnect, if we are doing that
		conn->Destroy();
		if (conn->AutoReconnectEnabled())
			conn->StartAutoReconnect();
		else
			conn->DecRef("Lifetime"); // if we are not reconnecting, this socket is done, so remove the lifetime ref
	}

	conn->DecRef("Connected");
}

//============================================================================
static bool NotifyConnSocketRead (CliFileConn * conn, AsyncNotifySocketRead * read) {
	conn->lastHeardTimeMs = GetNonZeroTimeMs();
	conn->recvBuffer.Add(read->buffer, read->bytes);
	read->bytesProcessed += read->bytes;

	for (;;) {
		if (conn->recvBuffer.Count() < sizeof(dword))
			return true;

		dword msgSize = *(dword *)conn->recvBuffer.Ptr();
		if (conn->recvBuffer.Count() < msgSize)
			return true;

		const Cli2File_MsgHeader * msg = (const Cli2File_MsgHeader *) conn->recvBuffer.Ptr();
		conn->Dispatch(msg);

		conn->recvBuffer.Move(0, msgSize, conn->recvBuffer.Count() - msgSize);
		conn->recvBuffer.ShrinkBy(msgSize);
	}
}

//============================================================================
static bool SocketNotifyCallback (
	AsyncSocket			sock,
	EAsyncNotifySocket	code,
	AsyncNotifySocket *	notify,
		void **				userState
) {
	bool result = true;
	CliFileConn * conn;

	switch (code) {
		case kNotifySocketConnectSuccess:
            conn = (CliFileConn *) notify->param;
            *userState = conn;
            s_critsect.Enter();
            {
				conn->sockLock.EnterWrite();
				conn->sock		= sock;
				conn->sockLock.LeaveWrite();
				conn->cancelId	= 0;
            }
            s_critsect.Leave();
            NotifyConnSocketConnect(conn);
		break;

		case kNotifySocketConnectFailed:
			conn = (CliFileConn *) notify->param;
			NotifyConnSocketConnectFailed(conn);
		break;

		case kNotifySocketDisconnect:
			conn = (CliFileConn *) *userState;
			NotifyConnSocketDisconnect(conn);
		break;

		case kNotifySocketRead:
			conn = (CliFileConn *) *userState;
			result = NotifyConnSocketRead(conn, (AsyncNotifySocketRead *) notify);
		break;
	}

	return result;
}

//============================================================================
static void Connect (CliFileConn * conn) {
	ASSERT(s_running);

	conn->pingSendTimeMs = 0;

    s_critsect.Enter();
    {
		while (CliFileConn * oldConn = s_conns.Head()) {
			if (oldConn != conn)
				UnlinkAndAbandonConn_CS(oldConn);
			else
				s_conns.Unlink(oldConn);
		}
        s_conns.Link(conn);
    }
    s_critsect.Leave();

	Cli2File_Connect connect;
	connect.hdr.connType	= kConnTypeCliToFile;
	connect.hdr.hdrBytes	= sizeof(connect.hdr);
	connect.hdr.buildId		= kFileSrvBuildId;
	connect.hdr.buildType	= BuildType();
	connect.hdr.branchId	= BranchId();
	connect.hdr.productId	= ProductId();
	connect.data.buildId	= conn->buildId;
	connect.data.serverType = conn->serverType;
	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);
	
    CliFileConn * conn = NEWZERO(CliFileConn);
    StrCopy(conn->name, name, arrsize(conn->name));
    conn->addr			= addr;
	conn->buildId		= s_connectBuildId;
	conn->serverType	= s_serverType;
    conn->seq			= ConnNextSequence();
	conn->lastHeardTimeMs	= GetNonZeroTimeMs();	// used in connect timeout, and ping timeout

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

//============================================================================
static void AsyncLookupCallback (
	void *				param,
	const wchar			name[],
	unsigned			addrCount,
	const NetAddress	addrs[]
) {
    if (!addrCount) {
		ReportNetError(kNetProtocolCli2File, kNetErrNameLookupFailed);
		return;
	}

	for (unsigned i = 0; i < addrCount; ++i) {
		Connect(name, addrs[i]);
	}
}

/*****************************************************************************
*
*   CliFileConn
*
***/

//============================================================================
CliFileConn::CliFileConn () {
	AtomicAdd(&s_perf[kPerfConnCount], 1);
}

//============================================================================
CliFileConn::~CliFileConn () {
	ASSERT(!cancelId);
	ASSERT(!reconnectTimer);
	Destroy();
	AtomicAdd(&s_perf[kPerfConnCount], -1);
}

//===========================================================================
void CliFileConn::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);
	}
}

//===========================================================================
static unsigned CliFileConnTimerReconnectProc (void * param) {
	((CliFileConn *) param)->TimerReconnect();
	return kAsyncTimeInfinite;
}

//===========================================================================
// This function is called when after a disconnect to start a new connection
void CliFileConn::StartAutoReconnect () {
	timerCritsect.Enter();
	if (reconnectTimer) {
		// 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;
		}
		AsyncTimerUpdate(reconnectTimer, remainingMs);
	}
	timerCritsect.Leave();
}

//===========================================================================
// This function should be called during object construction
// to initiate connection attempts to the remote host whenever
// the socket is disconnected.
void CliFileConn::AutoReconnect () {
	timerCritsect.Enter();
	{
		ASSERT(!reconnectTimer);
		IncRef("ReconnectTimer");
		AsyncTimerCreate(
			&reconnectTimer,
			CliFileConnTimerReconnectProc,
			0,  // immediate callback
			this
		);
	}
	timerCritsect.Leave();
}

//===========================================================================
static unsigned CliFileConnTimerDestroyed (void * param) {
	CliFileConn * sock = (CliFileConn *) param;
	sock->DecRef("TimerDestroyed");
	return kAsyncTimeInfinite;
}

//============================================================================
void CliFileConn::StopAutoReconnect () {
	timerCritsect.Enter();
	{
		if (AsyncTimer * timer = reconnectTimer) {
			reconnectTimer = nil;
			AsyncTimerDeleteCallback(timer, CliFileConnTimerDestroyed);
		}
	}
	timerCritsect.Leave();
}

//===========================================================================
static unsigned CliFileConnPingTimerProc (void * param) {
	((CliFileConn *) param)->TimerPing();
	return kPingIntervalMs;
}

//============================================================================
void CliFileConn::AutoPing () {
	ASSERT(!pingTimer);
	IncRef("PingTimer");
	timerCritsect.Enter();
	{
		sockLock.EnterRead();
		unsigned timerPeriod = sock ? 0 : kAsyncTimeInfinite;
		sockLock.LeaveRead();

		AsyncTimerCreate(
			&pingTimer,
			CliFileConnPingTimerProc,
			timerPeriod,
			this
		);
	}
	timerCritsect.Leave();
}

//============================================================================
void CliFileConn::StopAutoPing () {
	timerCritsect.Enter();
	{
		if (AsyncTimer * timer = pingTimer) {
			pingTimer = nil;
			AsyncTimerDeleteCallback(timer, CliFileConnTimerDestroyed);
		}
	}
	timerCritsect.Leave();
}

//============================================================================
void CliFileConn::TimerPing () {
	sockLock.EnterRead();
	for (;;) {
		if (!sock) // make sure it exists
			break;
#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();

			Cli2File_PingRequest msg;
			msg.messageId = kCli2File_PingRequest;
			msg.messageBytes = sizeof(msg);
			msg.pingTimeMs = pingSendTimeMs;

			// read locks are reentrant, so calling Send is ok here within the read lock
			Send(&msg, msg.messageBytes);
		}
		break;
	}
	sockLock.LeaveRead();
}

//============================================================================
void CliFileConn::Destroy () {
	AsyncSocket oldSock = nil;

	sockLock.EnterWrite();
	{
		SWAP(oldSock, sock);
	}
	sockLock.LeaveWrite();

	if (oldSock)
		AsyncSocketDelete(oldSock);
	recvBuffer.Clear();
}

//============================================================================
void CliFileConn::Send (const void * data, unsigned bytes) {
	sockLock.EnterRead();
	if (sock) {
		AsyncSocketSend(sock, data, bytes);
	}
	sockLock.LeaveRead();
}

//============================================================================
void CliFileConn::Dispatch (const Cli2File_MsgHeader * msg) {

#define DISPATCH(a) case kFile2Cli_##a: Recv_##a((const File2Cli_##a *) msg); break
	switch (msg->messageId) {
		DISPATCH(PingReply);
		DISPATCH(BuildIdReply);
		DISPATCH(BuildIdUpdate);
		DISPATCH(ManifestReply);
		DISPATCH(FileDownloadReply);
		DEFAULT_FATAL(msg->messageId)
	}
#undef DISPATCH
}

//============================================================================
bool CliFileConn::Recv_PingReply (
	const File2Cli_PingReply * msg
) {
	return true;
}

//============================================================================
bool CliFileConn::Recv_BuildIdReply (
	const File2Cli_BuildIdReply * msg
) {
	NetTransRecv(msg->transId, (const byte *)msg, msg->messageBytes);

	return true;
}

//============================================================================
bool CliFileConn::Recv_BuildIdUpdate (
	const File2Cli_BuildIdUpdate * msg
) {
	if (s_buildIdCallback)
		s_buildIdCallback(msg->buildId);
	return true;
}

//============================================================================
bool CliFileConn::Recv_ManifestReply (
	const File2Cli_ManifestReply * msg
) {
	NetTransRecv(msg->transId, (const byte *)msg, msg->messageBytes);

	return true;
}

//============================================================================
bool CliFileConn::Recv_FileDownloadReply (
	const File2Cli_FileDownloadReply * msg
) {
	NetTransRecv(msg->transId, (const byte *)msg, msg->messageBytes);

	return true;
}


/*****************************************************************************
*
*   BuildIdRequestTrans
*
***/

//============================================================================
BuildIdRequestTrans::BuildIdRequestTrans (
	FNetCliFileBuildIdRequestCallback	callback,
	void *								param
) : NetFileTrans(kBuildIdRequestTrans)
,	m_callback(callback)
,	m_param(param)
{}

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

	Cli2File_BuildIdRequest buildIdReq;
	buildIdReq.messageId = kCli2File_BuildIdRequest;
	buildIdReq.transId = m_transId;
	buildIdReq.messageBytes = sizeof(buildIdReq);

	m_conn->Send(&buildIdReq, buildIdReq.messageBytes);	
	
	return true;
}

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

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

	if (IS_NET_ERROR(reply.result)) {
		// we have a problem...
		m_result	= reply.result;
		m_state		= kTransStateComplete;
		return true;
	}

	m_buildId = reply.buildId;

	// mark as complete
	m_result	= reply.result;
	m_state		= kTransStateComplete;

	return true;
}


/*****************************************************************************
*
*   ManifestRequestTrans
*
***/

//============================================================================
ManifestRequestTrans::ManifestRequestTrans (
	FNetCliFileManifestRequestCallback	callback,
	void *								param,
	const wchar							group[],
	unsigned							buildId
) : NetFileTrans(kManifestRequestTrans)
,	m_callback(callback)
,	m_param(param)
,	m_numEntriesReceived(0)
,	m_buildId(buildId)
{
	if (group)
		StrCopy(m_group, group, arrsize(m_group));
	else
		m_group[0] = L'\0';
}

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

	Cli2File_ManifestRequest manifestReq;
	StrCopy(manifestReq.group, m_group, arrsize(manifestReq.group));
	manifestReq.messageId = kCli2File_ManifestRequest;
	manifestReq.transId = m_transId;
	manifestReq.messageBytes = sizeof(manifestReq);
	manifestReq.buildId = m_buildId;

	m_conn->Send(&manifestReq, manifestReq.messageBytes);	

	return true;
}

//============================================================================
void ManifestRequestTrans::Post () {
	m_callback(m_result, m_param, m_group, m_manifest.Ptr(), m_manifest.Count());
}

//============================================================================
void ReadStringFromMsg(const wchar* curMsgPtr, wchar str[], unsigned maxStrLen, unsigned* length) {
	StrCopy(str, curMsgPtr, maxStrLen);
	str[maxStrLen - 1] = L'\0'; // make sure it's terminated

	(*length) = StrLen(str);
}

//============================================================================
void ReadUnsignedFromMsg(const wchar* curMsgPtr, unsigned* val) {
	(*val) = ((*curMsgPtr) << 16) + (*(curMsgPtr + 1));
}

//============================================================================
bool ManifestRequestTrans::Recv (
	const byte	msg[],
	unsigned	bytes
) {
	m_timeoutAtMs = TimeGetMs() + NetTransGetTimeoutMs(); // Reset the timeout counter

	const File2Cli_ManifestReply & reply = *(const File2Cli_ManifestReply *) msg;

	dword numFiles = reply.numFiles;
	dword wcharCount = reply.wcharCount;
	const wchar* curChar = reply.manifestData;

	// tell the server we got the data
	Cli2File_ManifestEntryAck manifestAck;
	manifestAck.messageId = kCli2File_ManifestEntryAck;
	manifestAck.transId = reply.transId;
	manifestAck.messageBytes = sizeof(manifestAck);
	manifestAck.readerId = reply.readerId;

	m_conn->Send(&manifestAck, manifestAck.messageBytes);	

	// if wcharCount is 2, the data only contains the terminator "\0\0" and we
	// don't need to convert anything (and we are done)
	if ((IS_NET_ERROR(reply.result)) || (wcharCount == 2)) {
		// we have a problem... or we have nothing to so, so we're done
		m_result	= reply.result;
		m_state		= kTransStateComplete;
		return true;
	}

	if (numFiles > m_manifest.Count())
		m_manifest.SetCount(numFiles); // reserve the space ahead of time

	// manifestData format: "clientFile\0downloadFile\0md5\0filesize\0zipsize\0flags\0...\0\0"
	bool done = false;
	while (!done) {
		if (wcharCount == 0)
		{
			done = true;
			break;
		}

		// copy the data over to our array (m_numEntriesReceived is the current index)
		NetCliFileManifestEntry& entry = m_manifest[m_numEntriesReceived];

		// --------------------------------------------------------------------
		// read in the clientFilename
		unsigned filenameLen;
		ReadStringFromMsg(curChar, entry.clientName, arrsize(entry.clientName), &filenameLen);
		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

		// point it at the downloadFile
		curChar++;
		wcharCount--;

		// --------------------------------------------------------------------
		// read in the downloadFilename
		ReadStringFromMsg(curChar, entry.downloadName, arrsize(entry.downloadName), &filenameLen);
		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

		// point it at the md5
		curChar++;
		wcharCount--;

		// --------------------------------------------------------------------
		// read in the md5
		ReadStringFromMsg(curChar, entry.md5, arrsize(entry.md5), &filenameLen);
		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

		// point it at the md5 for compressed files
		curChar++; 
		wcharCount--;

		// --------------------------------------------------------------------
		// read in the md5 for compressed files
		ReadStringFromMsg(curChar, entry.md5compressed, arrsize(entry.md5compressed), &filenameLen);
		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

		// point it at the first part of the filesize value (format: 0xHHHHLLLL)
		curChar++; 
		wcharCount--;

		// --------------------------------------------------------------------
		if (wcharCount < 2) // we have to have 2 chars for the size
			return false; // screwy data
		ReadUnsignedFromMsg(curChar, &entry.fileSize);
		curChar += 2;
		wcharCount -= 2;
		if ((*curChar != L'\0') || (wcharCount <= 0))
			return false; // screwy data

		// point it at the first part of the zipsize value (format: 0xHHHHLLLL)
		curChar++; 
		wcharCount--;

		// --------------------------------------------------------------------
		if (wcharCount < 2) // we have to have 2 chars for the size
			return false; // screwy data
		ReadUnsignedFromMsg(curChar, &entry.zipSize);
		curChar += 2;
		wcharCount -= 2;
		if ((*curChar != L'\0') || (wcharCount <= 0))
			return false; // screwy data

		// point it at the first part of the flags value (format: 0xHHHHLLLL)
		curChar++; 
		wcharCount--;

		// --------------------------------------------------------------------
		if (wcharCount < 2) // we have to have 2 chars for the size
			return false; // screwy data
		ReadUnsignedFromMsg(curChar, &entry.flags);
		curChar += 2;
		wcharCount -= 2;
		if ((*curChar != L'\0') || (wcharCount <= 0))
			return false; // screwy data

		// --------------------------------------------------------------------
		// point it at either the second part of the terminator, or the next filename
		curChar++;
		wcharCount--;

		// do sanity checking
		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 < 14)
			// we must have at least three 1-char strings, three nulls, three 32-bit ints, and 2-char terminator left (3+3+6+2)
			return false; // screwy data

		// increment entries received
		m_numEntriesReceived++;
		if ((m_numEntriesReceived >= numFiles) && !done) {
			// too much data, abort
			return false;
		}
	}
	
	// check for completion
	if (m_numEntriesReceived >= numFiles)
	{
		// all entires received, mark as complete
		m_result	= reply.result;
		m_state		= kTransStateComplete;
	}
	return true;
}

/*****************************************************************************
*
*   FileDownloadRequestTrans
*
***/

//============================================================================
DownloadRequestTrans::DownloadRequestTrans (
	FNetCliFileDownloadRequestCallback	callback,
	void *								param,
	const wchar							filename[],
	hsStream *							writer,
	unsigned							buildId
) : NetFileTrans(kDownloadRequestTrans)
,	m_callback(callback)
,	m_param(param)
,	m_writer(writer)
,	m_totalBytesReceived(0)
,	m_buildId(buildId)
{
	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 DownloadRequestTrans::Send () {
	if (!AcquireConn())
		return false;

	Cli2File_FileDownloadRequest filedownloadReq;
	StrCopy(filedownloadReq.filename, m_filename, arrsize(m_filename));
	filedownloadReq.messageId = kCli2File_FileDownloadRequest;
	filedownloadReq.transId = m_transId;
	filedownloadReq.messageBytes = sizeof(filedownloadReq);
	filedownloadReq.buildId = m_buildId;

	m_conn->Send(&filedownloadReq, sizeof(filedownloadReq));
	
	return true;
}

//============================================================================
void DownloadRequestTrans::Post () {
	m_callback(m_result, m_param, m_filename, m_writer);
}

//============================================================================
bool DownloadRequestTrans::Recv (
	const byte	msg[],
	unsigned	bytes
) {
	m_timeoutAtMs = TimeGetMs() + NetTransGetTimeoutMs(); // Reset the timeout counter

	const File2Cli_FileDownloadReply & reply = *(const File2Cli_FileDownloadReply *) msg;

	dword byteCount = reply.byteCount;
	const byte* data = reply.fileData;

	// tell the server we got the data
	Cli2File_FileDownloadChunkAck fileAck;
	fileAck.messageId = kCli2File_FileDownloadChunkAck;
	fileAck.transId = reply.transId;
	fileAck.messageBytes = sizeof(fileAck);
	fileAck.readerId = reply.readerId;

	m_conn->Send(&fileAck, fileAck.messageBytes);

	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 (byteCount > 0) {
		RcvdFileDownloadChunkTrans * writeTrans = NEW(RcvdFileDownloadChunkTrans);
		writeTrans->writer	= m_writer;
		writeTrans->bytes	= byteCount;
		writeTrans->data	= (byte *)ALLOC(byteCount);
		MemCopy(writeTrans->data, data, byteCount);
		NetTransSend(writeTrans);
	}
	m_totalBytesReceived += byteCount;

	if (m_totalBytesReceived >= reply.totalFileSize) {
		// all bytes received, mark as complete
		m_result	= reply.result;
		m_state		= kTransStateComplete;
	}
	return true;
}

/*****************************************************************************
*
*   RcvdFileDownloadChunkTrans
*
***/

//============================================================================
RcvdFileDownloadChunkTrans::~RcvdFileDownloadChunkTrans () {
	FREE(data);
}

//============================================================================
void RcvdFileDownloadChunkTrans::Post () {
	writer->Write(bytes, data);
	m_result = kNetSuccess;
	m_state	 = kTransStateComplete;
}


} using namespace File;


/*****************************************************************************
*
*   NetFileTrans
*
***/

//============================================================================
NetFileTrans::NetFileTrans (ETransType transType)
:   NetTrans(kNetProtocolCli2File, transType)
,   m_conn(nil)
{
}

//============================================================================
NetFileTrans::~NetFileTrans () {
	ReleaseConn();
}

//============================================================================
bool NetFileTrans::AcquireConn () {
	if (!m_conn)
		m_conn = GetConnIncRef("AcquireConn");
	return m_conn != nil;
}

//============================================================================
void NetFileTrans::ReleaseConn () {
	if (m_conn) {
		m_conn->DecRef("AcquireConn");
		m_conn = nil;
	}
}


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

//============================================================================
void FileInitialize () {
	s_running = true;
}

//============================================================================
void FileDestroy (bool wait) {
	s_running = false;

	NetTransCancelByProtocol(
		kNetProtocolCli2File,
		kNetErrRemoteShutdown
	);    
    NetMsgProtocolDestroy(
        kNetProtocolCli2File,
        false
    );

    s_critsect.Enter();
    {
		while (CliFileConn * conn = s_conns.Head())
			UnlinkAndAbandonConn_CS(conn);
		s_active = nil;
	}
    s_critsect.Leave();

	if (!wait)
		return;

	while (s_perf[kPerfConnCount]) {
		NetTransUpdate();
        AsyncSleep(10);
	}
}

//============================================================================
bool FileQueryConnected () {
	bool result;
	s_critsect.Enter();
	result = s_active != nil;
	s_critsect.Leave();
	return result;
}

//============================================================================
unsigned FileGetConnId () {
	unsigned connId;
	s_critsect.Enter();
	connId = (s_active) ? s_active->seq : 0;
	s_critsect.Leave();
	return connId;
}

} using namespace Ngl;

/*****************************************************************************
*
*   Exported functions
*
***/

//============================================================================
void NetCliFileStartConnect (
	const wchar *	fileAddrList[],
	unsigned		fileAddrCount,
	bool			isPatcher /* = false */
) {
	// TEMP: Only connect to one file server until we fill out this module
	// to choose the "best" file connection.
	fileAddrCount = min(fileAddrCount, 1);
	s_connectBuildId = isPatcher ? kFileSrvBuildId : BuildId();
	s_serverType = kSrvTypeNone;

	for (unsigned i = 0; i < fileAddrCount; ++i) {
		// Do we need to lookup the address?
		const wchar * name = fileAddrList[i];
		while (unsigned ch = *name) {
			++name;
			if (!(isdigit(ch) || ch == L'.' || ch == L':')) {
				AsyncCancelId cancelId;
				AsyncAddressLookupName(
					&cancelId,
					AsyncLookupCallback,
					fileAddrList[i],
					kNetDefaultClientPort,
					nil
				);
				break;
			}
		}
		if (!name[0]) {
			NetAddress addr;
			NetAddressFromString(&addr, fileAddrList[i], kNetDefaultClientPort);
			Connect(fileAddrList[i], addr);
		}
	}
}

//============================================================================
void NetCliFileStartConnectAsServer (
	const wchar *	fileAddrList[],
	unsigned		fileAddrCount,
	unsigned		serverType,
	unsigned		serverBuildId
) {
	// TEMP: Only connect to one file server until we fill out this module
	// to choose the "best" file connection.
	fileAddrCount = min(fileAddrCount, 1);
	s_connectBuildId = serverBuildId;
	s_serverType = serverType;

	for (unsigned i = 0; i < fileAddrCount; ++i) {
		// Do we need to lookup the address?
		const wchar * name = fileAddrList[i];
		while (unsigned ch = *name) {
			++name;
			if (!(isdigit(ch) || ch == L'.' || ch == L':')) {
				AsyncCancelId cancelId;
				AsyncAddressLookupName(
					&cancelId,
					AsyncLookupCallback,
					fileAddrList[i],
					kNetDefaultClientPort,
					nil
				);
				break;
			}
		}
		if (!name[0]) {
			NetAddress addr;
			NetAddressFromString(&addr, fileAddrList[i], kNetDefaultServerPort);
			Connect(fileAddrList[i], addr);
		}
	}
}

//============================================================================
void NetCliFileDisconnect () {
    s_critsect.Enter();
    {
		while (CliFileConn * conn = s_conns.Head())
			UnlinkAndAbandonConn_CS(conn);
		s_active = nil;
    }
    s_critsect.Leave();
}

//============================================================================
void NetCliFileBuildIdRequest (
	FNetCliFileBuildIdRequestCallback	callback,
	void *								param
) {
	BuildIdRequestTrans * trans = NEW(BuildIdRequestTrans)(
		callback,
		param
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliFileRegisterBuildIdUpdate (FNetCliFileBuildIdUpdateCallback callback) {
	s_buildIdCallback = callback;
}

//============================================================================
void NetCliFileManifestRequest (
	FNetCliFileManifestRequestCallback	callback,
	void *								param,
	const wchar							group[],
	unsigned							buildId /* = 0 */
) {
	ManifestRequestTrans * trans = NEW(ManifestRequestTrans)(
		callback,
		param,
		group,
		buildId
	);
	NetTransSend(trans);
}

//============================================================================
void NetCliFileDownloadRequest (
	const wchar							filename[],
	hsStream *							writer,
	FNetCliFileDownloadRequestCallback	callback,
	void *								param,
	unsigned							buildId /* = 0 */
) {
	DownloadRequestTrans * trans = NEW(DownloadRequestTrans)(
		callback,
		param,
		filename,
		writer,
		buildId
	);
	NetTransSend(trans);
}