Skip to content

Zero Hour rebuilt from EA's source: x64, Direct3D 11, VS2022/CMake, ~60 original bugs fixed, an AI that builds a base. Bring your own game.

51.8 KB
Raw Blame
/*
 * test_online: the online service's connection (GameNetwork/Online/OnlineConnection).
 *
 * The JSON line reader and writer through round trips and every way a line can be wrong, the line cutter
 * fed a byte at a time and past its limit, then a real TLS connection over loopback to a server running
 * in this process.  The server's certificate is signed by a CA the test makes on the spot, so nothing
 * secret is committed and nothing expires: the client has to accept it against that CA and refuse it
 * against another.
 *
 * Last the adapters (OnlinePeer, OnlineBuddy, OnlineStats): the GameSpy queue interfaces fed the
 * server's lines as online/server.js writes them, checked for the responses EA's WOL screens read and
 * for the lines the screens' requests send.
 */

#include "test_harness.h"

#include "Lib/BaseType.h"
#include "Common/AsciiString.h"
#include "Common/GameMemory.h"
#include "Lib/WideCharFns.h"
#include <map>
#include "GameNetwork/Online/OnlineConnection.h"
#include "GameNetwork/Online/OnlineSession.h"
#include "GameNetwork/GameInfo.h"

#include <chrono>
#include <string>
#include <thread>
#include <vector>

#ifdef _WIN32
	#ifndef WIN32_LEAN_AND_MEAN
		#define WIN32_LEAN_AND_MEAN
	#endif
	#include <winsock2.h>
	typedef int TestSockLen;
#else
	#include <arpa/inet.h>
	#include <netinet/in.h>
	#include <sys/socket.h>
	typedef socklen_t TestSockLen;
#endif

#include "mbedtls/ctr_drbg.h"
#include "mbedtls/entropy.h"
#include "mbedtls/net_sockets.h"
#include "mbedtls/pk.h"
#include "mbedtls/ssl.h"
#include "mbedtls/x509_crt.h"

//-------------------------------------------------------------------------------------------------
// the JSON line
//-------------------------------------------------------------------------------------------------

static bool parseText( const std::string &line, OnlineMessage &out )
{
	return OnlineMessage::parse( line.data(), line.size(), out );
}

TEST(online_json_round_trip)
{
	const std::string awkward = std::string( "quote \" backslash \\ slash / newline \n tab \t bell \x01 del \x7f" " end" );
	const std::string turkish = "\xC3\x87" "a\xC4\x9F" "r\xC4\xB1 \xE2\x9C\x93 \xF0\x9F\x98\x80";		// a Turkish name, a check mark and an emoji
	std::vector<std::string> maps;
	maps.push_back( "Tournament Desert" );
	maps.push_back( turkish );
	maps.push_back( "" );
	std::vector<long long> ids;
	ids.push_back( -1 );
	ids.push_back( 0 );
	ids.push_back( 9007199254740993LL );		// 2^53 + 1: lost if numbers went through a double

	OnlineMessage m;
	m.setString( "t", "qm.join" ).setString( "text", awkward ).setString( "nick", turkish )
		.setInt( "exe", 0x89ABCDEFLL ).setInt( "big", 9007199254740993LL ).setInt( "neg", -42 )
		.setNumber( "half", 0.5 ).setNumber( "nan", NAN ).setBool( "yes", true ).setBool( "no", false )
		.setNull( "nothing" ).setStrings( "maps", maps ).setInts( "ids", ids ).setStrings( "none", std::vector<std::string>() );
	m.setInt( "neg", -43 );		// replaces in place

	std::string line;
	CHECK( m.toLine( line ) );
	CHECK( !line.empty() && line[ line.size() - 1 ] == '\n' );
	CHECK_EQ( line.find( '\n' ), line.size() - 1 );		// one line: the newline in the text went out escaped
	CHECK_EQ( line.find( "\"t\":\"qm.join\"" ), (size_t)1 );		// keys keep their first order

	OnlineMessage back;
	CHECK( OnlineMessage::parse( line.data(), line.size() - 1, back ) );
	CHECK_EQ( back.size(), m.size() );
	CHECK( back.type() == "qm.join" );
	CHECK( back.getString( "text" ) == awkward );
	CHECK( back.getString( "nick" ) == turkish );
	CHECK_EQ( back.getInt( "exe" ), 0x89ABCDEFLL );
	CHECK_EQ( back.getInt( "big" ), 9007199254740993LL );
	CHECK_EQ( back.getInt( "neg" ), -43 );
	CHECK_EQ( back.getNumber( "half" ), 0.5 );
	CHECK( back.has( "nan" ) && back.find( "nan" )->kind == OnlineValue::NUL );
	CHECK( back.getBool( "yes" ) );
	CHECK( !back.getBool( "no", true ) );
	CHECK( back.find( "nothing" )->kind == OnlineValue::NUL );
	CHECK( back.getStrings( "maps" ) == maps );
	CHECK( back.getInts( "ids" ) == ids );
	CHECK( back.find( "none" )->kind == OnlineValue::ARRAY && back.find( "none" )->items.empty() );

	// missing keys and wrong kinds give the default
	CHECK( back.getString( "missing", "x" ) == "x" );
	CHECK_EQ( back.getInt( "nick", 7 ), 7 );
	CHECK( back.getString( "exe" ).empty() );

	OnlineMessage empty;
	CHECK( empty.toLine( line ) );
	CHECK( line == "{}\n" );
}

TEST(online_json_reads_escapes_and_spacing)
{
	OnlineMessage m;
	CHECK( parseText( " { \"t\" : \"say\" ,\t\"text\":\"a\\\"b\\\\c\\/d\\b\\f\\n\\r\\t\\u00e7\\u00C7\\u2713\\ud83d\\ude00\" , \"n\" : -1.5e+2 , \"z\":0 , \"e\":1E3 , \"a\" : [ 1 , \"x\" , true , null ] }\r", m ) );
	CHECK( m.getString( "text" ) == "a\"b\\c/d\b\f\n\r\t\xC3\xA7\xC3\x87\xE2\x9C\x93\xF0\x9F\x98\x80" );
	CHECK_EQ( m.getNumber( "n" ), -150.0 );
	CHECK_EQ( m.getInt( "n" ), -150 );
	CHECK_EQ( m.getInt( "z" ), 0 );
	CHECK_EQ( m.getInt( "e" ), 1000 );
	const OnlineValue *a = m.find( "a" );
	CHECK( a && a->kind == OnlineValue::ARRAY && a->items.size() == 4 );
	CHECK( parseText( "{}", m ) && m.size() == 0 );
	CHECK( parseText( "{\"a\":[]}", m ) && m.find( "a" )->items.empty() );
	CHECK( parseText( "{\"\":\"empty key\"}", m ) && m.getString( "" ) == "empty key" );
	// raw UTF-8 passes through untouched
	CHECK( parseText( "{\"t\":\"\xC3\x87\xF0\x9F\x98\x80\"}", m ) && m.type() == "\xC3\x87\xF0\x9F\x98\x80" );
}

TEST(online_json_refuses_what_is_not_a_flat_object)
{
	const char *bad[] = {
		"",
		"   ",
		"[]",
		"\"t\"",
		"{",
		"{\"t\"}",
		"{\"t\":}",
		"{\"t\":\"x\",}",
		"{\"t\":\"x\"} trailing",
		"{\"t\":\"x\"}{}",
		"{\"t\":{\"nested\":1}}",
		"{\"t\":[1,[2]]}",
		"{\"t\":[1,{}]}",
		"{\"t\":[1,]}",
		"{\"t\":[1 2]}",
		"{\"t\":\"a\",\"t\":\"b\"}",		// duplicate key
		"{\"t\":\"unterminated}",
		"{\"t\":\"\\x\"}",							// unknown escape
		"{\"t\":\"\\u12\"}",						// short \u
		"{\"t\":\"\\u12g4\"}",
		"{\"t\":\"\\ud83d\"}",					// high surrogate alone
		"{\"t\":\"\\ud83d\\u0041\"}",		// high surrogate, then not a low one
		"{\"t\":\"\\ude00\"}",					// low surrogate alone
		"{\"t\":\"\\u0000\"}",					// NUL
		"{\"t\":\"a\tb\"}",							// raw control character
		"{\"t\":01}",
		"{\"t\":1.}",
		"{\"t\":.5}",
		"{\"t\":-}",
		"{\"t\":1e}",
		"{\"t\":+1}",
		"{\"t\":tru}",
		"{\"t\":True}",
		"{\"t\":NaN}",
		"{t:1}",
		"{'t':1}",
		"{\"t\":\"\xC0\x80\"}",					// overlong NUL
		"{\"t\":\"\xE0\x80\xAF\"}",			// overlong '/'
		"{\"t\":\"\xED\xA0\x80\"}",			// a surrogate written as UTF-8
		"{\"t\":\"\xF4\x90\x80\x80\"}",	// past U+10FFFF
		"{\"t\":\"\xC3\"}",							// cut short
		"{\"t\":\"\xFF\"}",
	};
	for (size_t i = 0; i < sizeof( bad ) / sizeof( bad[ 0 ] ); ++i)
	{
		OnlineMessage m;
		m.setString( "stale", "x" );
		const bool parsed = parseText( bad[ i ], m );
		if (parsed)
			printf( "  accepted: %s\n", bad[ i ] );
		CHECK( !parsed );
		CHECK_EQ( m.size(), (size_t)0 );		// cleared, never half filled
	}
	// a NUL byte in the middle of the line
	const std::string withNul( "{\"t\":\"a\0b\"}", 11 );
	OnlineMessage m;
	CHECK( !parseText( withNul, m ) );
}

