NetworkAddress address;

public:

	/** Silence the warnings */

	virtual ~TCPConnecter() {}

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

#include "tcp.h"

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

/**

 * 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();

	*url = '\0';

	/* Restore the URL. */

	*url = '/';

	return 0;

}

public:

	/**

	 * Start the connecting.

	 */

		callback(callback),

		url(stredup(url)),

		data(data),

 * @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 *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);

class TCPQueryConnecter : TCPConnecter {

private:

	bool request_company_info;

public:

	void OnFailure() override

	{

	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();

}

/**

{

	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;

}

	_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

	{

	void OnConnect(SOCKET s) override

	{

		_networking = true;

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

		NetworkClient_Connected();

	}

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;

	NetworkDisconnect();

	NetworkInitialize();

	_network_join_status = NETWORK_JOIN_STATUS_CONNECTING;

	ShowJoinStatusWindow();

}

static void NetworkInitGameInfo()

 * 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;

	NetworkGameList *item = GetLobbyGameInfo();

	if (item == nullptr) {

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

	}

	/* Clear any existing GRFConfig chain. */

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

	static NetworkRecvStatus SendMapOk();

	void CheckConnection();

public:

	~ClientNetworkGameSocketHandler();

	NetworkRecvStatus CloseConnection(NetworkRecvStatus status) override;

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

struct NetworkJoinInfo {

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

};

extern NetworkJoinInfo _network_join;

	this->http_response_index = -1;

	/* NetworkHTTPContentConnecter takes over freeing of content_request! */

}

	 * Initiate the connecting.

	 * @param address The address of the server.

	 */

	void OnFailure() override

	{

{

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

	this->isConnecting = true;

}

/**

		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)) {

 * @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;

		/* item gets mostly zeroed by NetworkUDPQueryServer */

		uint8 retries = item->retries;

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

	}

}

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

struct NetworkGameList {

};

/** Game list of this client */

extern NetworkGameList *_network_game_list;

void NetworkGameListAddItemDelayed(NetworkGameList *item);

void NetworkGameListRemoveItem(NetworkGameList *remove);

void NetworkGameListRequery();

	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).

	}

	/**

			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;

				break;

			case WID_NG_REFRESH: // Refresh

				break;

			case WID_NG_NEWGRF: // NewGRF Settings

			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;

		}

	}

	DeleteWindowById(WC_NETWORK_WINDOW, WN_NETWORK_WINDOW_START);

	DeleteWindowById(WC_NETWORK_WINDOW, WN_NETWORK_WINDOW_GAME);

	new NetworkLobbyWindow(&_network_lobby_window_desc, ngl);

}

extern CompanyMask _network_company_passworded;

void GetBindAddresses(NetworkAddressList *addresses, uint16 port);

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

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

/**

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

 */

{

	}

}

	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);

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

			}

		}

	}

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

			if (this->HasClientQuit()) return;

		}

	}

}

void NetworkUDPInitialize();

void NetworkUDPSearchGame();

void NetworkUDPQueryMasterServer();

void NetworkUDPAdvertise();

void NetworkUDPRemoveAdvertise(bool blocking);

void NetworkUDPClose();