protected:

	/** Address we're connecting to */

	NetworkAddress address;

public:

	/** Silence the warnings */

	virtual ~TCPConnecter() {}

	/**

	 * Callback when the connection succeeded.

	 * @param s the socket that we opened

 */

#include "../../stdafx.h"

#include "../../thread.h"

#include "tcp.h"

#include "../../safeguards.h"

/** List of connections that are currently being created */

static std::vector<TCPConnecter *> _tcp_connecters;

/**

 * Create a new connecter for the given address

 */

	connected(false),

	aborted(false),

	killed(false),

{

	_tcp_connecters.push_back(this);

	if (!StartNewThread(nullptr, "ottd:tcp", &TCPConnecter::ThreadEntry, this)) {

		this->Connect();

	}

}

	char *url = strchr(hname, '/');

	if (url == nullptr) return_error("[tcp/http] invalid location");

	*url = '\0';

	/* Restore the URL. */

	*url = '/';

	return 0;

}

#undef return_error

/**

	const char *data;       ///< The data to send

	int depth;              ///< How far we have recursed

public:

	/**

	 * Start the connecting.

	 */

		callback(callback),

		url(stredup(url)),

		data(data),

		depth(depth)

	{

	}

 *

 * @param company Pointer to the company variable to set iff indicted.

 * @param connection_string The string to parse.

 * @param default_port The default port to set port to if not in connection_string.

 * @return A valid NetworkAddress of the parsed information.

 */

{

	char internal_connection_string[NETWORK_HOSTNAME_PORT_LENGTH + 4]; // 4 extra for the "#" and company

	strecpy(internal_connection_string, connection_string.c_str(), lastof(internal_connection_string));

	const char *port_s = nullptr;

	const char *company_s = nullptr;

	ParseFullConnectionString(&company_s, &port_s, internal_connection_string);

	int port = port_s != nullptr ? atoi(port_s) : default_port;

	return NetworkAddress(internal_connection_string, port);

}

/**

}

/** Non blocking connection create to query servers */

class TCPQueryConnecter : TCPConnecter {

private:

	bool request_company_info;

public:

	void OnFailure() override

	{

		NetworkDisconnect();

	}

	void OnConnect(SOCKET s) override

	{

		_networking = true;

		MyClient::SendInformationQuery(request_company_info);

	}

};

/**

 * Query a server to fetch his game-info.

 * @param request_company_info Whether to request company info too.

 */

{

	if (!_network_available) return;

	NetworkDisconnect();

	NetworkInitialize();

}

/**

 * Validates an address entered as a string and adds the server to

 * the list. If you use this function, the games will be marked

 * as manually added.

 * @return The entry on the game list.

 */

NetworkGameList *NetworkAddServer(const std::string &connection_string)

{

	if (connection_string.empty()) return nullptr;

	/* Ensure the item already exists in the list */

	if (StrEmpty(item->info.server_name)) {

		ClearGRFConfigList(&item->info.grfconfig);

		item->manually = true;

		NetworkRebuildHostList();

		UpdateNetworkGameWindow();

	}

	return item;

}

/**

 * Get the addresses to bind to.

 * by the function that generates the config file. */

void NetworkRebuildHostList()

{

	_network_host_list.clear();

	for (NetworkGameList *item = _network_game_list; item != nullptr; item = item->next) {

	}

}

/** Non blocking connection create to actually connect to servers */

class TCPClientConnecter : TCPConnecter {

public:

	void OnFailure() override

	{

		ShowNetworkError(STR_NETWORK_ERROR_NOCONNECTION);

	}

	void OnConnect(SOCKET s) override

	{

		_networking = true;

		IConsoleCmdExec("exec scripts/on_client.scr 0");

		NetworkClient_Connected();

	}

};

/**

 * @param join_company_password The password for the company.

 * @return Whether the join has started.

 */

bool NetworkClientConnectGame(const std::string &connection_string, CompanyID default_company, const char *join_server_password, const char *join_company_password)