TEST(online_json_line_limit)
{
	// {"t":"..."} is 8 bytes around the text
	OnlineMessage m;
	m.setString( "t", std::string( ONLINE_MAX_LINE - 8, 'x' ) );
	std::string line;
	CHECK( m.toLine( line ) );
	CHECK_EQ( line.size(), (size_t)ONLINE_MAX_LINE + 1 );
	OnlineMessage back;
	CHECK( OnlineMessage::parse( line.data(), line.size() - 1, back ) );

	m.setString( "t", std::string( ONLINE_MAX_LINE - 7, 'x' ) );
	CHECK( !m.toLine( line ) );
	CHECK( line.empty() );
	const std::string over = "{\"t\":\"" + std::string( ONLINE_MAX_LINE - 7, 'x' ) + "\"}";
	CHECK( !parseText( over, back ) );

	// escapes count at their written length
	m.setString( "t", std::string( ONLINE_MAX_LINE / 2, '"' ) );
	CHECK( !m.toLine( line ) );
}

TEST(online_json_writer_refuses_bad_text)
{
	OnlineMessage m;
	std::string line;
	CHECK( !m.setString( "t", "\xC3" ).toLine( line ) );
	CHECK( !m.setString( "t", "\xED\xA0\x80" ).toLine( line ) );
	CHECK( !m.setString( "t", std::string( "a\0b", 3 ) ).toLine( line ) );
	m.clear();
	CHECK( !m.setString( "\xFF", "x" ).toLine( line ) );
	m.clear();
	std::vector<std::string> list;
	list.push_back( "ok" );
	list.push_back( "\xC0\x80" );
	CHECK( !m.setStrings( "t", list ).toLine( line ) );
	m.clear();
	OnlineValue nested;
	nested.kind = OnlineValue::ARRAY;
	nested.items.push_back( OnlineValue() );
	nested.items[ 0 ].kind = OnlineValue::ARRAY;
	CHECK( !m.set( "t", nested ).toLine( line ) );
	m.clear();
	OnlineValue number;
	number.kind = OnlineValue::NUMBER;
	number.text = "1e";
	CHECK( !m.set( "t", number ).toLine( line ) );
}

TEST(online_utf8_validator)
{
	CHECK( OnlineIsUtf8( "", 0 ) );
	CHECK( OnlineIsUtf8( "plain", 5 ) );
	CHECK( OnlineIsUtf8( "\xC2\x80", 2 ) );						// U+0080, the first two-byte one
	CHECK( OnlineIsUtf8( "\xEF\xBF\xBF", 3 ) );					// U+FFFF
	CHECK( OnlineIsUtf8( "\xF4\x8F\xBF\xBF", 4 ) );			// U+10FFFF
	CHECK( !OnlineIsUtf8( "\xC1\xBF", 2 ) );
	CHECK( !OnlineIsUtf8( "\xF0\x8F\xBF\xBF", 4 ) );		// overlong
	CHECK( !OnlineIsUtf8( "\x80", 1 ) );
	CHECK( !OnlineIsUtf8( "\xE2\x9C", 2 ) );
	CHECK( !OnlineIsUtf8( "\xE2\x28\x93", 3 ) );
	CHECK( !OnlineIsUtf8( "\xF8\x88\x80\x80\x80", 5 ) );
}

//-------------------------------------------------------------------------------------------------
// the line cutter
//-------------------------------------------------------------------------------------------------

TEST(online_lines_arrive_in_pieces)
{
	const std::string stream = "{\"t\":\"a\"}\r\n\n\r\n{\"t\":\"b\",\"text\":\"\xC3\x87\"}\n{\"t\":\"c\"}";
	OnlineLineReader reader;
	std::vector<std::string> lines;
	std::string line;
	for (size_t i = 0; i < stream.size(); ++i)
	{
		reader.feed( &stream[ i ], 1 );
		OnlineLineReader::Result r;
		while ((r = reader.next( line )) != OnlineLineReader::NONE)
		{
			CHECK_EQ( r, OnlineLineReader::LINE );
			lines.push_back( line );
		}
	}
	CHECK_EQ( lines.size(), (size_t)2 );		// the third has no newline yet
	CHECK( lines.size() == 2 && lines[ 0 ] == "{\"t\":\"a\"}" && lines[ 1 ] == "{\"t\":\"b\",\"text\":\"\xC3\x87\"}" );
	reader.feed( "\n", 1 );
	CHECK_EQ( reader.next( line ), OnlineLineReader::LINE );
	CHECK( line == "{\"t\":\"c\"}" );
	CHECK_EQ( reader.next( line ), OnlineLineReader::NONE );
}

TEST(online_lines_over_the_limit_are_dropped_once)
{
	OnlineLineReader reader;
	std::string line;

	// exactly the limit, with a CRLF, is a line
	std::string full( ONLINE_MAX_LINE, 'a' );
	full += "\r\n";
	reader.feed( full.data(), full.size() );
	CHECK_EQ( reader.next( line ), OnlineLineReader::LINE );
	CHECK_EQ( line.size(), (size_t)ONLINE_MAX_LINE );

	// one over, complete in one feed, followed by a good line
	std::string over( ONLINE_MAX_LINE + 1, 'b' );
	over += "\n{\"t\":\"ok\"}\n";
	reader.feed( over.data(), over.size() );
	CHECK_EQ( reader.next( line ), OnlineLineReader::OVERSIZE );
	CHECK_EQ( reader.next( line ), OnlineLineReader::LINE );
	CHECK( line == "{\"t\":\"ok\"}" );
	CHECK_EQ( reader.next( line ), OnlineLineReader::NONE );

	// a long one arriving in chunks is reported once and thrown away up to its newline, even when the
	// newline and the next line come together
	const std::string chunk( 1000, 'c' );
	int oversize = 0, lines = 0;
	for (int i = 0; i < 30; ++i)
	{
		reader.feed( chunk.data(), chunk.size() );
		OnlineLineReader::Result r;
		while ((r = reader.next( line )) != OnlineLineReader::NONE)
			(r == OnlineLineReader::OVERSIZE ? oversize : lines)++;
	}
	reader.feed( "ccc\n{\"t\":\"after\"}\n", 18 );
	OnlineLineReader::Result r;
	while ((r = reader.next( line )) != OnlineLineReader::NONE)
		(r == OnlineLineReader::OVERSIZE ? oversize : lines)++;
	CHECK_EQ( oversize, 1 );
	CHECK_EQ( lines, 1 );
	CHECK( line == "{\"t\":\"after\"}" );
}

//-------------------------------------------------------------------------------------------------
// TLS over loopback
//-------------------------------------------------------------------------------------------------

static const char *TEST_CA_NAME = "CN=Zero Hour Reforged test CA (test only),O=test_online";

struct TestPki
{
	bool ok;
	mbedtls_entropy_context entropy;
	mbedtls_ctr_drbg_context random;
	mbedtls_pk_context caKey, otherCaKey, serverKey;
	std::string caPem, otherCaPem, serverPem;
};

static bool makeKey( mbedtls_pk_context &key, mbedtls_ctr_drbg_context &random )
{
	return mbedtls_pk_setup( &key, mbedtls_pk_info_from_type( MBEDTLS_PK_ECKEY ) ) == 0
		&& mbedtls_ecp_gen_key( MBEDTLS_ECP_DP_SECP256R1, mbedtls_pk_ec( key ), mbedtls_ctr_drbg_random, &random ) == 0;
}