{

	CompanyID join_as = default_company;

	if (!_network_available) return false;

	if (!NetworkValidateClientName()) return false;

	_network_join.company = join_as;

	_network_join.server_password = join_server_password;

	_network_join.company_password = join_company_password;

	if (_game_mode == GM_MENU) {

		/* From the menu we can immediately continue with the actual join. */

 */

void NetworkClientJoinGame()

{

	NetworkDisconnect();

	NetworkInitialize();

	_network_join_status = NETWORK_JOIN_STATUS_CONNECTING;

	ShowJoinStatusWindow();

}

static void NetworkInitGameInfo()

{

	if (StrEmpty(_settings_client.network.server_name)) {

		strecpy(_settings_client.network.server_name, "Unnamed Server", lastof(_settings_client.network.server_name));

/**

 * Create a new socket for the client side of the game connection.

 * @param s The socket to connect with.

 */

{

	assert(ClientNetworkGameSocketHandler::my_client == nullptr);

	ClientNetworkGameSocketHandler::my_client = this;

}

/** Clear whatever we assigned. */

{

	if (this->status != STATUS_COMPANY_INFO && this->status != STATUS_GAME_INFO) return NETWORK_RECV_STATUS_MALFORMED_PACKET;

	NetworkGameList *item = GetLobbyGameInfo();

	if (item == nullptr) {

		/* This is not the lobby, so add it to the game list. */

	}

	/* Clear any existing GRFConfig chain. */

	ClearGRFConfigList(&item->info.grfconfig);

	/* Retrieve the NetworkGameInfo from the packet. */

	DeserializeNetworkGameInfo(p, &item->info);

#include "network_internal.h"

/** Class for handling the client side of the game connection. */

class ClientNetworkGameSocketHandler : public ZeroedMemoryAllocator, public NetworkGameSocketHandler {

private:

	struct PacketReader *savegame; ///< Packet reader for reading the savegame.

	byte token;                    ///< The token we need to send back to the server to prove we're the right client.

	/** Status of the connection with the server. */

	enum ServerStatus {

		STATUS_INACTIVE,      ///< The client is not connected nor active.

	static NetworkRecvStatus SendNewGRFsOk();

	static NetworkRecvStatus SendGetMap();

	static NetworkRecvStatus SendMapOk();

	void CheckConnection();

public:

	~ClientNetworkGameSocketHandler();

	NetworkRecvStatus CloseConnection(NetworkRecvStatus status) override;

	void ClientError(NetworkRecvStatus res);

	static NetworkRecvStatus SendInformationQuery(bool request_company_info);

void NetworkClient_Connected();

void NetworkClientSetCompanyPassword(const char *password);

/** Information required to join a server. */

struct NetworkJoinInfo {

	NetworkJoinInfo() : company(COMPANY_SPECTATOR), server_password(nullptr), company_password(nullptr) {}

	CompanyID company;            ///< The company to join.

	const char *server_password;  ///< The password of the server to join.

	const char *company_password; ///< The password of the company to join.

};

extern NetworkJoinInfo _network_join;

	for (const ContentID &id : content) {

		p += seprintf(p, lastof, "%d\n", id);

	}

	this->http_response_index = -1;

	/* NetworkHTTPContentConnecter takes over freeing of content_request! */

}

/**

 * Initiate downloading the content over the fallback protocol.

 * @param content The content to download.

class NetworkContentConnecter : TCPConnecter {

public:

	/**

	 * Initiate the connecting.

	 * @param address The address of the server.

	 */

	void OnFailure() override

	{

		_network_content_client.isConnecting = false;

		_network_content_client.OnConnect(false);

	}

 * Connect with the content server.

 */

void ClientNetworkContentSocketHandler::Connect()

{

	if (this->sock != INVALID_SOCKET || this->isConnecting) return;

	this->isConnecting = true;

}

/**

 * Disconnect from the content server.

 */

void ClientNetworkContentSocketHandler::Close()

{

	while (true) {

		NetworkGameList *ins_item = _network_game_delayed_insertion_list.load(std::memory_order_relaxed);

		while (ins_item != nullptr && !_network_game_delayed_insertion_list.compare_exchange_weak(ins_item, ins_item->next, std::memory_order_acq_rel)) {}

		if (ins_item == nullptr) break; // No item left.

		if (item != nullptr) {

			if (StrEmpty(item->info.server_name)) {

				ClearGRFConfigList(&item->info.grfconfig);

				memset(&item->info, 0, sizeof(item->info));

				strecpy(item->info.server_name, ins_item->info.server_name, lastof(item->info.server_name));

/**

 * Add a new item to the linked gamelist. If the IP and Port match

 * return the existing item instead of adding it again

 * @param address the address of the to-be added item

 * @return a point to the newly added or already existing item

 */

{

	NetworkGameList *item, *prev_item;

	prev_item = nullptr;

	for (item = _network_game_list; item != nullptr; item = item->next) {

		prev_item = item;

	}

	item = CallocT<NetworkGameList>(1);

	item->next = nullptr;

	if (prev_item == nullptr) {

		_network_game_list = item;

	} else {

		prev_item->next = item;

	}

	for (NetworkGameList *item = _network_game_list; item != nullptr; item = item->next) {

		item->retries++;

		if (item->retries < REFRESH_GAMEINFO_X_REQUERIES && (item->online || item->retries >= MAX_GAME_LIST_REQUERY_COUNT)) continue;

		/* item gets mostly zeroed by NetworkUDPQueryServer */

		uint8 retries = item->retries;

		item->retries = (retries >= REFRESH_GAMEINFO_X_REQUERIES) ? 0 : retries;

	}

}

/**

 * Rebuild the GRFConfig's of the servers in the game list as we did

#include "core/game_info.h"

#include "network_type.h"

/** Structure with information shown in the game list (GUI) */

struct NetworkGameList {

	NetworkGameInfo info;   ///< The game information of this server

	bool online;            ///< False if the server did not respond (default status)

	bool manually;          ///< True if the server was added manually

	uint8 retries;          ///< Number of retries (to stop requerying)

	NetworkGameList *next;  ///< Next pointer to make a linked game list

};

/** Game list of this client */

extern NetworkGameList *_network_game_list;

void NetworkGameListAddItemDelayed(NetworkGameList *item);

void NetworkGameListRemoveItem(NetworkGameList *remove);

void NetworkGameListRequery();

#endif /* NETWORK_GAMELIST_H */

	}

	/** Sort servers by name. */

	static bool NGameNameSorter(NetworkGameList * const &a, NetworkGameList * const &b)

	{

		int r = strnatcmp(a->info.server_name, b->info.server_name, true); // Sort by name (natural sorting).

	}

	/**

	 * Sort servers by the amount of clients online on a

	 * server. If the two servers have the same amount, the one with the

	 * higher maximum is preferred.

			y += FONT_HEIGHT_NORMAL;

			SetDParamStr(0, sel->info.server_revision);

			DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, STR_NETWORK_SERVER_LIST_SERVER_VERSION); // server version

			y += FONT_HEIGHT_NORMAL;

			DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, STR_NETWORK_SERVER_LIST_SERVER_ADDRESS); // server address

			y += FONT_HEIGHT_NORMAL;

			SetDParam(0, sel->info.start_date);

			DrawString(r.left + WD_FRAMERECT_LEFT, r.right - WD_FRAMERECT_RIGHT, y, STR_NETWORK_SERVER_LIST_START_DATE); // start date

			y += FONT_HEIGHT_NORMAL;

				if (this->server != nullptr) {

					ShowNetworkLobbyWindow(this->server);

				}

				break;

			case WID_NG_REFRESH: // Refresh

				break;

			case WID_NG_NEWGRF: // NewGRF Settings

				if (this->server != nullptr) ShowNewGRFSettings(false, false, false, &this->server->info.grfconfig);

				break;

				if (click_count > 1 && !this->IsWidgetDisabled(WID_NL_JOIN)) this->OnClick(pt, WID_NL_JOIN, 1);

				break;

			}

			case WID_NL_JOIN:     // Join company

				/* Button can be clicked only when it is enabled. */

				break;

			case WID_NL_NEW:      // New company

				break;

			case WID_NL_SPECTATE: // Spectate game

				break;

			case WID_NL_REFRESH:  // Refresh

				/* Clear the information so removed companies don't remain */

				for (auto &company : this->company_info) company = {};

				break;

		}

	}

	void OnResize() override

	{

{

	if (!NetworkValidateClientName()) return;

	DeleteWindowById(WC_NETWORK_WINDOW, WN_NETWORK_WINDOW_START);

	DeleteWindowById(WC_NETWORK_WINDOW, WN_NETWORK_WINDOW_GAME);

	new NetworkLobbyWindow(&_network_lobby_window_desc, ngl);

}

/**

 * Get the company information of a given company to fill for the lobby.

extern uint32 _network_join_bytes_total;

extern uint8 _network_reconnect;

extern CompanyMask _network_company_passworded;

void GetBindAddresses(NetworkAddressList *addresses, uint16 port);

struct NetworkGameList *NetworkAddServer(const std::string &connection_string);

void NetworkRebuildHostList();

void UpdateNetworkGameWindow();

void NetworkTextMessage(NetworkAction action, TextColour colour, bool self_send, const char *name, const char *str = "", int64 data = 0);

uint NetworkCalculateLag(const NetworkClientSocket *cs);

StringID GetNetworkErrorMsg(NetworkErrorCode err);

bool NetworkFindName(char *new_name, const char *last);

const char *GenerateCompanyPasswordHash(const char *password, const char *password_server_id, uint32 password_game_seed);

NetworkAddress ParseConnectionString(const std::string &connection_string, int default_port);

#endif /* NETWORK_INTERNAL_H */

static UDPSocket _udp_client("Client"); ///< udp client socket

static UDPSocket _udp_server("Server"); ///< udp server socket

static UDPSocket _udp_master("Master"); ///< udp master socket

/**

 * Helper function doing the actual work for querying the server.

 * @param needs_mutex Whether we need to acquire locks when sending the packet or not.

 * @param manually Whether the address was entered manually.

 */

{

	/* Clear item in gamelist */

	NetworkGameList *item = CallocT<NetworkGameList>(1);

	item->manually = manually;

	NetworkGameListAddItemDelayed(item);

	std::unique_lock<std::mutex> lock(_udp_client.mutex, std::defer_lock);

	if (needs_mutex) lock.lock();

	/* Init the packet */

	Packet p(PACKET_UDP_CLIENT_FIND_SERVER);

	if (_udp_client.socket != nullptr) _udp_client.socket->SendPacket(&p, &address);

}

/**

 * Query a specific server.

 * @param manually Whether the address was entered manually.

 */

{

	}

}

///*** Communication with the masterserver ***/

/** Helper class for connecting to the master server. */

	/* Just a fail-safe.. should never happen */

	if (_network_udp_server) return;

	DEBUG(net, 4, "[udp] server response from %s", client_addr->GetAddressAsString().c_str());

	/* Find next item */

	/* Clear any existing GRFConfig chain. */

	ClearGRFConfigList(&item->info.grfconfig);

	/* Retrieve the NetworkGameInfo from the packet. */

	DeserializeNetworkGameInfo(p, &item->info);

	/* Check for compatability with the client. */

			packet.Send_uint8(in_request_count);

			for (i = 0; i < in_request_count; i++) {

				SerializeGRFIdentifier(&packet, &in_request[i]->ident);

			}

		}

	}

	if (client_addr->GetAddress()->ss_family == AF_INET6) {

		strecat(item->info.server_name, " (IPv6)", lastof(item->info.server_name));

	}

			NetworkAddress addr(addr_storage, type == SLT_IPv4 ? sizeof(sockaddr_in) : sizeof(sockaddr_in6));

			addr.SetPort(p->Recv_uint16());

			/* Somehow we reached the end of the packet */

			if (this->HasClientQuit()) return;

		}

	}

}

/** The return of the client's request of the names of some NewGRFs */

void ClientNetworkUDPSocketHandler::Receive_SERVER_NEWGRFS(Packet *p, NetworkAddress *client_addr)