static std::string makeCertificate( mbedtls_pk_context &subjectKey, const char *subject, mbedtls_pk_context &issuerKey,
																		const char *issuer, unsigned char serial, bool authority, mbedtls_ctr_drbg_context &random )
{
	mbedtls_x509write_cert crt;
	mbedtls_x509write_crt_init( &crt );
	unsigned char pem[ 4096 ];
	mbedtls_x509write_crt_set_version( &crt, MBEDTLS_X509_CRT_VERSION_3 );
	mbedtls_x509write_crt_set_md_alg( &crt, MBEDTLS_MD_SHA256 );
	mbedtls_x509write_crt_set_subject_key( &crt, &subjectKey );
	mbedtls_x509write_crt_set_issuer_key( &crt, &issuerKey );
	const bool ok = mbedtls_x509write_crt_set_serial_raw( &crt, &serial, 1 ) == 0
		&& mbedtls_x509write_crt_set_validity( &crt, "20250101000000", "20991231235959" ) == 0
		&& mbedtls_x509write_crt_set_subject_name( &crt, subject ) == 0
		&& mbedtls_x509write_crt_set_issuer_name( &crt, issuer ) == 0
		&& mbedtls_x509write_crt_set_basic_constraints( &crt, authority ? 1 : 0, -1 ) == 0
		&& mbedtls_x509write_crt_set_key_usage( &crt, authority
				? (MBEDTLS_X509_KU_KEY_CERT_SIGN | MBEDTLS_X509_KU_CRL_SIGN) : MBEDTLS_X509_KU_DIGITAL_SIGNATURE ) == 0
		&& mbedtls_x509write_crt_pem( &crt, pem, sizeof( pem ), mbedtls_ctr_drbg_random, &random ) == 0;
	mbedtls_x509write_crt_free( &crt );
	return ok ? std::string( (const char *)pem ) : std::string();
}

// made once and kept for the run; nothing of it is written anywhere
static TestPki &pki()
{
	static TestPki p;
	static bool made = false;
	if (made)
		return p;
	made = true;
	mbedtls_entropy_init( &p.entropy );
	mbedtls_ctr_drbg_init( &p.random );
	mbedtls_pk_init( &p.caKey );
	mbedtls_pk_init( &p.otherCaKey );
	mbedtls_pk_init( &p.serverKey );
	p.ok = mbedtls_ctr_drbg_seed( &p.random, mbedtls_entropy_func, &p.entropy, NULL, 0 ) == 0
		&& makeKey( p.caKey, p.random ) && makeKey( p.otherCaKey, p.random ) && makeKey( p.serverKey, p.random );
	if (p.ok)
	{
		// the other CA has the same name and only another key: refused on the signature alone
		p.caPem = makeCertificate( p.caKey, TEST_CA_NAME, p.caKey, TEST_CA_NAME, 1, true, p.random );
		p.otherCaPem = makeCertificate( p.otherCaKey, TEST_CA_NAME, p.otherCaKey, TEST_CA_NAME, 1, true, p.random );
		p.serverPem = makeCertificate( p.serverKey, "CN=127.0.0.1", p.caKey, TEST_CA_NAME, 2, false, p.random );
		p.ok = !p.caPem.empty() && !p.otherCaPem.empty() && !p.serverPem.empty();
	}
	return p;
}

/* One connection: accept, handshake, read the client's first line, answer with a scripted stream (two
	 lines in one write, a long line in two writes with a pause, a nested line and an oversize one the
	 client must drop, then "bye"), and wait for the client to hang up. */
struct TestServer
{
	mbedtls_net_context listener;
	mbedtls_x509_crt chain;
	unsigned short port;
	int handshake;
	std::string received;
	std::thread thread;

	TestServer() : port( 0 ), handshake( 1 ) { mbedtls_net_init( &listener ); mbedtls_x509_crt_init( &chain ); }
	~TestServer()
	{
		if (thread.joinable())
			thread.join();
		mbedtls_net_free( &listener );
		mbedtls_x509_crt_free( &chain );
	}

	bool start()
	{
		const std::string &pem = pki().serverPem;
		if (mbedtls_x509_crt_parse( &chain, (const unsigned char *)pem.c_str(), pem.size() + 1 ) != 0
			|| mbedtls_net_bind( &listener, "127.0.0.1", "0", MBEDTLS_NET_PROTO_TCP ) != 0)
			return false;
		sockaddr_in address;
		TestSockLen size = sizeof( address );
		if (getsockname( listener.fd, (sockaddr *)&address, &size ) != 0)
			return false;
		port = ntohs( address.sin_port );
		thread = std::thread( &TestServer::serve, this );
		return true;
	}

	static bool writeAll( mbedtls_ssl_context &ssl, const std::string &bytes )
	{
		size_t done = 0;
		while (done < bytes.size())
		{
			const int n = mbedtls_ssl_write( &ssl, (const unsigned char *)bytes.data() + done, bytes.size() - done );
			if (n > 0)
				done += n;
			else if (n != MBEDTLS_ERR_SSL_WANT_WRITE && n != MBEDTLS_ERR_SSL_WANT_READ)
				return false;
		}
		return true;
	}

	void serve()
	{
		mbedtls_net_context client;
		mbedtls_ssl_context ssl;
		mbedtls_ssl_config conf;
		mbedtls_entropy_context entropy;
		mbedtls_ctr_drbg_context random;
		mbedtls_net_init( &client );
		mbedtls_ssl_init( &ssl );
		mbedtls_ssl_config_init( &conf );
		mbedtls_entropy_init( &entropy );
		mbedtls_ctr_drbg_init( &random );
		if (mbedtls_ctr_drbg_seed( &random, mbedtls_entropy_func, &entropy, NULL, 0 ) == 0
			&& mbedtls_net_accept( &listener, &client, NULL, 0, NULL ) == 0
			&& mbedtls_ssl_config_defaults( &conf, MBEDTLS_SSL_IS_SERVER, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT ) == 0)
		{
			mbedtls_ssl_conf_rng( &conf, mbedtls_ctr_drbg_random, &random );
			mbedtls_ssl_conf_max_tls_version( &conf, MBEDTLS_SSL_VERSION_TLS1_2 );		// as the client; OnlineConnection.cpp says why
			mbedtls_ssl_conf_read_timeout( &conf, 5000 );
			if (mbedtls_ssl_conf_own_cert( &conf, &chain, &pki().serverKey ) == 0 && mbedtls_ssl_setup( &ssl, &conf ) == 0)
			{
				mbedtls_ssl_set_bio( &ssl, &client, mbedtls_net_send, NULL, mbedtls_net_recv_timeout );
				while ((handshake = mbedtls_ssl_handshake( &ssl )) == MBEDTLS_ERR_SSL_WANT_READ || handshake == MBEDTLS_ERR_SSL_WANT_WRITE)
					;
			}
		}
		if (handshake == 0)
		{
			unsigned char bytes[ 1024 ];
			while (received.find( '\n' ) == std::string::npos)
			{
				const int n = mbedtls_ssl_read( &ssl, bytes, sizeof( bytes ) );
				if (n <= 0)
					break;
				received.append( (const char *)bytes, n );
			}
			const std::string big = "{\"t\":\"said\",\"text\":\"" + std::string( 8000, 'x' ) + "\"}\n";
			writeAll( ssl, "{\"t\":\"welcome\",\"motd\":\"h\\u00e9llo\",\"relayPort\":7001}\n"
										 "{\"t\":\"auth.ok\",\"id\":9007199254740993,\"nick\":\"\xC3\x87" "a\xC4\x9F" "r\xC4\xB1\"}\n" );
			writeAll( ssl, big.substr( 0, 3000 ) );
			std::this_thread::sleep_for( std::chrono::milliseconds( 60 ) );
			writeAll( ssl, big.substr( 3000 ) );
			writeAll( ssl, "{\"t\":[1,[2]]}\n" + std::string( 9000, 'y' ) + "\n{\"t\":\"bye\"}\n" );
			while (mbedtls_ssl_read( &ssl, bytes, sizeof( bytes ) ) > 0)
				;		// until the client's close_notify, or five quiet seconds
		}
		mbedtls_ssl_close_notify( &ssl );
		mbedtls_net_free( &client );
		mbedtls_ssl_free( &ssl );
		mbedtls_ssl_config_free( &conf );
		mbedtls_ctr_drbg_free( &random );
		mbedtls_entropy_free( &entropy );
	}
};

// the messages that arrive until "bye" or the connection ends, ten seconds at most
static std::vector<OnlineMessage> collect( OnlineConnection &c )
{
	std::vector<OnlineMessage> got;
	const auto give_up = std::chrono::steady_clock::now() + std::chrono::seconds( 10 );
	while (std::chrono::steady_clock::now() < give_up)
	{
		OnlineMessage m;
		while (c.receive( m ))
			got.push_back( m );
		if ((!got.empty() && got.back().type() == "bye") || c.state() == OnlineConnection::CLOSED)
			break;
		std::this_thread::sleep_for( std::chrono::milliseconds( 5 ) );
	}
	return got;
}

TEST(online_tls_loopback_against_the_test_ca)
{
	CHECK( pki().ok );
	TestServer server;
	CHECK( server.start() );
	if (!pki().ok || server.port == 0)
		return;

	OnlineConnection c;
	CHECK_EQ( c.state(), OnlineConnection::IDLE );
	CHECK( c.connect( "127.0.0.1", server.port, pki().caPem ) );
	CHECK( !c.connect( "127.0.0.1", server.port, pki().caPem ) );		// one at a time
	OnlineMessage hello;
	hello.setString( "t", "hello" ).setInt( "exe", 0x12345678 ).setInt( "ini", 0x9ABCDEF0LL ).setString( "ver", "test" );
	CHECK( c.send( hello ) );		// queued before the handshake is through, sent once it is

	const std::vector<OnlineMessage> got = collect( c );
	CHECK_EQ( got.size(), (size_t)4 );
	if (got.size() == 4)
	{
		CHECK( got[ 0 ].type() == "welcome" );
		CHECK( got[ 0 ].getString( "motd" ) == "h\xC3\xA9llo" );
		CHECK_EQ( got[ 0 ].getInt( "relayPort" ), 7001 );
		CHECK( got[ 1 ].type() == "auth.ok" );
		CHECK_EQ( got[ 1 ].getInt( "id" ), 9007199254740993LL );
		CHECK( got[ 1 ].getString( "nick" ) == "\xC3\x87" "a\xC4\x9F" "r\xC4\xB1" );
		CHECK( got[ 2 ].type() == "said" );
		CHECK_EQ( got[ 2 ].getString( "text" ).size(), (size_t)8000 );
		CHECK( got[ 3 ].type() == "bye" );
	}
	CHECK_EQ( c.droppedLines(), 2u );		// the nested one and the oversize one
	CHECK_EQ( c.state(), OnlineConnection::OPEN );
	if (!c.error().empty())
		printf( "  error: %s\n", c.error().c_str() );
	CHECK( c.error().empty() );

	c.close();
	CHECK_EQ( c.state(), OnlineConnection::CLOSED );
	CHECK( c.error().empty() );		// a hang-up asked for is not an error
	CHECK( !c.send( hello ) );
	if (server.thread.joinable())
		server.thread.join();
	CHECK_EQ( server.handshake, 0 );
	OnlineMessage first;
	CHECK( !server.received.empty() && parseText( server.received.substr( 0, server.received.size() - 1 ), first ) );
	CHECK( first.type() == "hello" );
	CHECK_EQ( first.getInt( "ini" ), 0x9ABCDEF0LL );
}

TEST(online_tls_refuses_a_server_the_ca_did_not_sign)
{
	CHECK( pki().ok );
	TestServer server;
	CHECK( server.start() );
	if (!pki().ok || server.port == 0)
		return;

	OnlineConnection c;
	CHECK( c.connect( "127.0.0.1", server.port, pki().otherCaPem ) );
	OnlineMessage hello;
	hello.setString( "t", "hello" );
	c.send( hello );
	const std::vector<OnlineMessage> got = collect( c );
	CHECK( got.empty() );
	CHECK_EQ( c.state(), OnlineConnection::CLOSED );
	printf( "  refused with: %s\n", c.error().c_str() );
	CHECK( c.error().find( "certificate" ) != std::string::npos );
	if (server.thread.joinable())
		server.thread.join();
	CHECK( server.handshake != 0 );
	CHECK( server.received.empty() );		// the hello never left the client
}

TEST(online_tls_refuses_a_name_the_certificate_does_not_carry)
{
	CHECK( pki().ok );
	TestServer server;
	CHECK( server.start() );
	if (!pki().ok || server.port == 0)
		return;

	OnlineConnection c;
	CHECK( c.connect( "localhost", server.port, pki().caPem ) );		// signed for 127.0.0.1, not this name
	collect( c );
	CHECK_EQ( c.state(), OnlineConnection::CLOSED );
	CHECK( c.error().find( "certificate" ) != std::string::npos );
	if (server.thread.joinable())
		server.thread.join();
}

TEST(online_connect_refuses_bad_arguments)
{
	OnlineConnection c;
	CHECK( !c.connect( "", 7000, "" ) );
	CHECK( !c.error().empty() );
	CHECK( !c.connect( "127.0.0.1", 0, "" ) );
	CHECK( !c.connect( "127.0.0.1", 7000, "-----BEGIN CERTIFICATE-----\nnot base64\n-----END CERTIFICATE-----\n" ) );
	CHECK( c.error().find( "CA" ) != std::string::npos );
	CHECK( c.state() != OnlineConnection::CONNECTING && c.state() != OnlineConnection::OPEN );

	// the built-in Let's Encrypt roots parse
	mbedtls_x509_crt roots;
	mbedtls_x509_crt_init( &roots );
	const std::string pem = OnlineConnection::defaultRoots();
	CHECK_EQ( mbedtls_x509_crt_parse( &roots, (const unsigned char *)pem.c_str(), pem.size() + 1 ), 0 );
	int count = 0;
	for (const mbedtls_x509_crt *crt = &roots; crt != NULL && crt->raw.len > 0; crt = crt->next)
		++count;
	CHECK_EQ( count, 2 );
	mbedtls_x509_crt_free( &roots );
}

//-------------------------------------------------------------------------------------------------
// the adapters, fed scripted server lines
//-------------------------------------------------------------------------------------------------

/* The three queues over a session that sends into `sent` and dials nothing.  feed() is one server line. */
struct AdapterRig
{
	std::vector<OnlineMessage> sent;
	OnlinePeerQueue *peer;
	OnlineBuddyQueue *buddy;
	OnlinePSQueue *ps;

	AdapterRig()
	{
		static bool booted = false;
		if (!booted)
		{
			initMemoryManager();
			booted = true;
		}
		OnlineSession::get().beginTest( &sent );
		peer = new OnlinePeerQueue;
		buddy = new OnlineBuddyQueue;
		ps = new OnlinePSQueue;
	}
	~AdapterRig()
	{
		delete ps;
		delete buddy;
		delete peer;
		OnlineSession::get().beginTest( NULL );
	}

	void feed( const OnlineMessage &m ) { OnlineSession::get().dispatch( m ); }
	void feed( const char *json )
	{
		OnlineMessage m;
		CHECK( parseText( json, m ) );
		feed( m );
	}
	std::vector<PeerResponse> peerResponses()
	{
		std::vector<PeerResponse> out;
		PeerResponse r;
		while (peer->getResponse( r ))
			out.push_back( r );
		return out;
	}
	std::string sentType( size_t i ) const { return i < sent.size() ? sent[i].type() : std::string(); }

	/* Logged in as Tank, id 7, at 10.0.0.3, with the login's answers read and the sent lines cleared. */
	void login()
	{
		BuddyRequest req;
		memset( &req, 0, sizeof(req) );
		req.buddyRequestType = BuddyRequest::BUDDYREQUEST_LOGIN;
		strcpy( req.arg.login.email, "[email protected]" );
		strcpy( req.arg.login.password, "secret" );
		buddy->addRequest( req );
		feed( "{\"t\":\"auth.ok\",\"id\":7,\"nick\":\"Tank\",\"token\":\"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef\",\"ticket\":\"00112233445566778899aabbccddeeff\"}" );
		feed( "{\"t\":\"relay.ok\",\"vip\":167772163}" );
		peerResponses();
		BuddyResponse b;
		while (buddy->getResponse( b )) {}
		sent.clear();
	}
};

TEST(online_adapter_login_waits_for_the_relay)
{
	AdapterRig rig;
	BuddyRequest req;
	memset( &req, 0, sizeof(req) );
	req.buddyRequestType = BuddyRequest::BUDDYREQUEST_LOGIN;
	strcpy( req.arg.login.nick, "Tank" );
	strcpy( req.arg.login.email, "[email protected]" );
	strcpy( req.arg.login.password, "secret" );
	rig.buddy->addRequest( req );

	CHECK_EQ( rig.sent.size(), (size_t)1 );
	CHECK_STR( rig.sentType( 0 ).c_str(), "login" );
	CHECK_STR( rig.sent[0].getString( "email" ).c_str(), "[email protected]" );
	CHECK_STR( rig.sent[0].getString( "pass" ).c_str(), "secret" );
	CHECK( rig.peer->isConnecting() );
	CHECK( !rig.peer->isConnected() );

	rig.feed( "{\"t\":\"auth.ok\",\"id\":7,\"nick\":\"Tank\",\"token\":\"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef\",\"ticket\":\"00112233445566778899aabbccddeeff\"}" );
	BuddyResponse b;
	CHECK( rig.buddy->getResponse( b ) );
	CHECK_EQ( (int)b.buddyResponseType, (int)BuddyResponse::BUDDYRESPONSE_LOGIN );
	CHECK_EQ( b.profile, 7 );
	CHECK_EQ( rig.buddy->getLocalProfileID(), 7 );

	// the ticket is out for HELLO_AUTH, but the game's login waits for the relay's answer
	UnsignedByte ticket[16];
	CHECK( OnlineGetRelayTicket( ticket ) );
	CHECK_EQ( ticket[0], 0x00 );
	CHECK_EQ( ticket[1], 0x11 );
	CHECK_EQ( ticket[15], 0xff );
	CHECK_STR( OnlineGetSessionToken().str(), "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" );
	CHECK( rig.peerResponses().empty() );

	rig.feed( "{\"t\":\"relay.ok\",\"vip\":167772163}" );
	std::vector<PeerResponse> r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)3 );
	if (r.size() == 3)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_LOGIN );
		CHECK_STR( r[0].nick.c_str(), "Tank" );
		CHECK_EQ( r[0].player.profileID, 7 );
		CHECK_EQ( r[0].player.internalIP, 0x0A000003u );
		CHECK_EQ( r[0].player.externalIP, 0x0A000003u );
		CHECK_EQ( (int)r[1].peerResponseType, (int)PeerResponse::PEERRESPONSE_GROUPROOM );
		CHECK_EQ( r[1].groupRoom.id, 1 );
		CHECK_EQ( (int)r[2].peerResponseType, (int)PeerResponse::PEERRESPONSE_GROUPROOM );
		CHECK_EQ( r[2].groupRoom.id, 0 );		// the end of the list
	}
	CHECK( rig.peer->isConnected() );
	CHECK_EQ( OnlineGetRelayVip(), 0x0A000003u );
	CHECK_STR( rig.sentType( 1 ).c_str(), "stats.get" );		// our own stats, as GameSpy's login read them
}

TEST(online_adapter_login_refusal_and_no_register)
{
	AdapterRig rig;
	BuddyRequest req;
	memset( &req, 0, sizeof(req) );
	// accounts are made on the site: a new-account request sends nothing
	req.buddyRequestType = BuddyRequest::BUDDYREQUEST_LOGINNEW;
	strcpy( req.arg.login.nick, "Tank" );
	strcpy( req.arg.login.email, "[email protected]" );
	strcpy( req.arg.login.password, "secret" );
	rig.buddy->addRequest( req );
	CHECK_EQ( rig.sent.size(), (size_t)0 );

	req.buddyRequestType = BuddyRequest::BUDDYREQUEST_LOGIN;
	rig.buddy->addRequest( req );
	CHECK_EQ( rig.sent.size(), (size_t)1 );
	CHECK_STR( rig.sentType( 0 ).c_str(), "login" );
	CHECK_STR( rig.sent[0].getString( "email" ).c_str(), "[email protected]" );

	rig.feed( "{\"t\":\"auth.fail\",\"code\":\"badlogin\"}" );
	std::vector<PeerResponse> r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)1 );
	if (r.size() == 1)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_DISCONNECT );
		CHECK_EQ( (int)r[0].discon.reason, (int)DISCONNECT_GP_LOGIN_BAD_PASSWORD );
	}
	CHECK( !rig.peer->isConnecting() );
	UnsignedByte ticket[16];
	CHECK( !OnlineGetRelayTicket( ticket ) );

	// a resume with a saved token is the same login
	OnlineResume( "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" );
	CHECK_STR( rig.sentType( 1 ).c_str(), "resume" );
	CHECK_EQ( rig.sent[1].getString( "token" ).size(), (size_t)64 );
}

TEST(online_adapter_room_and_chat)
{
	AdapterRig rig;
	rig.login();

	PeerRequest join;
	join.peerRequestType = PeerRequest::PEERREQUEST_JOINGROUPROOM;
	join.groupRoom.id = 1;
	rig.peer->addRequest( join );
	CHECK_STR( rig.sentType( 0 ).c_str(), "room.join" );
	CHECK_STR( rig.sent[0].getString( "id" ).c_str(), "lobby1" );

	rig.feed( "{\"t\":\"room\",\"id\":\"lobby1\",\"ids\":[7,9],\"nicks\":[\"Tank\",\"Kim\"],\"vips\":[167772163,167772162]}" );
	std::vector<PeerResponse> r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)3 );
	if (r.size() == 3)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_JOINGROUPROOM );
		CHECK_EQ( r[0].joinGroupRoom.id, 1 );
		CHECK( r[0].joinGroupRoom.ok );
		CHECK_EQ( (int)r[2].peerResponseType, (int)PeerResponse::PEERRESPONSE_PLAYERJOIN );
		CHECK_STR( r[2].nick.c_str(), "Kim" );
		CHECK_EQ( r[2].player.profileID, 9 );
		CHECK_EQ( (int)r[2].player.roomType, (int)GroupRoom );
		CHECK_EQ( r[2].player.IP, OnlineHostToNet( 0x0A000002 ) );		// GameSpy's player IP, network order
	}

	PeerRequest say;
	say.peerRequestType = PeerRequest::PEERREQUEST_MESSAGEROOM;
	say.text = WideCharString( u"merhaba " ) + (WideChar)0x011F;		// g with breve: UTF-8 c4 9f
	say.message.isAction = FALSE;
	rig.peer->addRequest( say );
	CHECK_STR( rig.sentType( 1 ).c_str(), "say" );
	CHECK_STR( rig.sent[1].getString( "room" ).c_str(), "lobby1" );
	CHECK_STR( rig.sent[1].getString( "text" ).c_str(), "merhaba \xc4\x9f" );

	rig.feed( "{\"t\":\"said\",\"room\":\"lobby1\",\"from\":9,\"nick\":\"Kim\",\"text\":\"selam \xc4\x9f\",\"action\":0}" );
	rig.feed( "{\"t\":\"said\",\"room\":\"lobby2\",\"from\":9,\"nick\":\"Kim\",\"text\":\"elsewhere\",\"action\":0}" );
	rig.feed( "{\"t\":\"said\",\"to\":\"Tank\",\"from\":9,\"nick\":\"Kim\",\"text\":\"psst\",\"action\":1}" );
	r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)2 );
	if (r.size() == 2)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_MESSAGE );
		CHECK_STR( r[0].nick.c_str(), "Kim" );
		CHECK( r[0].text == WideCharString( u"selam " ) + (WideChar)0x011F );
		CHECK( !r[0].message.isPrivate );
		CHECK_EQ( r[0].message.profileID, 9 );
		CHECK( r[1].message.isPrivate );
		CHECK( r[1].message.isAction );
	}

	rig.feed( "{\"t\":\"player.left\",\"room\":\"lobby1\",\"id\":9,\"nick\":\"Kim\"}" );
	r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)1 );
	if (r.size() == 1)
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_PLAYERLEFT );
}

TEST(online_adapter_game_list_round_trips_the_host_options)
{
	AdapterRig rig;
	rig.login();

	// host: the CRCs given at creation travel in every game.opts
	PeerRequest create;
	create.peerRequestType = PeerRequest::PEERREQUEST_CREATESTAGINGROOM;
	create.text = u"fun game";
	create.stagingRoomCreation.exeCRC = 0x12345678;
	create.stagingRoomCreation.iniCRC = 0x9abcdef0;
	create.stagingRoomCreation.gameVersion = 3;
	create.stagingRoomCreation.allowObservers = TRUE;
	create.stagingRoomCreation.useStats = TRUE;
	create.stagingRoomCreation.ladPort = 0;
	create.stagingRoomCreation.restrictGameList = FALSE;
	rig.peer->addRequest( create );
	CHECK_STR( rig.sentType( 0 ).c_str(), "game.host" );
	CHECK_STR( rig.sent[0].getString( "name" ).c_str(), "fun game" );

	rig.feed( "{\"t\":\"game.joined\",\"action\":\"joined\",\"id\":6,\"name\":\"fun game\",\"map\":\"-\",\"maxp\":8,\"host\":\"Tank\",\"hostId\":7,\"count\":1,\"opts\":\"\",\"ids\":[7],\"nicks\":[\"Tank\"]}" );
	std::vector<PeerResponse> r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)2 );
	if (r.size() == 2)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_CREATESTAGINGROOM );
		CHECK_EQ( r[0].createStagingRoom.result, (Int)PEERJoinSuccess );
		// the host itself on the staging room's player list, so its own chat lines show
		CHECK_EQ( (int)r[1].peerResponseType, (int)PeerResponse::PEERRESPONSE_PLAYERINFO );
		CHECK_STR( r[1].nick.c_str(), "Tank" );
		CHECK_EQ( (int)r[1].player.roomType, (int)StagingRoom );
	}

	PeerRequest opts;
	opts.peerRequestType = PeerRequest::PEERREQUEST_SETGAMEOPTIONS;
	opts.options = "M=maps/a.map;S=Tank,0,0";
	opts.gameOptsMapName = "maps/a/a.map";
	opts.gameOptsPlayerNames[0] = "Tank";
	for (Int i = 0; i < MAX_SLOTS; ++i)
	{
		opts.gameOptions.wins[i] = opts.gameOptions.losses[i] = opts.gameOptions.profileID[i] = 0;
		opts.gameOptions.faction[i] = opts.gameOptions.color[i] = 0;
	}
	opts.gameOptions.wins[0] = 4;
	opts.gameOptions.numPlayers = 1;
	opts.gameOptions.numObservers = 0;
	opts.gameOptions.maxPlayers = 2;
	rig.peer->addRequest( opts );
	CHECK_STR( rig.sentType( 1 ).c_str(), "game.opts" );
	CHECK_STR( rig.sentType( 2 ).c_str(), "utm" );
	CHECK_EQ( rig.sent[2].getInt( "room" ), 6 );		// a staging room is its game id, a number
	CHECK_STR( rig.sent[2].getString( "cmd" ).c_str(), "SL/" );
	CHECK_STR( rig.sent[2].getString( "opts" ).c_str(), "M=maps/a.map;S=Tank,0,0" );

	// the list as another player sees it, from the server's game line carrying those opts
	OnlineMessage game;
	game.setString( "t", "game" ).setString( "action", "add" ).setInt( "id", 6 ).setString( "name", "fun game" );
	game.setString( "map", "-" ).setInt( "maxp", 8 ).setString( "host", "Tank" ).setInt( "hostId", 7 ).setInt( "count", 1 );
	game.setString( "opts", rig.sent.size() > 1 ? rig.sent[1].getString( "opts" ) : std::string() );

	PeerRequest list;
	list.peerRequestType = PeerRequest::PEERREQUEST_STARTGAMELIST;
	list.gameList.restrictGameList = FALSE;
	rig.peer->addRequest( list );
	CHECK_STR( rig.sentType( 3 ).c_str(), "games.watch" );
	rig.feed( game );
	r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)3 );
	if (r.size() == 3)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_STAGINGROOM );
		CHECK_EQ( r[0].stagingRoom.action, PEER_CLEAR );
		CHECK_EQ( (int)r[1].peerResponseType, (int)PeerResponse::PEERRESPONSE_STAGINGROOMLISTCOMPLETE );
		CHECK_EQ( r[2].stagingRoom.action, PEER_ADD );
		CHECK_EQ( r[2].stagingRoom.id, 6 );
		CHECK( r[2].stagingServerName == WideCharString( u"fun game" ) );
		CHECK_EQ( r[2].stagingRoom.exeCRC, 0x12345678u );
		CHECK_EQ( r[2].stagingRoom.iniCRC, 0x9abcdef0u );
		CHECK_EQ( r[2].stagingRoom.version, 3u );
		CHECK( r[2].stagingRoom.allowObservers );
		CHECK_STR( r[2].stagingRoomMapName.c_str(), "maps/a/a.map" );
		CHECK_STR( r[2].stagingRoomPlayerNames[0].c_str(), "Tank" );
		CHECK_EQ( r[2].stagingRoom.wins[0], 4 );
		CHECK_EQ( r[2].stagingRoom.maxPlayers, 2 );
	}
}

TEST(online_adapter_join_utm_and_start)
{
	AdapterRig rig;
	rig.login();

	PeerRequest join;
	join.peerRequestType = PeerRequest::PEERREQUEST_JOINSTAGINGROOM;
	join.stagingRoom.id = 5;
	rig.peer->addRequest( join );
	CHECK_STR( rig.sentType( 0 ).c_str(), "game.join" );
	CHECK_EQ( rig.sent[0].getInt( "id" ), 5 );

	rig.feed( "{\"t\":\"game.joined\",\"action\":\"joined\",\"id\":5,\"name\":\"g\",\"map\":\"-\",\"maxp\":8,\"host\":\"Kim\",\"hostId\":9,\"count\":2,\"opts\":\"\",\"ids\":[9,7],\"nicks\":[\"Kim\",\"Tank\"]}" );
	std::vector<PeerResponse> r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)3 );
	if (r.size() == 3)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_JOINSTAGINGROOM );
		CHECK( r[0].joinStagingRoom.ok );
		CHECK_EQ( r[0].joinStagingRoom.id, 5 );
		CHECK( r[0].joinStagingRoom.isHostPresent );
		CHECK_STR( r[0].stagingRoomPlayerNames[0].c_str(), "Kim" );
		CHECK_STR( r[0].stagingRoomPlayerNames[1].c_str(), "Tank" );
		// both on the staging room's player list, the host's chat lines need it
		CHECK_EQ( (int)r[1].peerResponseType, (int)PeerResponse::PEERRESPONSE_PLAYERINFO );
		CHECK_STR( r[1].nick.c_str(), "Kim" );
		CHECK_EQ( r[1].player.profileID, 9 );
		CHECK_STR( r[2].nick.c_str(), "Tank" );
	}
	CHECK_STR( rig.sentType( 1 ).c_str(), "stats.get" );		// the host's stats, as GameSpy's join read them
	CHECK_EQ( rig.sent[1].getInt( "id" ), 9 );

	rig.feed( "{\"t\":\"utm\",\"from\":9,\"nick\":\"Kim\",\"cmd\":\"SL/\",\"opts\":\"M=maps/a.map\",\"room\":5}" );
	rig.feed( "{\"t\":\"utm\",\"from\":9,\"nick\":\"Kim\",\"cmd\":\"KICK/\",\"opts\":\"GameFull\",\"to\":\"Tank\"}" );
	rig.feed( "{\"t\":\"utm\",\"from\":9,\"nick\":\"Kim\",\"cmd\":\"X\",\"opts\":\"\",\"room\":\"lobby1\"}" );		// a chat room's: dropped
	r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)2 );
	if (r.size() == 2)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_ROOMUTM );
		CHECK_STR( r[0].nick.c_str(), "Kim" );
		CHECK_STR( r[0].command.c_str(), "SL" );		// the screens compare without GameSpy's slash
		CHECK_STR( r[0].commandOptions.c_str(), "M=maps/a.map" );
		CHECK_EQ( (int)r[1].peerResponseType, (int)PeerResponse::PEERRESPONSE_PLAYERUTM );
		CHECK_STR( r[1].command.c_str(), "KICK" );
	}

	PeerRequest utm;
	utm.peerRequestType = PeerRequest::PEERREQUEST_UTMPLAYER;
	utm.nick = "Kim";
	utm.id = "REQ/";
	utm.options = "accept";
	rig.peer->addRequest( utm );
	CHECK_STR( rig.sentType( 2 ).c_str(), "utm" );
	CHECK_STR( rig.sent[2].getString( "to" ).c_str(), "Kim" );
	CHECK_STR( rig.sent[2].getString( "cmd" ).c_str(), "REQ/" );

	// the server removes a started game from the list before it says game.start: no "host left"
	rig.feed( "{\"t\":\"game\",\"action\":\"remove\",\"id\":5}" );
	rig.feed( "{\"t\":\"game.start\",\"match\":\"m1\",\"ids\":[9,7],\"nicks\":[\"Kim\",\"Tank\"],\"vips\":[167772162,167772163]}" );
	r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)2 );
	if (r.size() == 2)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_STAGINGROOM );
		CHECK_EQ( r[0].stagingRoom.action, PEER_REMOVE );
		CHECK_EQ( (int)r[1].peerResponseType, (int)PeerResponse::PEERRESPONSE_GAMESTART );
	}
	CHECK_STR( OnlineSession::get().matchId.c_str(), "m1" );
}

TEST(online_adapter_host_leaving_reads_as_player_left)
{
	AdapterRig rig;
	rig.login();
	PeerRequest join;
	join.peerRequestType = PeerRequest::PEERREQUEST_JOINSTAGINGROOM;
	join.stagingRoom.id = 5;
	rig.peer->addRequest( join );
	rig.feed( "{\"t\":\"game.joined\",\"action\":\"joined\",\"id\":5,\"name\":\"g\",\"map\":\"-\",\"maxp\":8,\"host\":\"Kim\",\"hostId\":9,\"count\":2,\"opts\":\"\",\"ids\":[9,7],\"nicks\":[\"Kim\",\"Tank\"]}" );
	rig.peerResponses();

	rig.feed( "{\"t\":\"game\",\"action\":\"remove\",\"id\":5}" );
	std::vector<PeerResponse> r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)2 );
	if (r.size() == 2)
	{
		CHECK_EQ( r[0].stagingRoom.action, PEER_REMOVE );
		CHECK_EQ( (int)r[1].peerResponseType, (int)PeerResponse::PEERRESPONSE_PLAYERLEFT );
		CHECK_STR( r[1].nick.c_str(), "Kim" );
		CHECK_EQ( (int)r[1].player.roomType, (int)StagingRoom );
	}
}

TEST(online_adapter_quick_match)
{
	AdapterRig rig;
	rig.login();

	PeerRequest qm;
	qm.peerRequestType = PeerRequest::PEERREQUEST_STARTQUICKMATCH;
	qm.qmMaps.push_back( true );
	qm.qmMaps.push_back( false );
	qm.qmMaps.push_back( true );
	qm.QM.side = 2;
	qm.QM.color = 3;
	rig.peer->addRequest( qm );
	CHECK_STR( rig.sentType( 0 ).c_str(), "qm.join" );
	if (!rig.sent.empty())
	{
		const std::vector<long long> maps = rig.sent[0].getInts( "maps" );
		CHECK_EQ( maps.size(), (size_t)2 );
		CHECK( maps.size() == 2 && maps[0] == 0 && maps[1] == 2 );
		CHECK_EQ( rig.sent[0].getInt( "side" ), 2 );
		CHECK_EQ( rig.sent[0].getInt( "color" ), 3 );
	}

	rig.feed( "{\"t\":\"qm.status\",\"status\":\"searching\",\"pool\":4}" );
	PeerRequest widen;
	widen.peerRequestType = PeerRequest::PEERREQUEST_WIDENQUICKMATCHSEARCH;
	rig.peer->addRequest( widen );
	CHECK_STR( rig.sentType( 1 ).c_str(), "qm.widen" );
	// side -25 is a Random pool (America and Turkiye): this binary has no template store, so a pool is the
	// one kind of side that reaches the seat unchanged here
	rig.feed( "{\"t\":\"qm.matched\",\"match\":\"q1\",\"seed\":77,\"mapIdx\":1,\"nicks\":[\"Tank\",\"Kim\"],\"ids\":[7,9],\"vips\":[167772163,167772162],\"sides\":[-25,-1],\"colors\":[3,-1]}" );

	std::vector<PeerResponse> r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)3 );
	if (r.size() == 3)
	{
		CHECK_EQ( (int)r[0].qmStatus.status, (int)QM_WORKING );
		CHECK_EQ( r[0].qmStatus.poolSize, 4 );
		CHECK_EQ( (int)r[1].qmStatus.status, (int)QM_WIDENINGSEARCH );
		CHECK_EQ( (int)r[2].peerResponseType, (int)PeerResponse::PEERRESPONSE_QUICKMATCHSTATUS );
		CHECK_EQ( (int)r[2].qmStatus.status, (int)QM_MATCHED );
		CHECK_EQ( r[2].qmStatus.seed, 77 );
		CHECK_EQ( r[2].qmStatus.mapIdx, 1 );
		CHECK_STR( r[2].stagingRoomPlayerNames[0].c_str(), "Tank" );
		CHECK_STR( r[2].stagingRoomPlayerNames[1].c_str(), "Kim" );
		CHECK( r[2].stagingRoomPlayerNames[2].empty() );
		CHECK_EQ( r[2].qmStatus.IP[1], 0x0A000002u );
		CHECK_EQ( r[2].qmStatus.side[0], -25 );
		CHECK_EQ( r[2].qmStatus.color[1], -1 );
		CHECK_EQ( r[2].qmStatus.nat[0], 1 );
	}
	CHECK_STR( OnlineSession::get().matchId.c_str(), "q1" );
}

/* GameLogic dereferences the template and the colour a seat names (getColor(999)->getColor() was a
	 crash at Quick Match start), so whatever the server says is clamped before a seat sees it. */
TEST(online_seat_side_and_color_are_clamped)
{
	const Int TEMPLATES = 5, COLORS = 8;
	CHECK_EQ( OnlineSeatSide( 0, TEMPLATES ), 0 );
	CHECK_EQ( OnlineSeatSide( 4, TEMPLATES ), 4 );
	CHECK_EQ( OnlineSeatSide( -1, TEMPLATES ), -1 );
	CHECK_EQ( OnlineSeatSide( PLAYERTEMPLATE_RANDOM_POOL - 0x9, TEMPLATES ), PLAYERTEMPLATE_RANDOM_POOL - 0x9 );
	CHECK_EQ( OnlineSeatSide( PLAYERTEMPLATE_RANDOM_POOL - 0x3FFFFFFF, TEMPLATES ), PLAYERTEMPLATE_RANDOM_POOL - 0x3FFFFFFF );
	CHECK_EQ( OnlineSeatSide( 5, TEMPLATES ), -1 );
	CHECK_EQ( OnlineSeatSide( 999, TEMPLATES ), -1 );
	CHECK_EQ( OnlineSeatSide( PLAYERTEMPLATE_OBSERVER, TEMPLATES ), -1 );
	CHECK_EQ( OnlineSeatSide( -3, TEMPLATES ), -1 );
	CHECK_EQ( OnlineSeatSide( PLAYERTEMPLATE_RANDOM_POOL, TEMPLATES ), -1 );
	CHECK_EQ( OnlineSeatSide( PLAYERTEMPLATE_RANDOM_POOL - 0x40000000LL, TEMPLATES ), -1 );
	CHECK_EQ( OnlineSeatSide( (1LL << 32) + 2, TEMPLATES ), -1 );		// not 2 after a truncation
	CHECK_EQ( OnlineSeatSide( -(1LL << 40), TEMPLATES ), -1 );
	CHECK_EQ( OnlineSeatSide( 0, 0 ), -1 );

	CHECK_EQ( OnlineSeatColor( 0, COLORS ), 0 );
	CHECK_EQ( OnlineSeatColor( 7, COLORS ), 7 );
	CHECK_EQ( OnlineSeatColor( -1, COLORS ), -1 );
	CHECK_EQ( OnlineSeatColor( 8, COLORS ), -1 );
	CHECK_EQ( OnlineSeatColor( 999, COLORS ), -1 );
	CHECK_EQ( OnlineSeatColor( -2, COLORS ), -1 );
	CHECK_EQ( OnlineSeatColor( (1LL << 32) + 3, COLORS ), -1 );

	// through the adapter: a hostile qm.matched and a hostile game list line
	AdapterRig rig;
	rig.login();
	rig.feed( "{\"t\":\"qm.matched\",\"match\":\"q9\",\"seed\":1,\"mapIdx\":-5,\"nicks\":[\"Tank\",\"Kim\"],\"ids\":[7,9],\"vips\":[1,2],\"sides\":[999,-2],\"colors\":[999,-7]}" );
	OnlineMessage opts;
	opts.setInts( "factions", std::vector<long long>( 2, 999 ) ).setInts( "colors", std::vector<long long>( 2, 4294967296LL ) );
	std::string optsLine;
	CHECK( opts.toLine( optsLine ) );
	OnlineMessage game;
	game.setString( "t", "game" ).setString( "action", "add" ).setInt( "id", 3 ).setString( "host", "Kim" );
	game.setString( "opts", optsLine.substr( 0, optsLine.size() - 1 ) );
	rig.feed( game );

	std::vector<PeerResponse> r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)2 );
	if (r.size() == 2)
	{
		CHECK_EQ( (int)r[0].qmStatus.status, (int)QM_MATCHED );
		for (Int i = 0; i < 2; ++i)
		{
			CHECK_EQ( r[0].qmStatus.side[i], -1 );
			CHECK_EQ( r[0].qmStatus.color[i], -1 );
			CHECK_EQ( r[1].stagingRoom.faction[i], -1 );
			CHECK_EQ( r[1].stagingRoom.color[i], -1 );
		}
	}
}

TEST(online_test_server_only_when_the_welcome_says_so)
{
	AdapterRig rig;
	CHECK( !OnlineIsTestServer() );
	rig.feed( "{\"t\":\"welcome\",\"config\":\"\",\"motd\":\"\",\"relayPort\":8094}" );
	CHECK( !OnlineIsTestServer() );
	rig.feed( "{\"t\":\"welcome\",\"config\":\"\",\"motd\":\"\",\"relayPort\":8094,\"testMode\":\"yes\"}" );
	CHECK( !OnlineIsTestServer() );		// a bool, not anything truthy
	rig.feed( "{\"t\":\"welcome\",\"config\":\"\",\"motd\":\"\",\"relayPort\":8094,\"testMode\":true}" );
	CHECK( OnlineIsTestServer() );
	rig.feed( "{\"t\":\"welcome\",\"config\":\"\",\"motd\":\"\",\"relayPort\":8094,\"testMode\":false}" );
	CHECK( !OnlineIsTestServer() );
}

TEST(online_adapter_stats_read_and_writes_dropped)
{
	AdapterRig rig;
	rig.login();

	PSRequest read;
	read.requestType = PSRequest::PSREQUEST_READPLAYERSTATS;
	read.player.id = 9;
	rig.ps->addRequest( read );
	PSRequest write;
	write.requestType = PSRequest::PSREQUEST_UPDATEPLAYERSTATS;
	write.player.id = 7;
	write.player.wins[3] = 1000;
	rig.ps->addRequest( write );
	CHECK_EQ( rig.sent.size(), (size_t)1 );		// the write never leaves
	CHECK_STR( rig.sentType( 0 ).c_str(), "stats.get" );
	CHECK_EQ( rig.sent[0].getInt( "id" ), 9 );

	rig.feed( "{\"t\":\"stats\",\"id\":9,\"kv\":\"\\\\nick\\\\Kim\\\\wins\\\\5\\\\losses\\\\2\\\\games\\\\7\\\\rating\\\\31\"}" );
	PSResponse resp;
	CHECK( rig.ps->getResponse( resp ) );
	CHECK_EQ( (int)resp.responseType, (int)PSResponse::PSRESPONSE_PLAYERSTATS );
	CHECK_EQ( resp.player.id, 9 );
	CHECK_EQ( (int)resp.player.wins[0], 5 );
	CHECK_EQ( (int)resp.player.losses[0], 2 );
	CHECK_EQ( (int)resp.player.games[0], 7 );
	CHECK_EQ( (int)rig.ps->findPlayerStatsByID( 9 ).wins[0], 5 );
	CHECK_EQ( rig.ps->findPlayerStatsByID( 12 ).id, 0 );
}

TEST(online_adapter_report_goes_once_a_match)
{
	AdapterRig rig;
	rig.login();

	OnlineReport report;
	report.seed = 77;
	report.endFrame = 9000;
	report.duration = 9000;
	report.winningTeam = 1;
	report.sawGameEnd = TRUE;
	report.surrendered = TRUE;
	report.numPlayers = 2;
	report.side[0] = "America";
	report.side[1] = "China";
	report.discon[1] = TRUE;

	OnlineSendReport( report );
	CHECK( rig.sent.empty() );		// no match yet

	rig.feed( "{\"t\":\"qm.matched\",\"match\":\"q1\",\"seed\":77,\"mapIdx\":0,\"nicks\":[\"Tank\",\"Kim\"],\"ids\":[7,9],\"vips\":[1,2],\"sides\":[0,0],\"colors\":[0,1]}" );
	OnlineSendReport( report );
	OnlineSendReport( report );		// the score screen's second call
	CHECK_EQ( rig.sent.size(), (size_t)1 );
	if (rig.sent.size() == 1)
	{
		const OnlineMessage &m = rig.sent[0];
		CHECK_STR( m.type().c_str(), "report" );
		CHECK_STR( m.getString( "match" ).c_str(), "q1" );
		CHECK_EQ( m.getInt( "seed" ), 77 );
		CHECK_EQ( m.getInt( "endFrame" ), 9000 );
		CHECK_EQ( m.getInt( "winningTeam" ), 1 );
		CHECK( m.getBool( "surrendered" ) );
		CHECK( !m.getBool( "sawDesync" ) );
		CHECK( m.getInts( "discon" ).size() == 2 && m.getInts( "discon" )[1] == 1 );
		CHECK( m.getStrings( "side" ).size() == 2 && m.getStrings( "side" )[1] == "China" );
	}

	// the next match reports again
	rig.feed( "{\"t\":\"game.start\",\"match\":\"m2\",\"ids\":[7,9],\"nicks\":[\"Tank\",\"Kim\"],\"vips\":[1,2]}" );
	OnlineSendReport( report );
	CHECK_EQ( rig.sent.size(), (size_t)2 );
}

/* Tank in the lobby's chat room, then hosting game 1 (the server keeps him in the chat room too). */
static void hostGameOne( AdapterRig &rig )
{
	rig.login();
	PeerRequest join;
	join.peerRequestType = PeerRequest::PEERREQUEST_JOINGROUPROOM;
	join.groupRoom.id = 1;
	rig.peer->addRequest( join );
	rig.feed( "{\"t\":\"room\",\"id\":\"lobby1\",\"ids\":[7],\"nicks\":[\"Tank\"],\"vips\":[167772163]}" );
	PeerRequest create;
	create.peerRequestType = PeerRequest::PEERREQUEST_CREATESTAGINGROOM;
	create.text = u"g";
	create.stagingRoomCreation.exeCRC = 1;
	create.stagingRoomCreation.iniCRC = 2;
	create.stagingRoomCreation.gameVersion = 3;
	create.stagingRoomCreation.allowObservers = FALSE;
	create.stagingRoomCreation.useStats = TRUE;
	create.stagingRoomCreation.ladPort = 0;
	rig.peer->addRequest( create );
	rig.feed( "{\"t\":\"game.joined\",\"action\":\"joined\",\"id\":1,\"name\":\"g\",\"map\":\"\",\"maxp\":8,\"host\":\"Tank\",\"hostId\":7,\"count\":1,\"opts\":\"\",\"ids\":[7],\"nicks\":[\"Tank\"],\"vips\":[167772163]}" );
	rig.peerResponses();
	rig.sent.clear();
}

TEST(online_adapter_host_seats_a_joiner_at_its_relay_address)
{
	AdapterRig rig;
	hostGameOne( rig );

	// what the WOL staging room seats a joiner from: PLAYERJOIN, StagingRoom, the IP in network order
	rig.feed( "{\"t\":\"player\",\"game\":1,\"id\":9,\"nick\":\"Kim\",\"vip\":167772162}" );
	std::vector<PeerResponse> r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)1 );
	if (r.size() == 1)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_PLAYERJOIN );
		CHECK_EQ( (int)r[0].player.roomType, (int)StagingRoom );
		CHECK_STR( r[0].nick.c_str(), "Kim" );
		CHECK_EQ( r[0].player.profileID, 9 );
		CHECK_EQ( r[0].player.IP, OnlineHostToNet( 0x0A000002 ) );
	}

	// and leaving carries it too
	rig.feed( "{\"t\":\"player.left\",\"game\":1,\"id\":9,\"nick\":\"Kim\"}" );
	r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)1 );
	if (r.size() == 1)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_PLAYERLEFT );
		CHECK_EQ( r[0].player.IP, OnlineHostToNet( 0x0A000002 ) );
	}
}

TEST(online_adapter_staging_chat_arrives_once)
{
	AdapterRig rig;
	hostGameOne( rig );

	// staging chat names the game by number; the chat room's line for "lobby1" is not the staging room's
	PeerRequest say;
	say.peerRequestType = PeerRequest::PEERREQUEST_MESSAGEROOM;
	say.text = u"gl hf";
	say.message.isAction = FALSE;
	rig.peer->addRequest( say );
	CHECK_STR( rig.sentType( 0 ).c_str(), "say" );
	CHECK_EQ( rig.sent[0].getInt( "room" ), 1 );

	rig.feed( "{\"t\":\"said\",\"room\":\"lobby1\",\"from\":9,\"nick\":\"Kim\",\"text\":\"hi\",\"action\":0}" );
	rig.feed( "{\"t\":\"said\",\"room\":1,\"from\":9,\"nick\":\"Kim\",\"text\":\"hi\",\"action\":0}" );
	std::vector<PeerResponse> r = rig.peerResponses();
	CHECK_EQ( r.size(), (size_t)1 );
	if (r.size() == 1)
	{
		CHECK_EQ( (int)r[0].peerResponseType, (int)PeerResponse::PEERRESPONSE_MESSAGE );
		CHECK( r[0].text == WideCharString( u"hi" ) );
	}
}

TEST(online_adapter_logs_the_rating_result)
{
	AdapterRig rig;
	rig.login();
	rig.feed( "{\"t\":\"rated\",\"match\":\"q1\",\"delta\":1.25,\"rating\":-3.5}" );
	CHECK_STR( OnlineSession::get().resultLine.c_str(), "ONLINE RATED delta=1.25 rating=-3.5" );
	CHECK_STR( rig.sentType( 0 ).c_str(), "stats.get" );		// our own numbers again
	rig.feed( "{\"t\":\"unrated\",\"match\":\"m2\",\"reason\":\"custom\"}" );
	CHECK_STR( OnlineSession::get().resultLine.c_str(), "ONLINE UNRATED reason=custom" );
}

TEST(online_adapter_leaves_the_chat_room_for_a_staging_room)
{
	AdapterRig rig;
	rig.login();
	PeerRequest join;
	join.peerRequestType = PeerRequest::PEERREQUEST_JOINGROUPROOM;
	join.groupRoom.id = 1;
	rig.peer->addRequest( join );
	rig.feed( "{\"t\":\"room\",\"id\":\"lobby1\",\"ids\":[7],\"nicks\":[\"Tank\"],\"vips\":[167772163]}" );
	rig.peerResponses();
	rig.sent.clear();

	PeerRequest create;
	create.peerRequestType = PeerRequest::PEERREQUEST_CREATESTAGINGROOM;
	create.text = u"fun game";
	rig.peer->addRequest( create );
	CHECK_STR( rig.sentType( 0 ).c_str(), "room.leave" );
	CHECK_STR( rig.sentType( 1 ).c_str(), "game.host" );

	rig.sent.clear();
	PeerRequest leave;
	leave.peerRequestType = PeerRequest::PEERREQUEST_LEAVEGROUPROOM;
	rig.peer->addRequest( leave );
	CHECK_EQ( rig.sent.size(), (size_t)0 );		// already out
}

TEST(online_register_url_from_the_welcome_and_only_a_web_page_opens)
{
	AdapterRig rig;
	rig.feed( "{\"t\":\"welcome\",\"config\":\"\",\"motd\":\"\",\"relayPort\":8094}" );
	CHECK( OnlineGetRegisterUrl().isEmpty() );		// none sent: Create Account hides
	rig.feed( "{\"t\":\"welcome\",\"config\":\"\",\"motd\":\"\",\"relayPort\":8094,\"registerUrl\":\"https://example.test/register\"}" );
	CHECK_STR( OnlineGetRegisterUrl().str(), "https://example.test/register" );
	// a hostile server's address is refused before anything is asked to open it
	CHECK( !OnlineOpenURL( "file:///C:/Windows/System32/calc.exe" ) );
	CHECK( !OnlineOpenURL( "C:\\Windows\\notepad.exe" ) );
	CHECK( !OnlineOpenURL( "" ) );
	CHECK( !OnlineOpenURL( NULL ) );
}