Merge lp:~widelands-dev/widelands/net-relay into lp:widelands

[Notabilis]

When running an Internet game, do not use a local server but relay all traffic over the metaserver.
Avoids problems with firewalls and NAT.

Finally: Ready for review!
When running an Internet game, do not use a local host but relay all traffic over the metaserver, avoiding problems with firewalls and routers/NAT.
Probably best start reviewing the code with src/network/relay_protocol.h for an overview how it works.

This change does not affect build19 clients. Those are still required to host a game locally.

Merge this together with deploying the metaserver version at:
https://github.com/widelands/widelands_metaserver/pull/12

This branch is not quite ready for merge yet: I am waiting for the net-uuid branch to continue the increasing protocol version numbers. Technically it would also be possible to merge this one first and adapt the version numbers in the other branch. Setting the version in this branch is required anyway.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2443. State: failed. Details: https://travis-ci.org/widelands/widelands/builds/254133988.
Appveyor build 2269. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_net_relay-2269.

[GunChleoc (gunchleoc)]

The protocol looks good to me.

There is no description of how the relay server get shut down yet, either in game end or when host and clients disappear without telling the relay about it.

I'd add a note to RLYCMD_TO_HOST that it's identical to RLYCMD_TO_CLIENT etc., to make the documentation easier to read.

There are also a bunch of commented out braces.

[Notabilis (notabilis27)]

Thanks for looking over it!

A command to shutdown the server is really missing, I haven't thought about that one. I think there should be a (long) timeout until automated shutdown when all players disconnect, just in case the shutdown-message does not arrive. Since the game can't work without the host, we could simply interpret the (planned) disconnect message of the host as a shutdown command.

With "identical" you mean the same enum-value? That is actually a bug, good catch. Is fixed in my local file now.
Assuming with the braces you mean the ///\{ and ///\} : This is intentional. With doxygen this leads to grouping of methods. The /** command */ in front of them is the description of the group.

[GunChleoc (gunchleoc)]

1 comment regarding naming conventions.

I'd also have some minor phrasing/English language nits, but I'll keep those for the final code review when the branch is done.

[SirVer (sirver)]

Notabilis, could you give us an update on your work? I am quite curious. Are you blocked in any way?

[Notabilis (notabilis27)]

Sorry for the long silence, I should have written much earlier. My primary problem is lack of time, but when I can work on it its going well enough. I fear I won't be able to work on it in the next two weeks but hopefully I have more time afterwards.

Thanks for the comments regarding the protocol, it should be all fixed now. I also changed some more things while working on the implementation.
First (alpha-) versions of the relay server and the game connections have been implemented. The current state is pushed here and on GitHub. I haven't tested it yet but it compiles and the general design should be recognizable. If you want to comment on it, go ahead. My next step will probably be to try to run a game over the relay (and fix all the bugs that come up...).

As a high-level overview:

- The relay server is one process which creates a Game object for each running game. New connections are all to the same port. Based on their first message (containing the game name) they are distributed between the running games.

- I extracted a NetHostInterface/NetClientInterface from the NetHost/NetClient classes. These interfaces are also implemented by NetHostProxy/NetHostClient. For LAN games the old NetHost/NetClient classes are instantiated, for internet games the *Proxy classes are used. These pack all packets and actions (e.g. (dis-)connects) as described in relay_protocol.h and sent them over a single connection to the relay server. There they are forwarded to the other participants of the respective game. This way, the GameHost/GameClient classes do not have to care whether it is an internet or a local game.

What is currently missing is the integration with the metaserver. When a player wants to start a new game the metaserver has to order the relay to create the respective game and tell the host about ip/port/host-password of it. After the host connected, the metaserver can announce the game in the lobby for other clients to join.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2557. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/265326001.
Appveyor build 2269. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_net_relay-2269.

[GunChleoc (gunchleoc)]

Good to hear that it's going well whenever you have the time :)

[SirVer (sirver)]

Thanks for the update! I just was curious if you are blocked. Do you want a review now? Otherwise I'd defer reviewing until you have something mergable.

Also, if some of the refactorings you did can be done beforhand in a smaller merge request, that would be very useful.

[Notabilis (notabilis27)]

If you want to say something about the design, go ahead. Looking at the details isn't worthwhile yet.

Okay, I will try to create a smaller merge when I am done.

[Notabilis (notabilis27)]

I just pushed the first "working" version of the relay server. Working as in: Everything hardcoded (IPs, name of the game, ...), but relaying game packets works and I was able to run a game.

One question where I would like some opinion: Currently the metaserver tells the client where to connect to (i.e. the IP and port of the relay). Do we need/want this flexibility or do we simply use hardcoded values in the client? It will probably always (?) be the IP of the metaserver and some fixed port number.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2667. State: failed. Details: https://travis-ci.org/widelands/widelands/builds/275219903.
Appveyor build 2488. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_net_relay-2488.

[GunChleoc (gunchleoc)]

As a matter of principle, I am against hard coding where it can be avoided without too much trouble. There could conceivably be multiple game servers in the future.

[Notabilis (notabilis27)]

Okay, thanks. Than I will implement the dynamic version.

[Notabilis (notabilis27)]

So much for: "[Prequisite branches] changes will not be shown in the diff."
The changes to NetHost, NetClient and the new interface classes are also at:
https://code.launchpad.net/~widelands-dev/widelands/nethost-split/+merge/332385

Maybe they will disappear from the diff here after the other branch is merged into trunk.

[SirVer (sirver)]

This merge request tripped up bunnybot because the number of comments went down when it was reopened. The bug is fixed now, so other branches should now get merged as normal again.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2765. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/297537925.
Appveyor build 2577. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_net_relay-2577.

[SirVer (sirver)]

Finally reviewed this! I left a few comments in the code using NOCOM as markers.

Really nice work. The structure is understandable and the feature is an absolute killer! Thanks for working on this.

[GunChleoc (gunchleoc)]

@SirVer: You forgot to push

[SirVer (sirver)]

indeed, done now.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2832. State: failed. Details: https://travis-ci.org/widelands/widelands/builds/306718329.
Appveyor build 2642. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_net_relay-2642.

[Notabilis (notabilis27)]

Thanks for the review. I have a few questions regarding your NOCOMs, though.

> You can and should use std::piecewise_construct here and get rid of the default constructor for client

I guess you mean something like (not working):
 clients_.emplace(std::piecewise_construct, id, Client::State::kConnecting);
So instead of the default constructor I will have one taking the state of the argument? That could also be achieved by
 clients_.emplace(id, Client::State::kConnecting);
I don't really see why I should get rid of the default constructor, and I guess you mean something else.

> It would be nice to get syncstream data into this somehow to make it easier to debug desyncs going forward.

What exactly do you mean with this? Writing all transfered data to the syncstream? Only the commands/headers? Or just when errors occur? Desyncs are something which does not (or at least: should not) matter on this layer, the relay is happily transmitting even useless data.

> It would be nice to always get a kPong on a kPing ...

Can do so, no problem. Actually, that is what happening already (but pings are not always send). Currently, the pings are only used for the game host and not for the clients. Do you want to have pings for all participants? Kicking out slow clients is a feature I see as a responsibility of the "higher" layers, i.e., the GameHost class, and nothing done by the relay.

[SirVer (sirver)]

I numbered the points for easier reference:

> 1) I changed the code to my suggestion. Please revert if you disagree.

> 2) It would be nice to get syncstream data into this somehow to make it easier to debug desyncs going forward.

Sorry, that was initial excitement while reviewing, it doesn't really belong in this code review. My thoughts on this topic are not coherent yet, so I have no clear design in mind. I pulled what I have so far out into a separate bug and removed the comment.

[1] https://bugs.launchpad.net/widelands/+bug/1734671

> 3) Ping/Pong

I agree that the relay should not auto-kick users. But it is uniquely positioned to determine the actual ping values that affect gameplay. So I think it should regularly inform the players (or at least the host) how the ping to the different players is. For this a regular ping (once every 5-10 seconds) to all players would be valuable.

I pulled out a bug to design the feature: https://bugs.launchpad.net/widelands/+bug/1734673. Of course Widelands site changes and UI are not part of this MR, but I suggest to implement the regular ping for all players directly.

[Notabilis (notabilis27)]

1) Thanks, looks good. Not that I really understand this construct.

2) Okay. Seems to be worth looking into that, but not in this branch.

3) I added a simple protocol for this. Please see relay_protocol.h (diff line 1918ff) for the design, it should us allow what we want to do. Metaserver support is missing for it, when you approve of the design I will add it there, too. Adding the RTT-display-/kicking-GUI should be a Widelands-only change later on.

4) A still open NOCOM is regarding the move-constructor of RecvPacket. The problem is that this class extends the (old) class StreamRead, which removes the copy-constructor explicitly. We could remove this declaration but it is probably there for a reason. So I guess it is either move operations or ... no real idea.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2891. State: errored. Details: https://travis-ci.org/widelands/widelands/builds/309199942.
Appveyor build 2700. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_net_relay-2700.

[SirVer (sirver)]

I added a few more NOCOMs again, sorry :(.

3) That design looks sufficient for what I had in mind. It is also nicely minimal. Good job!

4) Here is my suggestion:

- Change bool try_receive(RecvPacket*) to std::unique_ptr<RecvPacket> try_receive(), with nullptr being what false was before.
- The various std::deque<RecvPacket> received_ can now become std::deque<unique_ptr<RecvPacket>> - which makes them even cheaper.
- You can delete the move operator/constructor in RecvPacket

This has also the advantage that you communicate clearly that a RecvPacket never changes. The move operator makes it look like you sometimes move partially read packets - but you never do as far as I can tell.

[Notabilis (notabilis27)]

With such a great commit message you can give me as much NOCOMs as you want. ;)

4) I implemented your suggestion, but I am not completely happy with it. The move constructors are gone but there are still a few of the evil std::move in the code. Decide for yourself, I guess. I could get rid of them by storing raw pointers in the received_ queue but I am not such a fan of the idea.

5) I made the NOCOM regarding the duplicated code to a TODO note. Pulling out a method should be done but I don't know where to put it right now. I guess some place will present itself when the feature is added for real.

NOCOMs are all done (for now...).

[SirVer (sirver)]

4) I disagree. I think it looks wonderful! You only need std::move() to signalize that you move the front() of your queue and leave an empty vector - and without it, the code would read like a copy at this site. So the move adds readability. All in all the code now looks like I would expect it to.

5) Pull the function to somewhere, it doesn't matter much. Either in the one of the units where it is used and include the header from the other. Or one that is used by both. Reducing duplicated code is more important than finding the right place for the function IMHO. Please, for me? Pretty please?

[Notabilis (notabilis27)]

5) Since you asked that nicely, I did it, just for you. :)

On a side note: The last commits have not been tested yet, will do so when I am done with the metaserver.

[SirVer (sirver)]

Had another look over the code just now. LGTM! As soon as the metaserver branch is ready, this can go in.

What a great change! Thanks for working on this Notabilis!

review: Approve

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2907. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/310195149.
Appveyor build 2716. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_net_relay-2716.

[Notabilis (notabilis27)]

It turns out that the kRoundTripTimeResponse can't work as plant. It is returning the player IDs as seen by the relay, which are something different than the player IDs in the GameHost/Client code. The relay IDs are fine for the GameHost (who has the mapping) but of no use for GameClients. Answering ping messages is fine for both. So we could:

a) Only display the ping times at the GameHost. Should probably be fine since it is the only one who
is permitted to kick participants anyway.
b) Make the GameHost deliver the ping results to the GameClients. So the relay collects the data, the GameHost retrieves them and the GameClients can ask the GameHost about it. Kind of complicated but probably a cleaner design than c). The GameHost/GameClient exchange can be done in a later branch. (a and b result in the same code in this branch.)
c) Give the relay more information about the connected participants so it can use the GameHost/Client-IDs when returning ping results.
d) Do something great I haven't come up with yet.

Which one do you prefer?

[SirVer (sirver)]

I am on business travel and therefore slow to respond.

> It is returning the player IDs as seen by the relay, which are something different than the player IDs in the GameHost/Client code.

I think these IDs should stay private to Widelands and the metaserver/relay respectively. Instead when they need to communicate about a particular player, they should send the player id as string - and map them internally to their ids.

Is this ready for another review round? What about the metaserver branch?

[Notabilis (notabilis27)]

No problem, I am in no hurry.

Seems I was a bit unclear in my previous post, sorry.
These IDs are only used between the relay and the game host. The ID is created when a new client connects to the relay and announced to the host. Later messages of the client are prepended with this ID and passed on to the host. This way, we have multiple virtual network connections multiplexed about a single connection between host and relay. In the GameHost class the host can map between this "connections" (can be real connections in LAN games) and the state of the clients. The IDs are only used to number these connections, inside the GameHost class other IDs are used to number the participants of the game. So I guess this works as you want.
For the clients this mapping does not exist since they don't have to care about other clients; the game state is always send by the game host. Due to this the IDs that can be send by the relay are useless.
Currently the ID is transmitted as a single byte but I can change this to a string if you insist. (When I think about it: using a byte means that the relay has to restrict the number of participants in a game to 250. I have to check this.)

There are (at least) two problems with the pings currently:

1) Internet gaming: The relay/host IDs are useless for the client. For possible solutions see post above.

2) LAN gaming: We have no network protocol here, so no pings. When communicating with the relay, the game data packets are prepended with information regarding the intended receiver. In LAN games this is not required so the packets are send "raw". This means that we can't simply add pings on the level of the NetHost/NetClient connection but have to add them to the GameHost/GameClient layer. So for internet gaming we get our ping results from the NetHostProxy (and that from the relay) while in LANs the (higher layer) GameHost has to send the pings. I don't like it (mixing the layer responsibilities). However, if we do it that way, I am in favor of variant b) in the post above, since then we have no problems with the IDs and (at least for GameClients) the same ping-code for internet and LAN games.

Apart from this RTT/ID problem, both branches are ready for review.

[SirVer (sirver)]

> For the clients this mapping does not exist since they don't have to care about other clients; the game state is always send by the game host.

Okay, now I got it. using a string as identifier for all packets is not wise, since packets can be small and would grow in size tremendously though this. So I think we stick with the current design and only the host knows the ping times.

> (When I think about it: using a byte means that the relay has to restrict the number of participants in a game to 250. I have to check this.)

This seems sufficient. We must keep in mind that we multiplex the bandwith of our net-relay too with the number of connections.

1) I understood now. Let's keep this information between host and net-relay for now then. We can always expand the protocol later to get this information to every connected entity.

2) I am of the opinion that the net-relay should be internet only and LAN play should not be touched. There is really no advantage in LAN for the relay, also LAN play is these days probably a rarely used feature - so much so that basically no commercial game supports it anymore.

I take that the code is now ready for a final pass. I will try to do this this weekend.

[SirVer (sirver)]

Actually, that was easy. This code lgtm. Will review the metaserver soon.

[SirVer (sirver)]

@bunnybot merge

review: Approve

=== modified file 'src/network/CMakeLists.txt'
--- src/network/CMakeLists.txt	2017-11-25 20:29:26 +0000
+++ src/network/CMakeLists.txt	2017-12-05 20:38:52 +0000
@@ -15,9 +15,15 @@
     netclient_interface.h
     netclient.cc
     netclient.h
+    netclientproxy.cc
+    netclientproxy.h
     nethost_interface.h
     nethost.cc
     nethost.h
+    nethostproxy.cc
+    nethostproxy.h
+    netrelayconnection.cc
+    netrelayconnection.h
     network.cc
     network.h
     network_gaming_messages.cc
@@ -27,6 +33,7 @@
     network_player_settings_backend.cc
     network_player_settings_backend.h
     network_protocol.h
+    relay_protocol.h
   DEPENDS
     ai
     base_exceptions
 
=== modified file 'src/network/gameclient.cc'
--- src/network/gameclient.cc	2017-11-05 19:59:33 +0000
+++ src/network/gameclient.cc	2017-12-05 20:38:52 +0000
@@ -41,6 +41,8 @@
 #include "logic/playersmanager.h"
 #include "map_io/widelands_map_loader.h"
 #include "network/internet_gaming.h"
+#include "network/netclient.h"
+#include "network/netclientproxy.h"
 #include "network/network_gaming_messages.h"
 #include "network/network_protocol.h"
 #include "scripting/lua_interface.h"
@@ -58,7 +60,7 @@
 
 	std::string localplayername;
 
-	std::unique_ptr<NetClient> net;
+	std::unique_ptr<NetClientInterface> net;
 
 	/// Currently active modal panel. Receives an end_modal on disconnect
 	UI::Panel* modal;
@@ -91,13 +93,22 @@
 
 GameClient::GameClient(const std::pair<NetAddress, NetAddress>& host,
                        const std::string& playername,
-                       bool internet)
+                       bool internet, const std::string& gamename)
    : d(new GameClientImpl), internet_(internet) {
 
-	d->net = NetClient::connect(host.first);
+	if (internet) {
+		assert(!gamename.empty());
+		d->net = NetClientProxy::connect(host.first, gamename);
+	} else {
+		d->net = NetClient::connect(host.first);
+	}
 	if ((!d->net || !d->net->is_connected()) && host.second.is_valid()) {
 		// First IP did not work? Try the second IP
-		d->net = NetClient::connect(host.second);
+		if (internet) {
+			d->net = NetClientProxy::connect(host.first, gamename);
+		} else {
+			d->net = NetClient::connect(host.second);
+		}
 	}
 	if (!d->net || !d->net->is_connected()) {
 		throw WLWarning(_("Could not establish connection to host"),
@@ -877,9 +888,10 @@
 			return;
 		}
 		// Process all available packets
-		RecvPacket packet;
-		while (d->net->try_receive(&packet)) {
-			handle_packet(packet);
+		std::unique_ptr<RecvPacket> packet = d->net->try_receive();
+		while (packet) {
+			handle_packet(*packet);
+			packet = d->net->try_receive();
 		}
 	} catch (const DisconnectException& e) {
 		disconnect(e.what());
 
=== modified file 'src/network/gameclient.h'
--- src/network/gameclient.h	2017-11-27 21:21:06 +0000
+++ src/network/gameclient.h	2017-12-05 20:38:52 +0000
@@ -24,7 +24,7 @@
 #include "logic/game_controller.h"
 #include "logic/game_settings.h"
 #include "logic/player_end_result.h"
-#include "network/netclient.h"
+#include "network/netclient_interface.h"
 
 struct GameClientImpl;
 
@@ -39,7 +39,7 @@
 struct GameClient : public GameController, public GameSettingsProvider, public ChatProvider {
 	GameClient(const std::pair<NetAddress, NetAddress>& host,
 	           const std::string& playername,
-	           bool internet = false);
+			   bool internet = false, const std::string& gamename = "");
 
 	~GameClient() override;
 
 
=== modified file 'src/network/gamehost.cc'
--- src/network/gamehost.cc	2017-11-30 07:11:36 +0000
+++ src/network/gamehost.cc	2017-12-05 20:38:52 +0000
@@ -52,6 +52,7 @@
 #include "network/constants.h"
 #include "network/internet_gaming.h"
 #include "network/nethost.h"
+#include "network/nethostproxy.h"
 #include "network/network_gaming_messages.h"
 #include "network/network_lan_promotion.h"
 #include "network/network_player_settings_backend.h"
@@ -412,7 +413,7 @@
 	HostGameSettingsProvider hp;
 	NetworkPlayerSettingsBackend npsb;
 
-	LanGamePromoter* promoter;
+	std::unique_ptr<LanGamePromoter> promoter;
 	std::unique_ptr<NetHostInterface> net;
 
 	/// List of connected clients. Note that clients are not in the same
@@ -459,7 +460,7 @@
 	     chat(h),
 	     hp(h),
 	     npsb(&hp),
-	     promoter(nullptr),
+	     promoter(),
 	     net(),
 	     game(nullptr),
 	     pseudo_networktime(0),
@@ -480,21 +481,30 @@
    : d(new GameHostImpl(this)), internet_(internet), forced_pause_(false) {
 	log("[Host]: starting up.\n");
 
-	if (internet) {
-		InternetGaming::ref().open_game();
-	}
-
 	d->localplayername = playername;
 
 	// create a listening socket
-	d->net = NetHost::listen(kWidelandsLanPort);
-	if (d->net == nullptr) {
-		// This might happen when the widelands socket is already in use
-		throw WLWarning(_("Failed to start the server!"),
-		                _("Widelands could not start a server.\n"
-		                  "Probably some other process is already running a server on our port."));
+	if (internet) {
+		// No real listening socket. Instead, connect to the relay server
+		d->net = NetHostProxy::connect(InternetGaming::ref().ips(),
+						InternetGaming::ref().get_local_servername(), InternetGaming::ref().relay_password());
+		if (d->net == nullptr) {
+			// Some kind of problem with the relay server. Bad luck :(
+			throw WLWarning(_("Failed to host the server!"),
+							_("Widelands could not start hosting a server.\n"
+							  "This should not happen and there is most likely "
+							  "nothing you can do about it. Please report a bug."));
+		}
+	} else {
+		d->net = NetHost::listen(kWidelandsLanPort);
+		if (d->net == nullptr) {
+			// This might happen when the widelands socket is already in use
+			throw WLWarning(_("Failed to start the server!"),
+							_("Widelands could not start a server.\n"
+							  "Probably some other process is already running a server on our port."));
+		}
+		d->promoter.reset(new LanGamePromoter());
 	}
-	d->promoter = new LanGamePromoter();
 	d->game = nullptr;
 	d->pseudo_networktime = 0;
 	d->waiting = true;
@@ -525,7 +535,7 @@
 
 	// close all open sockets
 	d->net.reset();
-	delete d->promoter;
+	d->promoter.reset();
 	delete d;
 	delete file_;
 }
@@ -941,8 +951,12 @@
 
 	// if there is one client that is currently receiving a file, we can not launch.
 	for (std::vector<Client>::iterator j = d->clients.begin(); j != d->clients.end(); ++j) {
-		if (!d->settings.users[j->usernum].ready)
-			return false;
+		if (j->usernum == -1) {
+			return false;
+		}
+		if (!d->settings.users[j->usernum].ready) {
+			return false;
+		}
 	}
 
 	// all players must be connected to a controller (human/ai) or be closed.
@@ -1896,8 +1910,9 @@
 
 void GameHost::handle_network() {
 
-	if (d->promoter != nullptr)
+	if (d->promoter) {
 		d->promoter->run();
+	}
 
 	// Check for new connections.
 	Client peer;
@@ -1929,11 +1944,12 @@
 	}
 
 	// Check if we hear anything from our clients
-	RecvPacket packet;
 	for (size_t i = 0; i < d->clients.size(); ++i) {
 		try {
-			while (d->net->try_receive(d->clients.at(i).sock_id, &packet)) {
-				handle_packet(i, packet);
+			std::unique_ptr<RecvPacket> packet = d->net->try_receive(d->clients.at(i).sock_id);
+			while (packet) {
+				handle_packet(i, *packet);
+				packet = d->net->try_receive(d->clients.at(i).sock_id);
 			}
 			// Thrown by handle_packet()
 		} catch (const DisconnectException& e) {
 
=== modified file 'src/network/internet_gaming.cc'
--- src/network/internet_gaming.cc	2017-11-26 20:55:56 +0000
+++ src/network/internet_gaming.cc	2017-12-05 20:38:52 +0000
@@ -43,7 +43,7 @@
    : net(nullptr),
      state_(OFFLINE),
      reg_(false),
-     port_(INTERNET_GAMING_PORT),
+     port_(kInternetGamingPort),
      clientrights_(INTERNET_CLIENT_UNREGISTERED),
      gameips_(),
      clientupdateonmetaserver_(true),
@@ -68,7 +68,7 @@
 	authenticator_ = "";
 	reg_ = false;
 	meta_ = INTERNET_GAMING_METASERVER;
-	port_ = INTERNET_GAMING_PORT;
+	port_ = kInternetGamingPort;
 	clientname_ = "";
 	clientrights_ = INTERNET_CLIENT_UNREGISTERED;
 	gamename_ = "";
@@ -152,7 +152,7 @@
 	log("InternetGaming: Sending login request.\n");
 	SendPacket s;
 	s.string(IGPCMD_LOGIN);
-	s.string(boost::lexical_cast<std::string>(INTERNET_GAMING_PROTOCOL_VERSION));
+	s.string(boost::lexical_cast<std::string>(kInternetGamingProtocolVersion));
 	s.string(clientname_);
 	s.string(build_id());
 	s.string(bool2str(reg_));
@@ -162,7 +162,7 @@
 	// Now let's see, whether the metaserver is answering
 	uint32_t const secs = time(nullptr);
 	state_ = CONNECTING;
-	while (INTERNET_GAMING_TIMEOUT > time(nullptr) - secs) {
+	while (kInternetGamingTimeout > time(nullptr) - secs) {
 		handle_metaserver_communication();
 		// Check if we are a step further... if yes handle_packet has taken care about all the
 		// paperwork, so we put our feet up and just return. ;)
@@ -274,9 +274,9 @@
 				return;
 			}
 			// Process all available packets
-			RecvPacket packet;
-			if (net->try_receive(&packet)) {
-				handle_packet(packet);
+			std::unique_ptr<RecvPacket> packet = net->try_receive();
+			if (packet) {
+				handle_packet(*packet);
 			} else {
 				// Nothing more to receive
 				break;
@@ -356,7 +356,7 @@
 	// Okay, we have a connection. Send the login message and terminate the connection
 	SendPacket s;
 	s.string(IGPCMD_TELL_IP);
-	s.string(boost::lexical_cast<std::string>(INTERNET_GAMING_PROTOCOL_VERSION));
+	s.string(boost::lexical_cast<std::string>(kInternetGamingProtocolVersion));
 	s.string(clientname_);
 	s.string(authenticator_);
 	tmpNet->send(s);
@@ -581,6 +581,15 @@
 			if (waitcmd_ == IGPCMD_GAME_OPEN) {
 				waitcmd_ = "";
 			}
+			// Save the received IP(s), so the client can connect to the game
+			NetAddress::parse_ip(&gameips_.first, packet.string(), kInternetRelayPort);
+			// If the next value is true, a secondary IP follows
+			if (packet.string() == bool2str(true)) {
+				NetAddress::parse_ip(&gameips_.second, packet.string(), kInternetRelayPort);
+			}
+			log("InternetGaming: Received ips of the relay to host: %s %s.\n",
+			    gameips_.first.ip.to_string().c_str(), gameips_.second.ip.to_string().c_str());
+			state_ = IN_GAME;
 		}
 
 		else if (cmd == IGPCMD_GAME_CONNECT) {
@@ -588,10 +597,10 @@
 			assert(waitcmd_ == IGPCMD_GAME_CONNECT);
 			waitcmd_ = "";
 			// Save the received IP(s), so the client can connect to the game
-			NetAddress::parse_ip(&gameips_.first, packet.string(), kWidelandsLanPort);
+			NetAddress::parse_ip(&gameips_.first, packet.string(), kInternetRelayPort);
 			// If the next value is true, a secondary IP follows
 			if (packet.string() == bool2str(true)) {
-				NetAddress::parse_ip(&gameips_.second, packet.string(), kWidelandsLanPort);
+				NetAddress::parse_ip(&gameips_.second, packet.string(), kInternetRelayPort);
 			}
 			log("InternetGaming: Received ips of the game to join: %s %s.\n",
 			    gameips_.first.ip.to_string().c_str(), gameips_.second.ip.to_string().c_str());
@@ -648,11 +657,18 @@
 	return gameips_;
 }
 
+const std::string InternetGaming::relay_password() {
+	return authenticator_;
+}
+
 /// called by a client to join the game \arg gamename
 void InternetGaming::join_game(const std::string& gamename) {
 	if (!logged_in())
 		return;
 
+	// Reset the game ips, we should receive new ones shortly
+	gameips_ = std::make_pair(NetAddress(), NetAddress());
+
 	SendPacket s;
 	s.string(IGPCMD_GAME_CONNECT);
 	s.string(gamename);
@@ -663,7 +679,7 @@
 
 	// From now on we wait for a reply from the metaserver
 	waitcmd_ = IGPCMD_GAME_CONNECT;
-	waittimeout_ = time(nullptr) + INTERNET_GAMING_TIMEOUT;
+	waittimeout_ = time(nullptr) + kInternetGamingTimeout;
 }
 
 /// called by a client to open a new game with name gamename_
@@ -671,17 +687,19 @@
 	if (!logged_in())
 		return;
 
+	// Reset the game ips, we should receive new ones shortly
+	gameips_ = std::make_pair(NetAddress(), NetAddress());
+
 	SendPacket s;
 	s.string(IGPCMD_GAME_OPEN);
 	s.string(gamename_);
 	s.string("1024");  // Used to be maxclients, no longer used.
 	net->send(s);
 	log("InternetGaming: Client opened a game with the name %s.\n", gamename_.c_str());
-	state_ = IN_GAME;
 
 	// From now on we wait for a reply from the metaserver
 	waitcmd_ = IGPCMD_GAME_OPEN;
-	waittimeout_ = time(nullptr) + INTERNET_GAMING_TIMEOUT;
+	waittimeout_ = time(nullptr) + kInternetGamingTimeout;
 }
 
 /// called by a client that is host of a game to inform the metaserver, that the game started
@@ -696,7 +714,7 @@
 
 	// From now on we wait for a reply from the metaserver
 	waitcmd_ = IGPCMD_GAME_START;
-	waittimeout_ = time(nullptr) + INTERNET_GAMING_TIMEOUT;
+	waittimeout_ = time(nullptr) + kInternetGamingTimeout;
 }
 
 /// called by a client to inform the metaserver, that it left the game and is back in the lobby.
 
=== modified file 'src/network/internet_gaming.h'
--- src/network/internet_gaming.h	2017-11-26 20:55:56 +0000
+++ src/network/internet_gaming.h	2017-12-05 20:38:52 +0000
@@ -101,10 +101,17 @@
 	 * Contains two addresses when the host supports IPv4 and IPv6, one address when the host
 	 * only supports one of the protocols, no addresses when no join-request was sent to
 	 * the metaserver. "No address" means a default constructed address.
+	 * Also returns the IPs of the relay server when trying to host a game.
 	 * Use NetAddress::is_valid() to check whether a NetAddress has been default constructed.
 	 * @return The addresses.
 	 */
 	const std::pair<NetAddress, NetAddress>& ips();
+
+	/**
+	 * Returns the password required to connect to the relay server as host.
+	 */
+	const std::string relay_password();
+
 	void join_game(const std::string& gamename);
 	void open_game();
 	void set_game_playing();
 
=== modified file 'src/network/internet_gaming_protocol.h'
--- src/network/internet_gaming_protocol.h	2017-11-26 20:55:56 +0000
+++ src/network/internet_gaming_protocol.h	2017-12-05 20:38:52 +0000
@@ -34,46 +34,34 @@
  * 0: Build 19 and before [stable, supported]
  * 1: Between build 19 and build 20 - IPv6 support added
  * 2: Between build 19 and build 20 - Added UUID to allow reconnect with same username after
- * crashes.
- *                                    When logging twice with a registered account, the second
- * connection
- *                                    gets a free username assigned. Dropping RELOGIN command.
- * [supported]
- */
-#define INTERNET_GAMING_PROTOCOL_VERSION 2
-
-/**
- * The default timeout time after which the client tries to resend a package or even finally closes
- * the
- * connection to the metaserver, if no answer to a previous package (which requires an answer) was
- * received. In case of a login or reconnect, this is the time to wait for the metaservers answer.
- *
- * value is in milliseconds
- */
-// TODO(unknown): Should this be resettable by the user?
-#define INTERNET_GAMING_TIMEOUT 10  // 10 seconds
-
-/**
- * The default timeout time after which the client tries to resend a package or even finally closes
- * the
- * connection to the metaserver, if no answer to a previous package (which requires an answer) was
- * received. In case of a login or reconnect, this is the time to wait for the metaservers answer.
- *
- * value is in milliseconds
- */
-// TODO(unknown): Should this be resettable by the user?
-#define INTERNET_GAMING_CLIENT_TIMEOUT 60  // 60 seconds - some time to reconnect
-
-/**
- * The default number of retries after a timeout after which the client finally closes the
- * connection to the metaserver.
- */
-// TODO(unknown): Should this be resettable by the user?
-#define INTERNET_GAMING_RETRIES 3
+ *    crashes. When logging twice with a registered account, the second connection gets a free
+ *     username assigned. Dropping RELOGIN command.
+ * 3: Between build 19 and build 20 - Added network relay for internet games [supported]
+ */
+constexpr unsigned int kInternetGamingProtocolVersion = 3;
+
+/**
+ * The default timeout time after which the client tries to resend a package or even finally closes
+ * the
+ * connection to the metaserver, if no answer to a previous package (which requires an answer) was
+ * received. In case of a login or reconnect, this is the time to wait for the metaservers answer.
+ *
+ * value is in milliseconds
+ */
+// TODO(unknown): Should this be resettable by the user?
+constexpr time_t kInternetGamingTimeout = 10;  // 10 seconds
 
 /// Metaserver connection details
 static const std::string INTERNET_GAMING_METASERVER = "widelands.org";
-#define INTERNET_GAMING_PORT 7395
+// Default port for connecting to the metaserver
+constexpr uint16_t kInternetGamingPort = 7395;
+// Default port for connecting to the relay
+constexpr uint16_t kInternetRelayPort = 7397;
+// The following ones are only used between metaserver and relay
+// Port used by the metaserver to contact the relay
+// INTERNET_RELAY_RPC_PORT 7398
+// Port used by the relay to contact the metaserver
+// INTERNET_GAMING_RPC_PORT 7399
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * CLIENT RIGHTS                                                           *
@@ -183,7 +171,7 @@
  *                used.)
  * \li string:    clients rights  (see client rights section above)
  *
- * If no answer is received in \ref INTERNET_GAMING_TIMEOUT s the client will again try to login
+ * If no answer is received in \ref kInternetGamingTimeout s the client will again try to login
  * \ref INTERNET_GAMING_RETRIES times until it finally bails out something like "server does not
  * answer"
  *
@@ -337,12 +325,13 @@
  * \li string:    number of maximal clients
  * \note build_id is not necessary, as this is in every way the build_id of the hosting client.
  *
- * Sent by the metaserver to acknowledge the startup of a new game without payload. The metaserver
- * will
- * list the new game, but set it as not connectable and recheck the connectability for
- * INTERNET_GAMING_TIMEOUT ms.
- * If the game gets connectable in time, the metaserver lists the game as connectable, else it
- * removes the game from the list of games.
+ * Sent by the metaserver to acknowledge the startup of a new game with the following payload:
+ * \li string:    primary ip of relay server for the game.
+ * \li string:    whether a secondary ip for the relay follows ("true" or "false" as string)
+ * \li string:    secondary ip of the relay - only valid if previous was true
+ * The metaserver will list the new game, but set it as not connectable.
+ * When the client connects to the relay within kInternetGamingTimeout milliseconds,
+ * the metaserver lists the game as connectable, else it removes the game from the list of games.
  */
 static const std::string IGPCMD_GAME_OPEN = "GAME_OPEN";
 
 
=== modified file 'src/network/netclient.cc'
--- src/network/netclient.cc	2017-07-22 22:09:20 +0000
+++ src/network/netclient.cc	2017-12-05 20:38:52 +0000
@@ -51,7 +51,7 @@
 	socket_.close(ec);
 }
 
-bool NetClient::try_receive(RecvPacket* packet) {
+std::unique_ptr<RecvPacket> NetClient::try_receive() {
 	if (is_connected()) {
 		// If we are connected, try to receive some data
 
@@ -72,7 +72,12 @@
 		}
 	}
 	// Try to get one packet from the deserializer
-	return deserializer_.write_packet(packet);
+	std::unique_ptr<RecvPacket> packet(new RecvPacket);
+	if (deserializer_.write_packet(packet.get())) {
+		return packet;
+	} else {
+		return std::unique_ptr<RecvPacket>();
+	}
 }
 
 void NetClient::send(const SendPacket& packet) {
@@ -81,21 +86,20 @@
 	}
 
 	boost::system::error_code ec;
-#ifdef NDEBUG
-	boost::asio::write(socket_, boost::asio::buffer(packet.get_data(), packet.get_size()), ec);
-#else
 	size_t written =
 	   boost::asio::write(socket_, boost::asio::buffer(packet.get_data(), packet.get_size()), ec);
-#endif
 
-	// TODO(Notabilis): This one is an assertion of mine, I am not sure if it will hold
-	// If it doesn't, set the socket to blocking before writing
-	// If it does, remove this comment after build 20
-	assert(ec != boost::asio::error::would_block);
-	assert(written == packet.get_size() || ec);
+	if (ec == boost::asio::error::would_block) {
+		throw wexception("[NetClient] Socket connected to relay would block when writing");
+	}
 	if (ec) {
 		log("[NetClient] Error when trying to send some data: %s.\n", ec.message().c_str());
 		close();
+		return;
+	}
+	if (written < packet.get_size()) {
+		throw wexception("[NetClient] Unable to send complete packet to relay (only %lu bytes of %lu)",
+						written, packet.get_size());
 	}
 }
 
 
=== modified file 'src/network/netclient.h'
--- src/network/netclient.h	2017-11-27 21:21:06 +0000
+++ src/network/netclient.h	2017-12-05 20:38:52 +0000
@@ -53,7 +53,7 @@
 	// Inherited from NetClientInterface
 	bool is_connected() const override;
 	void close() override;
-	bool try_receive(RecvPacket* packet) override;
+	std::unique_ptr<RecvPacket> try_receive() override;
 	void send(const SendPacket& packet) override;
 
 private:
 
=== modified file 'src/network/netclient_interface.h'
--- src/network/netclient_interface.h	2017-10-31 03:50:46 +0000
+++ src/network/netclient_interface.h	2017-12-05 20:38:52 +0000
@@ -54,12 +54,10 @@
 
 	/**
 	 * Tries to receive a packet.
-	 * \param packet A packet that should be overwritten with the received data.
-	 * \return \c true if a packet is available, \c false otherwise.
-	 *   The given packet is only modified when \c true is returned.
-	 *   Calling this on a closed connection will return false.
+	 * \return A pointer to a packet if one packet is available, an invalid pointer otherwise.
+	 *   Calling this on a closed connection will return an invalid pointer.
 	 */
-	virtual bool try_receive(RecvPacket* packet) = 0;
+	virtual std::unique_ptr<RecvPacket> try_receive() = 0;
 
 	/**
 	 * Sends a packet.
 
=== added file 'src/network/netclientproxy.cc'
--- src/network/netclientproxy.cc	1970-01-01 00:00:00 +0000
+++ src/network/netclientproxy.cc	2017-12-05 20:38:52 +0000
@@ -0,0 +1,165 @@
+#include "network/netclientproxy.h"
+
+#include <memory>
+
+#include "base/log.h"
+#include "network/relay_protocol.h"
+
+std::unique_ptr<NetClientProxy> NetClientProxy::connect(const NetAddress& address, const std::string& name) {
+	std::unique_ptr<NetClientProxy> ptr(new NetClientProxy(address, name));
+	if (ptr->conn_ == nullptr || !ptr->conn_->is_connected()) {
+		ptr.reset();
+	}
+	return ptr;
+}
+
+NetClientProxy::~NetClientProxy() {
+	close();
+}
+
+
+bool NetClientProxy::is_connected() const {
+	return conn_ && conn_->is_connected();
+}
+
+void NetClientProxy::close() {
+	if (conn_ && conn_->is_connected()) {
+		conn_->close();
+	}
+}
+
+std::unique_ptr<RecvPacket> NetClientProxy::try_receive() {
+	receive_commands();
+
+	// Now check whether there is data
+	if (received_.empty()) {
+		return std::unique_ptr<RecvPacket>();
+	}
+
+	std::unique_ptr<RecvPacket> packet = std::move(received_.front());
+	received_.pop();
+	return packet;
+}
+
+void NetClientProxy::send(const SendPacket& packet) {
+	conn_->send(RelayCommand::kToHost);
+	conn_->send(packet);
+}
+
+NetClientProxy::NetClientProxy(const NetAddress& address, const std::string& name)
+	: conn_(NetRelayConnection::connect(address)) {
+   	if (conn_ == nullptr || !conn_->is_connected()) {
+		   return;
+	   }
+
+   	conn_->send(RelayCommand::kHello);
+   	conn_->send(kRelayProtocolVersion);
+   	conn_->send(name);
+   	conn_->send("client");
+
+   	// Wait 10 seconds for an answer
+	uint32_t endtime = time(nullptr) + 10;
+	while (!NetRelayConnection::Peeker(conn_.get()).cmd()) {
+		if (time(nullptr) > endtime) {
+			// No message received in time
+			conn_->close();
+			conn_.reset();
+			return;
+		}
+	}
+
+	RelayCommand cmd;
+	conn_->receive(&cmd);
+
+   	if (cmd != RelayCommand::kWelcome) {
+		conn_->close();
+		conn_.reset();
+		return;
+   	}
+
+   	// Check version
+   	endtime = time(nullptr) + 10;
+	while (!NetRelayConnection::Peeker(conn_.get()).uint8_t()) {
+		if (time(nullptr) > endtime) {
+			conn_->close();
+			conn_.reset();
+			return;
+		}
+	}
+	uint8_t relay_proto_version;
+	conn_->receive(&relay_proto_version);
+   	if (relay_proto_version != kRelayProtocolVersion) {
+		conn_->close();
+		conn_.reset();
+   	}
+
+   	// Check game name
+   	endtime = time(nullptr) + 10;
+	while (!NetRelayConnection::Peeker(conn_.get()).string()) {
+		if (time(nullptr) > endtime) {
+			conn_->close();
+			conn_.reset();
+			return;
+		}
+	}
+	std::string game_name;
+	conn_->receive(&game_name);
+   	if (game_name != name) {
+		conn_->close();
+		conn_.reset();
+		return;
+   	}
+}
+
+void NetClientProxy::receive_commands() {
+	if (!conn_->is_connected()) {
+		return;
+	}
+
+	// Receive all available commands
+	RelayCommand cmd;
+	NetRelayConnection::Peeker peek(conn_.get());
+	if (!peek.cmd(&cmd)) {
+		// No command to receive
+		return;
+	}
+	switch (cmd) {
+		case RelayCommand::kDisconnect:
+			if (peek.string()) {
+				// Command is completely in the buffer, handle it
+				conn_->receive(&cmd);
+				std::string reason;
+				conn_->receive(&reason);
+				// TODO(Notabilis): Handle the reason for the disconnect
+				conn_->close();
+			}
+			break;
+		case RelayCommand::kFromHost:
+			if (peek.recvpacket()) {
+				conn_->receive(&cmd);
+				std::unique_ptr<RecvPacket> packet(new RecvPacket);
+				conn_->receive(packet.get());
+			   received_.push(std::move(packet));
+		   }
+			break;
+		case RelayCommand::kPing:
+			if (peek.uint8_t()) {
+				conn_->receive(&cmd);
+				uint8_t seq;
+				conn_->receive(&seq);
+				// Reply with a pong
+				conn_->send(RelayCommand::kPong);
+				conn_->send(seq);
+			}
+			break;
+		case RelayCommand::kRoundTripTimeResponse:
+			conn_->ignore_rtt_response();
+			break;
+		default:
+			// Other commands should not be possible.
+			// Then is either something wrong with the protocol or there is an implementation mistake
+			log("Received command code %i from relay server, do not know what to do with it\n",
+					static_cast<uint8_t>(cmd));
+			NEVER_HERE();
+	}
+}
 
=== added file 'src/network/netclientproxy.h'
--- src/network/netclientproxy.h	1970-01-01 00:00:00 +0000
+++ src/network/netclientproxy.h	2017-12-05 20:38:52 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2008-2017 by the Widelands Development Team
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef WL_NETWORK_NETCLIENTPROXY_H
+#define WL_NETWORK_NETCLIENTPROXY_H
+
+#include <map>
+#include <memory>
+
+#include "network/netclient_interface.h"
+#include "network/netrelayconnection.h"
+
+/**
+ * Represents a client in-game, but talks through the 'wlnr' relay binary.
+ */
+class NetClientProxy : public NetClientInterface {
+public:
+
+	/**
+	 * Tries to connect to the relay at the given address.
+	 * \param address The address to connect to.
+	 * \param name The name of the game.
+	 * \return A pointer to a ready \c NetClientProxy object or a nullptr if the connection failed.
+	 */
+	static std::unique_ptr<NetClientProxy> connect(const NetAddress& address, const std::string& name);
+
+	/**
+	 * Closes the server.
+	 */
+	~NetClientProxy() override;
+
+
+	// Inherited from NetClientInterface
+	bool is_connected() const override;
+	void close() override;
+	std::unique_ptr<RecvPacket> try_receive() override;
+	void send(const SendPacket& packet) override;
+
+private:
+
+	/**
+	 * Tries to connect to the relay at the given address.
+	 * If it fails, is_connected() will return \c false.
+	 * \param address The address to connect to.
+	 * \param name The name of the game.
+	 */
+	NetClientProxy(const NetAddress& address, const std::string& name);
+
+	void receive_commands();
+
+	std::unique_ptr<NetRelayConnection> conn_;
+
+	/// For each connected client, the packages that have been received from him.
+	std::queue<std::unique_ptr<RecvPacket>> received_;
+};
+
+#endif  // end of include guard: WL_NETWORK_NETCLIENTPROXY_H
 
=== modified file 'src/network/nethost.cc'
--- src/network/nethost.cc	2017-10-17 19:08:59 +0000
+++ src/network/nethost.cc	2017-12-05 20:38:52 +0000
@@ -127,7 +127,7 @@
 	return true;
 }
 
-bool NetHost::try_receive(const ConnectionId id, RecvPacket* packet) {
+std::unique_ptr<RecvPacket> NetHost::try_receive(const ConnectionId id) {
 	// Always read all available data into buffers
 	uint8_t buffer[kNetworkBufferSize];
 
@@ -161,32 +161,35 @@
 
 	// Now check whether there is data for the requested client
 	if (!is_connected(id))
-		return false;
+		return std::unique_ptr<RecvPacket>();
 
 	// Try to get one packet from the deserializer
-	return clients_.at(id).deserializer.write_packet(packet);
+	std::unique_ptr<RecvPacket> packet(new RecvPacket);
+	if (clients_.at(id).deserializer.write_packet(packet.get())) {
+		return packet;
+	} else {
+		return std::unique_ptr<RecvPacket>();
+	}
 }
 
 void NetHost::send(const ConnectionId id, const SendPacket& packet) {
 	boost::system::error_code ec;
 	if (is_connected(id)) {
-#ifdef NDEBUG
-		boost::asio::write(
-		   clients_.at(id).socket, boost::asio::buffer(packet.get_data(), packet.get_size()), ec);
-#else
 		size_t written = boost::asio::write(
 		   clients_.at(id).socket, boost::asio::buffer(packet.get_data(), packet.get_size()), ec);
-#endif
 
-		// TODO(Notabilis): This one is an assertion of mine, I am not sure if it will hold
-		// If it doesn't, set the socket to blocking before writing
-		// If it does, remove this comment after build 20
-		assert(ec != boost::asio::error::would_block);
-		assert(written == packet.get_size() || ec);
+		if (ec == boost::asio::error::would_block) {
+			throw wexception("[NetHost] Socket connected to relay would block when writing");
+		}
 		if (ec) {
 			log("[NetHost] Error when sending to a client, closing connection: %s.\n",
 			    ec.message().c_str());
 			close(id);
+			return;
+		}
+		if (written < packet.get_size()) {
+			throw wexception("[NetHost] Unable to send complete packet to relay (only %lu bytes of %lu)",
+							written, packet.get_size());
 		}
 	}
 }
 
=== modified file 'src/network/nethost.h'
--- src/network/nethost.h	2017-11-28 08:57:52 +0000
+++ src/network/nethost.h	2017-12-05 20:38:52 +0000
@@ -48,7 +48,7 @@
 	bool is_connected(ConnectionId id) const override;
 	void close(ConnectionId id) override;
 	bool try_accept(ConnectionId* new_id) override;
-	bool try_receive(ConnectionId id, RecvPacket* packet) override;
+	std::unique_ptr<RecvPacket> try_receive(ConnectionId id) override;
 	void send(ConnectionId id, const SendPacket& packet) override;
 	void send(const std::vector<ConnectionId>& ids, const SendPacket& packet) override;
 
 
=== modified file 'src/network/nethost_interface.h'
--- src/network/nethost_interface.h	2017-10-17 19:08:59 +0000
+++ src/network/nethost_interface.h	2017-12-05 20:38:52 +0000
@@ -20,6 +20,8 @@
 #ifndef WL_NETWORK_NETHOST_INTERFACE_H
 #define WL_NETWORK_NETHOST_INTERFACE_H
 
+#include <memory>
+
 #include "network/network.h"
 
 /**
@@ -66,12 +68,10 @@
 	/**
 	 * Tries to receive a packet.
 	 * \param id The connection id of the client that should be received.
-	 * \param packet A packet that should be overwritten with the received data.
-	 * \return \c true if a packet is available, \c false otherwise.
-	 *   The given packet is only modified when \c true is returned.
-	 *   Calling this on a closed connection will return false.
+	 * \return A pointer to a packet if one is available, an invalid pointer otherwise.
+	 *   Calling this on a closed connection will return an invalid pointer.
 	 */
-	virtual bool try_receive(ConnectionId id, RecvPacket* packet) = 0;
+	virtual std::unique_ptr<RecvPacket> try_receive(ConnectionId id) = 0;
 
 	/**
 	 * Sends a packet.
 
=== added file 'src/network/nethostproxy.cc'
--- src/network/nethostproxy.cc	1970-01-01 00:00:00 +0000
+++ src/network/nethostproxy.cc	2017-12-05 20:38:52 +0000
@@ -0,0 +1,288 @@
+#include "network/nethostproxy.h"
+
+#include <memory>
+
+#include "base/log.h"
+#include "network/relay_protocol.h"
+
+std::unique_ptr<NetHostProxy> NetHostProxy::connect(const std::pair<NetAddress, NetAddress>& addresses, const std::string& name, const std::string& password) {
+	std::unique_ptr<NetHostProxy> ptr(new NetHostProxy(addresses, name, password));
+	if (ptr->conn_ == nullptr || !ptr->conn_->is_connected()) {
+		ptr.reset();
+	}
+	return ptr;
+}
+
+NetHostProxy::~NetHostProxy() {
+	if (conn_ && conn_->is_connected()) {
+		while (!clients_.empty()) {
+			close(clients_.begin()->first);
+			clients_.erase(clients_.begin());
+		}
+		conn_->close();
+	}
+}
+
+bool NetHostProxy::is_connected(const ConnectionId id) const {
+	return clients_.count(id) > 0 && clients_.at(id).state_ == Client::State::kConnected;
+}
+
+void NetHostProxy::close(const ConnectionId id) {
+	auto iter_client = clients_.find(id);
+	if (iter_client == clients_.end()) {
+		// Not connected anyway
+		return;
+	}
+    conn_->send(RelayCommand::kDisconnectClient);
+    conn_->send(id);
+    if (iter_client->second.received_.empty()) {
+		// No pending messages, remove the client
+		clients_.erase(iter_client);
+    } else {
+    	// Still messages pending. Keep the structure so the host can receive them
+		iter_client->second.state_ = Client::State::kDisconnected;
+    }
+}
+
+bool NetHostProxy::try_accept(ConnectionId* new_id) {
+	// Always read all available data into buffers
+	receive_commands();
+
+	for (auto& entry : clients_) {
+		if (entry.second.state_ == Client::State::kConnecting) {
+			*new_id = entry.first;
+			entry.second.state_ = Client::State::kConnected;
+			return true;
+		}
+	}
+	return false;
+}
+
+std::unique_ptr<RecvPacket> NetHostProxy::try_receive(const ConnectionId id) {
+	receive_commands();
+
+	// Check whether client is not (yet) connected
+	if (clients_.count(id) == 0 || clients_.at(id).state_ == Client::State::kConnecting)
+		return std::unique_ptr<RecvPacket>();
+
+	std::queue<std::unique_ptr<RecvPacket>>& packet_list = clients_.at(id).received_;
+
+	// Now check whether there is data for the requested client
+	if (packet_list.empty()) {
+		// If the client is already disconnected it should not be in the map anymore
+		assert(clients_.at(id).state_ == Client::State::kConnected);
+		return std::unique_ptr<RecvPacket>();
+	}
+
+	std::unique_ptr<RecvPacket> packet = std::move(packet_list.front());
+	packet_list.pop();
+	if (packet_list.empty() && clients_.at(id).state_ == Client::State::kDisconnected) {
+		// If the receive buffer is empty now, remove client
+		clients_.erase(id);
+	}
+	return packet;
+}
+
+void NetHostProxy::send(const ConnectionId id, const SendPacket& packet) {
+	std::vector<ConnectionId> vec;
+	vec.push_back(id);
+	send(vec, packet);
+}
+
+void NetHostProxy::send(const std::vector<ConnectionId>& ids, const SendPacket& packet) {
+	if (ids.empty()) {
+		return;
+	}
+
+	receive_commands();
+
+	bool has_connected_client = false;
+	for (ConnectionId id : ids) {
+		if (is_connected(id)) {
+			// This should be but is not always the case. It can happen that we receive a client disconnect
+			// on receive_commands() above and the GameHost did not have the chance to react to it yet.
+			has_connected_client = true;
+		}
+	}
+	if (!has_connected_client) {
+		// Oops, no clients left to send to
+		return;
+	}
+
+	conn_->send(RelayCommand::kToClients);
+	for (ConnectionId id : ids) {
+		if (is_connected(id)) {
+			conn_->send(id);
+		}
+	}
+	conn_->send(0);
+	conn_->send(packet);
+}
+
+NetHostProxy::NetHostProxy(const std::pair<NetAddress, NetAddress>& addresses, const std::string& name, const std::string& password)
+	: conn_(NetRelayConnection::connect(addresses.first)) {
+
+	if ((conn_ == nullptr || !conn_->is_connected()) && addresses.second.is_valid()) {
+		conn_ = NetRelayConnection::connect(addresses.second);
+	}
+
+   	if (conn_ == nullptr || !conn_->is_connected()) {
+		return;
+   	}
+
+   	conn_->send(RelayCommand::kHello);
+   	conn_->send(kRelayProtocolVersion);
+   	conn_->send(name);
+   	conn_->send(password);
+   	conn_->send(password);
+
+   	// Wait 10 seconds for an answer
+	uint32_t endtime = time(nullptr) + 10;
+	while (!NetRelayConnection::Peeker(conn_.get()).cmd()) {
+		if (time(nullptr) > endtime) {
+			// No message received in time
+			conn_->close();
+			conn_.reset();
+			return;
+		}
+	}
+
+	RelayCommand cmd;
+	conn_->receive(&cmd);
+
+   	if (cmd != RelayCommand::kWelcome) {
+		conn_->close();
+		conn_.reset();
+		return;
+   	}
+
+   	// Check version
+	endtime = time(nullptr) + 10;
+	while (!NetRelayConnection::Peeker(conn_.get()).uint8_t()) {
+		if (time(nullptr) > endtime) {
+			// No message received in time
+			conn_->close();
+			conn_.reset();
+			return;
+		}
+	}
+	uint8_t relay_proto_version;
+	conn_->receive(&relay_proto_version);
+   	if (relay_proto_version != kRelayProtocolVersion) {
+		conn_->close();
+		conn_.reset();
+		return;
+   	}
+
+   	// Check game name
+	endtime = time(nullptr) + 10;
+	while (!NetRelayConnection::Peeker(conn_.get()).string()) {
+		if (time(nullptr) > endtime) {
+			// No message received in time
+			conn_->close();
+			conn_.reset();
+			return;
+		}
+	}
+	std::string game_name;
+	conn_->receive(&game_name);
+   	if (game_name != name) {
+		conn_->close();
+		conn_.reset();
+		return;
+   	}
+}
+
+void NetHostProxy::receive_commands() {
+	if (!conn_->is_connected()) {
+		// Seems the connection broke at some time. Set all clients to disconnected
+		for (auto iter_client = clients_.begin(); iter_client != clients_.end(); ) {
+			if (iter_client->second.received_.empty()) {
+				// No pending messages, remove the client
+				clients_.erase(iter_client++);
+			} else {
+				// Still messages pending. Keep the structure so the host can receive them
+				iter_client->second.state_ = Client::State::kDisconnected;
+				++iter_client;
+			}
+		}
+		return;
+	}
+
+	// Receive all available commands
+	RelayCommand cmd;
+	NetRelayConnection::Peeker peek(conn_.get());
+	if (!peek.cmd(&cmd)) {
+		// No command to receive
+		return;
+	}
+	switch (cmd) {
+		case RelayCommand::kDisconnect:
+			if (peek.string()) {
+				// Command is completely in the buffer, handle it
+				conn_->receive(&cmd);
+				std::string reason;
+				conn_->receive(&reason);
+				conn_->close();
+				// Set all clients to offline
+				for (auto& entry : clients_) {
+					entry.second.state_ = Client::State::kDisconnected;
+				}
+			}
+			break;
+		case RelayCommand::kConnectClient:
+			if (peek.uint8_t()) {
+				conn_->receive(&cmd);
+				uint8_t id;
+				conn_->receive(&id);
+#ifndef NDEBUG
+			   auto result = clients_.emplace(
+			      std::piecewise_construct, std::forward_as_tuple(id), std::forward_as_tuple());
+				assert(result.second);
+#else
+			   clients_.emplace(
+			      std::piecewise_construct, std::forward_as_tuple(id), std::forward_as_tuple());
+#endif
+			}
+			break;
+		case RelayCommand::kDisconnectClient:
+			if (peek.uint8_t()) {
+				conn_->receive(&cmd);
+				uint8_t id;
+				conn_->receive(&id);
+				assert(clients_.count(id));
+				clients_.at(id).state_ = Client::State::kDisconnected;
+			}
+			break;
+		case RelayCommand::kFromClient:
+			if (peek.uint8_t() && peek.recvpacket()) {
+				conn_->receive(&cmd);
+				uint8_t id;
+				conn_->receive(&id);
+				std::unique_ptr<RecvPacket> packet(new RecvPacket);
+				conn_->receive(packet.get());
+				assert(clients_.count(id));
+				clients_.at(id).received_.push(std::move(packet));
+			}
+			break;
+		case RelayCommand::kPing:
+			if (peek.uint8_t()) {
+				conn_->receive(&cmd);
+				uint8_t seq;
+				conn_->receive(&seq);
+				// Reply with a pong
+				conn_->send(RelayCommand::kPong);
+				conn_->send(seq);
+			}
+			break;
+		case RelayCommand::kRoundTripTimeResponse:
+			conn_->ignore_rtt_response();
+			break;
+		default:
+			// Other commands should not be possible.
+			// Then is either something wrong with the protocol or there is an implementation mistake
+			log("Received command code %i from relay server, do not know what to do with it\n",
+					static_cast<uint8_t>(cmd));
+			NEVER_HERE();
+	}
+}
 
=== added file 'src/network/nethostproxy.h'
--- src/network/nethostproxy.h	1970-01-01 00:00:00 +0000
+++ src/network/nethostproxy.h	2017-12-05 20:38:52 +0000
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2008-2017 by the Widelands Development Team
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef WL_NETWORK_NETHOSTPROXY_H
+#define WL_NETWORK_NETHOSTPROXY_H
+
+#include <map>
+#include <memory>
+
+#include "network/nethost_interface.h"
+#include "network/netrelayconnection.h"
+
+/**
+ * Represents a host in-game, but talks through the 'wlnr' relay binary.
+ */
+class NetHostProxy : public NetHostInterface {
+public:
+
+	/**
+	 * Tries to connect to the relay at the given address.
+	 * \param address The address to connect to.
+	 * \param name The name of the game.
+	 * \param password The password for connecting as host.
+	 * \return A pointer to a ready \c NetHostProxy object or a nullptr if the connection failed.
+	 */
+	static std::unique_ptr<NetHostProxy> connect(const std::pair<NetAddress, NetAddress>& addresses, const std::string& name, const std::string& password);
+
+	/**
+	 * Closes the server.
+	 */
+	~NetHostProxy() override;
+
+	// Inherited from NetHostInterface
+	bool is_connected(ConnectionId id) const override;
+	void close(ConnectionId id) override;
+	bool try_accept(ConnectionId* new_id) override;
+	std::unique_ptr<RecvPacket> try_receive(ConnectionId id) override;
+	void send(ConnectionId id, const SendPacket& packet) override;
+	void send(const std::vector<ConnectionId>& ids, const SendPacket& packet) override;
+
+private:
+
+	/**
+	 * Tries to connect to the relay at the given address.
+	 * If it fails, is_connected() will return \c false.
+	 * \param addresses Two possible addresses to connect to.
+	 * \param name The name of the game.
+	 * \param password The password for connecting as host.
+	 */
+	NetHostProxy(const std::pair<NetAddress, NetAddress>& addresses, const std::string& name, const std::string& password);
+
+	void receive_commands();
+
+	std::unique_ptr<NetRelayConnection> conn_;
+
+	/// A list of clients which want to connect.
+	std::queue<ConnectionId> accept_;
+
+	/// The clients connected through the relay
+	struct Client {
+		/// The state of the client
+		enum class State {
+			/// The relay introduced the client but try_accept() hasn't been called for it yet
+			kConnecting,
+			/// A normally connected client
+			kConnected,
+			/// The relay told us that the client disconnected but there are still packages in the buffer
+			kDisconnected
+		};
+
+		Client()
+			: state_(State::kConnecting), received_() {
+		}
+
+		// deleted since RecvPacket does not offer a copy constructor
+		Client(const Client& other) = delete;
+
+		/// The current connection state
+		State state_;
+		/// The packages that have been received
+		std::queue<std::unique_ptr<RecvPacket>> received_;
+	};
+	/// The connected clients
+	std::map<ConnectionId, Client> clients_;
+};
+
+#endif  // end of include guard: WL_NETWORK_NETHOSTPROXY_H
 
=== added file 'src/network/netrelayconnection.cc'
--- src/network/netrelayconnection.cc	1970-01-01 00:00:00 +0000
+++ src/network/netrelayconnection.cc	2017-12-05 20:38:52 +0000
@@ -0,0 +1,337 @@
+#include "network/netrelayconnection.h"
+
+#include <memory>
+
+#include "base/log.h"
+
+// Not so great: Quite some duplicated code between this class and NetClient.
+
+NetRelayConnection::Peeker::Peeker(NetRelayConnection *conn)
+	: conn_(conn), peek_pointer_(0) {
+	assert(conn_);
+}
+
+bool NetRelayConnection::Peeker::string() {
+
+	// Simple validity check. Should always be true as long as the caller has not used any receive() method.
+	assert(conn_->buffer_.size() >= peek_pointer_);
+
+	conn_->try_network_receive();
+
+	if (conn_->buffer_.size() < peek_pointer_ + 1) {
+		return false;
+	}
+
+	// A string goes until the next \0 and might have a length of 0
+	for (size_t i = peek_pointer_; i < conn_->buffer_.size(); ++i) {
+		if (conn_->buffer_[i] == '\0') {
+			peek_pointer_ = i + 1;
+			return true;
+		}
+	}
+	return false;
+}
+
+bool NetRelayConnection::Peeker::cmd(RelayCommand *out) {
+
+	assert(conn_->buffer_.size() >= peek_pointer_);
+
+	conn_->try_network_receive();
+
+	if (conn_->buffer_.size() > peek_pointer_) {
+		if (out != nullptr) {
+			*out = static_cast<RelayCommand>(conn_->buffer_[peek_pointer_]);
+		}
+		peek_pointer_++;
+		return true;
+	}
+	return false;
+}
+
+bool NetRelayConnection::Peeker::uint8_t(::uint8_t *out) {
+
+	assert(conn_->buffer_.size() >= peek_pointer_);
+
+	conn_->try_network_receive();
+
+	// If there is any byte available, we can read an uint8
+	if (conn_->buffer_.size() > peek_pointer_) {
+		if (out != nullptr) {
+			*out = static_cast<::uint8_t>(conn_->buffer_[peek_pointer_]);
+		}
+		peek_pointer_++;
+		return true;
+	}
+	return false;
+}
+
+bool NetRelayConnection::Peeker::recvpacket() {
+
+	assert(conn_->buffer_.size() >= peek_pointer_);
+
+	conn_->try_network_receive();
+
+	if (conn_->buffer_.size() < peek_pointer_ + 2) {
+		// Not even enough space for the size of the recvpacket
+		return false;
+	}
+
+	// RecvPackets have their size coded in their first two bytes
+	const uint16_t size = conn_->buffer_[peek_pointer_ + 0] << 8 | conn_->buffer_[peek_pointer_ + 1];
+	assert(size >= 2);
+
+	if (conn_->buffer_.size() >= peek_pointer_ + size) {
+		peek_pointer_ += size;
+		return true;
+	}
+	return false;
+}
+
+std::unique_ptr<NetRelayConnection> NetRelayConnection::connect(const NetAddress& host) {
+	std::unique_ptr<NetRelayConnection> ptr(new NetRelayConnection(host));
+	if (!ptr->is_connected()) {
+		ptr.reset();
+	}
+	return ptr;
+}
+
+NetRelayConnection::~NetRelayConnection() {
+	if (is_connected()) {
+		close();
+	}
+}
+
+bool NetRelayConnection::is_connected() const {
+	return socket_.is_open();
+}
+
+void NetRelayConnection::close() {
+	if (!is_connected()) {
+		return;
+	}
+	boost::system::error_code ec;
+	boost::asio::ip::tcp::endpoint remote = socket_.remote_endpoint(ec);
+	if (!ec) {
+		log("[NetRelayConnection] Closing network socket connected to %s:%i.\n",
+		    remote.address().to_string().c_str(), remote.port());
+	} else {
+		log("[NetRelayConnection] Closing network socket.\n");
+	}
+	socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ec);
+	socket_.close(ec);
+}
+
+void NetRelayConnection::receive(std::string *str) {
+	// Try to receive something from the network.
+	try_network_receive();
+
+	#ifndef NDEBUG
+	// Check if we can read a complete string
+	assert(Peeker(this).string());
+	#endif // NDEBUG
+
+	// Read the string
+	str->clear();
+	// No range check needed, peek_string() takes care of that
+	while (buffer_.front() != '\0') {
+		str->push_back(buffer_.front());
+		buffer_.pop_front();
+	}
+	// Pop the \0
+	buffer_.pop_front();
+}
+
+void NetRelayConnection::receive(RelayCommand *out) {
+	try_network_receive();
+
+	// No complete peeker required here, we only want one byte
+	assert(!buffer_.empty());
+
+	uint8_t i;
+	receive(&i);
+	*out = static_cast<RelayCommand>(i);
+}
+
+void NetRelayConnection::receive(uint8_t *out) {
+	try_network_receive();
+
+	assert(!buffer_.empty());
+
+	*out = buffer_.front();
+	buffer_.pop_front();
+}
+
+void NetRelayConnection::receive(RecvPacket *packet) {
+	try_network_receive();
+
+
+	#ifndef NDEBUG
+	assert(Peeker(this).recvpacket());
+	#endif // NDEBUG
+
+	// Read the packet (adapted copy from Deserializer)
+	const uint16_t size = buffer_[0] << 8 | buffer_[1];
+	assert(size >= 2);
+	assert(buffer_.size() >= size);
+
+	packet->buffer.clear();
+	packet->buffer.insert(packet->buffer.end(), buffer_.begin() + 2, buffer_.begin() + size);
+	packet->index_ = 0;
+
+	buffer_.erase(buffer_.begin(), buffer_.begin() + size);
+}
+
+bool NetRelayConnection::try_network_receive() {
+	if (!is_connected()) {
+		return false;
+	}
+
+	unsigned char buffer[kNetworkBufferSize];
+	boost::system::error_code ec;
+	size_t length = socket_.read_some(boost::asio::buffer(buffer, kNetworkBufferSize), ec);
+	if (!ec) {
+		assert(length > 0);
+		assert(length <= kNetworkBufferSize);
+		// Has read something
+		for (size_t i = 0; i < length; ++i) {
+			buffer_.push_back(buffer[i]);
+		}
+	}
+
+	if (ec && ec != boost::asio::error::would_block) {
+		// Connection closed or some error, close the socket
+		log("[NetRelayConnection] Error when trying to receive some data: %s.\n", ec.message().c_str());
+		close();
+		return false;
+	}
+	return true;
+}
+
+void NetRelayConnection::send(const RelayCommand data) {
+	send(static_cast<uint8_t>(data));
+}
+
+void NetRelayConnection::send(const uint8_t data) {
+	if (!is_connected()) {
+		return;
+	}
+
+	uint8_t buf[1];
+	buf[0] = data;
+
+	boost::system::error_code ec;
+	size_t written = boost::asio::write(socket_, boost::asio::buffer(buf, 1), ec);
+
+	if (ec == boost::asio::error::would_block) {
+		throw wexception("[NetRelayConnection] Socket connected to relay would block when writing");
+	}
+	if (written < 1) {
+		throw wexception("[NetRelayConnection] Unable to send byte to relay");
+	}
+	if (ec) {
+		log("[NetRelayConnection] Error when trying to send some data: %s.\n", ec.message().c_str());
+		close();
+	}
+}
+
+void NetRelayConnection::send(const std::string& str) {
+	if (!is_connected()) {
+		return;
+	}
+
+	// Append \0
+	std::vector<boost::asio::const_buffer> buffers;
+	buffers.push_back(boost::asio::buffer(str));
+	buffers.push_back(boost::asio::buffer("\0", 1));
+
+	boost::system::error_code ec;
+	size_t written = boost::asio::write(socket_, buffers, ec);
+
+	if (ec == boost::asio::error::would_block) {
+		throw wexception("[NetRelayConnection] Socket connected to relay would block when writing");
+	}
+	if (written < str.length() + 1) {
+		throw wexception(
+					"[NetRelayConnection] Unable to send complete string to relay (only %lu bytes of %lu)",
+					written, str.length() + 1);
+	}
+	if (ec) {
+		log("[NetRelayConnection] Error when trying to send some data: %s.\n", ec.message().c_str());
+		close();
+	}
+}
+
+void NetRelayConnection::send(const SendPacket& packet) {
+	if (!is_connected()) {
+		return;
+	}
+
+	boost::system::error_code ec;
+	size_t written =
+		boost::asio::write(socket_, boost::asio::buffer(packet.get_data(), packet.get_size()), ec);
+
+	if (ec == boost::asio::error::would_block) {
+		throw wexception("[NetRelayConnection] Socket connected to relay would block when writing");
+	}
+	if (ec) {
+		log("[NetRelayConnection] Error when trying to send some data: %s.\n", ec.message().c_str());
+		close();
+		return;
+	}
+	if (written < packet.get_size()) {
+		throw wexception(
+					"[NetRelayConnection] Unable to send complete packet to relay (only %lu bytes of %lu)",
+					written, packet.get_size());
+	}
+}
+
+NetRelayConnection::NetRelayConnection(const NetAddress& host)
+   : io_service_(), socket_(io_service_), buffer_() {
+
+	assert(host.is_valid());
+	const boost::asio::ip::tcp::endpoint destination(host.ip, host.port);
+
+	log("[NetRelayConnection]: Trying to connect to %s:%u ... ", host.ip.to_string().c_str(), host.port);
+	boost::system::error_code ec;
+	socket_.connect(destination, ec);
+	if (!ec && is_connected()) {
+		log("success.\n");
+		socket_.non_blocking(true);
+	} else {
+		log("failed.\n");
+		socket_.close();
+		assert(!is_connected());
+	}
+}
+
+void NetRelayConnection::ignore_rtt_response() {
+
+	// TODO(Notabilis): Implement GUI with display of RTTs and possibility to kick lagging players
+	//                  See https://bugs.launchpad.net/widelands/+bug/1734673
+	// TODO(Notabilis): Move this method somewhere where it makes sense.
+
+	uint8_t length_list = 0;
+	RelayCommand cmd;
+	uint8_t tmp;
+
+	Peeker peek(this);
+	peek.cmd(&cmd);
+	assert(cmd == RelayCommand::kRoundTripTimeResponse);
+
+	bool data_complete = peek.uint8_t(&length_list);
+	// Each list element consists of three uint8_t
+	for (uint8_t i = 0; i < length_list * 3; i++) {
+		data_complete = data_complete && peek.uint8_t();
+	}
+	if (!data_complete) {
+		// Some part of this packet is still missing. Try again later
+		return;
+	}
+
+	// Packet completely in buffer, fetch it and ignore it
+	receive(&cmd); // Cmd
+	receive(&tmp); // Length
+	for (uint8_t i = 0; i < length_list * 3; i++) {
+		receive(&tmp); // Parts of the list. See relay_protocol.h
+	}
+}
 
=== added file 'src/network/netrelayconnection.h'
--- src/network/netrelayconnection.h	1970-01-01 00:00:00 +0000
+++ src/network/netrelayconnection.h	2017-12-05 20:38:52 +0000
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2008-2017 by the Widelands Development Team
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef WL_NETWORK_NETRELAYCONNECTION_H
+#define WL_NETWORK_NETRELAYCONNECTION_H
+
+#include <memory>
+
+#include "network/network.h"
+#include "network/relay_protocol.h"
+
+/**
+ * A wrapper around a network connection to the 'wlnr' binary in the metaserver repo.
+ * Does not contain logic but provides a buffer to read
+ * uint8_t / std::string / SendPacket from the network stream.
+ *
+ * Use the Peeker class to check whether the required data has already been received
+ * before trying to read the data.
+ */
+class NetRelayConnection {
+public:
+
+	/**
+	 * Allows to check whether the required data is completely in the buffer before starting to receive it.
+	 *
+	 * The idea of this methods is that the caller can check whether a complete relay command
+	 * can be received before starting to remove data from the buffer. Otherwise, the caller would have to
+	 * maintain their own buffer.
+	 *
+	 * The methods will not remove any bytes, but will check whether the required value can be read.
+	 * After checking, an internal peek-pointer will be incremented. The next call of a method will then
+	 * start reading after the previous value. Only a successful peek will move the pointer.
+	 *
+	 * Note that a successful peek does not mean that the received bytes really are of the requested type,
+	 * it only means they could be interpreted that way. Whether the type matches is in the responsibility
+	 * of the caller.
+	 *
+	 * Using any method of this class will trigger an internal read from the network socket inside the
+	 * given NetRelayConnection.
+	 *
+	 * \warning Calling any receive() method on the given connection will invalidate the Peeker.
+	 */
+	class Peeker {
+	public:
+
+		/**
+		 * Creates a Peeker for the given connection.
+		 * Calling any receive() method on the given connection will invalidate the Peeker.
+		 * \param conn The connection which should be peeked into.
+		 * \note The Peeker instance does not own the given connection. It is the responsible of the
+		 *       caller to make sure the given instance stays valid.
+		 */
+		Peeker(NetRelayConnection *conn);
+
+		/**
+		 * Checks whether a relay command can be read from the buffer.
+		 * This method does not modify the buffer contents but increases the peek-pointer.
+		 * \param out The command that will be returned next. It will not be removed from the input queue!
+		 *            If \c false is returned the contents are not modified. Can be nullptr.
+		 * \return \c True if the value can be read, \c false if not enough data has been received.
+		 */
+		bool cmd(RelayCommand *out = nullptr);
+
+		/**
+		 * Checks whether an uint8_t can be read from the buffer.
+		 * This method does not modify the buffer contents but increases the peek-pointer.
+		 * \param out The uint8_t that will be returned next. It will not be removed from the input queue!
+		 *            If \c false is returned the contents are not modified. Can be nullptr.
+		 * \return \c True if the value can be read, \c false if not enough data has been received.
+		 */
+		bool uint8_t(uint8_t *out = nullptr);
+
+		/**
+		 * Checks whether a std::string can be read from the buffer.
+		 * This method does not modify the buffer contents but increases the peek-pointer.
+		 * \return \c True if the value can be read, \c false if not enough data has been received.
+		 */
+		bool string();
+
+		/**
+		 * Checks whether a RecvPacket can be read from the buffer.
+		 * This method does not modify the buffer contents but increases the peek-pointer.
+		 * \return \c True if the value can be read, \c false if not enough data has been received.
+		 */
+		bool recvpacket();
+
+	private:
+
+		/// The connection to operate on.
+		NetRelayConnection *conn_;
+
+		/// The position of the next peek.
+		size_t peek_pointer_;
+	};
+
+	/**
+	 * Tries to establish a connection to the given relay.
+	 * \param host The host to connect to.
+	 * \return A pointer to a connected \c NetRelayConnection object or a \c nullptr.
+	 */
+	static std::unique_ptr<NetRelayConnection> connect(const NetAddress& host);
+
+	/**
+	 * Closes the connection.
+	 * If you want to send a goodbye-message to the relay, do so before freeing the object.
+	 */
+	~NetRelayConnection();
+
+	/**
+	 * Returns whether the relay is connected.
+	 * \return \c true if the connection is open, \c false otherwise.
+	 */
+	bool is_connected() const;
+
+	/**
+	 * Closes the connection.
+	 * If you want to send a goodbye-message to the relay, do so before calling this.
+	 */
+	void close();
+
+	/**
+	 * Receive a command.
+	 * \warning Calling this method is only safe when peek_cmd() returned \c true.
+	 *          Otherwise the behavior of this method is undefined.
+	 * \param out The variable to write the value to.
+	 */
+	void receive(RelayCommand *out);
+
+	/**
+	 * Receive an uint8_t.
+	 * \warning Calling this method is only safe when peek_uint8_t() returned \c true.
+	 *          Otherwise the behavior of this method is undefined.
+	 * \param out The variable to write the value to.
+	 */
+	void receive(uint8_t *out);
+
+	/**
+	 * Receive a string.
+	 * \warning Calling this method is only safe when peek_string() returned \c true.
+	 *          Otherwise the behavior of this method is undefined.
+	 * \param out The variable to write the value to.
+	 */
+	void receive(std::string *out);
+
+	/**
+	 * Receive a RecvPacket.
+	 * \warning Calling this method is only safe when peek_recvpacket() returned \c true.
+	 *          Otherwise the behavior of this method is undefined.
+	 * \param out The variable to write the value to.
+	 */
+	void receive(RecvPacket *out);
+
+	/**
+	 * Sends a relay command.
+	 * Calling this on a closed connection will silently fail.
+	 * \param data The data to send.
+	 */
+	void send(RelayCommand data);
+
+	/**
+	 * Sends an uint8_t.
+	 * Calling this on a closed connection will silently fail.
+	 * \param data The data to send.
+	 */
+	void send(uint8_t data);
+
+	/**
+	 * Sends a string.
+	 * Calling this on a closed connection will silently fail.
+	 * \param data The data to send.
+	 */
+	void send(const std::string& data);
+
+	/**
+	 * Sends a packet.
+	 * Calling this on a closed connection will silently fail.
+	 * \param data The data to send.
+	 */
+	void send(const SendPacket& data);
+
+	// Temporary method, will be removed.
+	// Removes a message from type kRoundTripTimeResponse from the buffer.
+	void ignore_rtt_response();
+
+private:
+	/**
+	 * Tries to establish a connection to the given host.
+	 * If the connection attempt failed, is_connected() will return \c false.
+	 * \param host The host to connect to.
+	 */
+	explicit NetRelayConnection(const NetAddress& host);
+
+	/**
+	 * Reads data from network.
+	 * \return \c False if an error occurred.
+	 */
+	bool try_network_receive();
+
+	/// An io_service needed by boost.asio. Primarily needed for asynchronous operations.
+	boost::asio::io_service io_service_;
+
+	/// The socket that connects us to the relay.
+	boost::asio::ip::tcp::socket socket_;
+
+	/// Buffer for arriving data. We need to store it until we have enough to return the required type.
+	std::deque<unsigned char> buffer_;
+};
+
+#endif  // end of include guard: WL_NETWORK_NETRELAYCONNECTION_H
 
=== modified file 'src/network/network.cc'
--- src/network/network.cc	2017-07-05 19:21:57 +0000
+++ src/network/network.cc	2017-12-05 20:38:52 +0000
@@ -171,6 +171,8 @@
 	if (buffer.empty()) {
 		buffer.push_back(0);  //  this will finally be the length of the packet
 		buffer.push_back(0);
+		// Attention! These bytes are also used by the network relay protocol.
+		// So if they are removed the protocol has to be updated
 	}
 
 	for (size_t idx = 0; idx < size; ++idx)
@@ -199,7 +201,6 @@
 }
 
 /*** class RecvPacket ***/
-
 size_t RecvPacket::data(void* const packet_data, size_t const bufsize) {
 	if (index_ + bufsize > buffer.size())
 		throw wexception("Packet too short");
 
=== modified file 'src/network/network.h'
--- src/network/network.h	2017-08-09 17:55:34 +0000
+++ src/network/network.h	2017-12-05 20:38:52 +0000
@@ -171,6 +171,7 @@
 
 private:
 	friend class Deserializer;
+	friend class NetRelayConnection;
 	std::vector<uint8_t> buffer;
 	size_t index_ = 0U;
 };
 
=== added file 'src/network/relay_protocol.h'
--- src/network/relay_protocol.h	1970-01-01 00:00:00 +0000
+++ src/network/relay_protocol.h	2017-12-05 20:38:52 +0000
@@ -0,0 +1,242 @@
+/*
+ * Copyright (C) 2012-2017 by the Widelands Development Team
+ *
+ * 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ */
+
+#ifndef WL_NETWORK_RELAY_PROTOCOL_H
+#define WL_NETWORK_RELAY_PROTOCOL_H
+
+/**
+ * Before the internet gaming relay was added, (a) NetHost and (multiple) NetClient established a direct
+ * connection and exchanged data packets created and processed by the GameHost/GameClient. With the
+ * introduction of the relay this changed: GameHost/GameClient still create and process the data packets.
+ * For LAN games, they still pass them to the NetHost/NetClient.
+ * For internet games, the traffic is relayed by the wlnr binary in the metaserver repository.
+ * GameHost/GameClient pass their packets to the new classes NetHostProxy/NetClientProxy.
+ * Those no longer have a direct connection but are both connected to the relay on the metaserver.
+ * When they want to exchange messages, they send their packets to the relay which forwards them to the
+ * intended recipient.
+ * The relay only transport the packets, it does not run any game logic. The idea of this is that the
+ * relay runs on an globally reachable computer (i.e. the one of the metaserver) and simplifies
+ * connectivity for the users (i.e. no more port forwarding required).
+ *
+ * Below are the command codes used in the relay protocol. They are used on the connection
+ * between NetHostProxy/NetClientProxy and relay.
+ *
+ * An example of a typical session:
+ * 1) A user wants to start an internet game. The Widelands instance tells the metaserver about it.
+ * 2) A relay instance is started by the metaserver. On startup of the relay, the nonce of the player is set
+ *    as password for the game-host position in the new game. Additionally, the name of the hosted game
+ *    is stored. The IP address of the relay is send to the Widelands instance by the metaserver.
+ * 3) The Widelands instance of the user connects to the relay.
+ * 4) Now there is a reachable relay/game running somewhere. The open game can be listed in the lobby.
+ * 5) Clients get the address and port of the relay by the metaserver and can connect to the game.
+ *    When enough clients have connected, the GameHost can start the game.
+ * 6) When a client wants to send a packet (e.g. user input) to the GameHost, its GameClient packs the packet,
+ *    passes it to the local NetClientProxy which sends it to the relay. The relay relays the packet to the
+ *    NetHostProxy which passes it to the GameHost.
+ * 7) When the GameHost wants to send a packet to one or all clients, it also packs it and passes it to its
+ *    NetHostProxy which sends it to the relay, where it is forwarded to the client(s).
+ */
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * CONSTANTS
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/**
+ * The current version of the network protocol.
+ * Protocol versions must match on all systems.
+ * Used versions:
+ * 1: Initial version introduced between build 19 and build 20
+ */
+constexpr uint8_t kRelayProtocolVersion = 1;
+
+/**
+ * The commands used by the relay.
+ *
+ * If a command is followed by parameters, they are listed in the description.
+ * Most of these commands do not require any reaction by the receiver.
+ * Exceptions are described at the respective commands.
+ *
+ * Parameter types:
+ *
+ * Strings are NULL-terminated.
+ *
+ * Transmitting data packets:
+ *
+ * The main work of the relay consists of passing opaque data packets between GameHost
+ * and GameClients. They send SendPacket's over the network and expect to receive RecvPacket's
+ * (see network.h). Those packets basically consists of an array of uint8_t with the first two bytes
+ * coding the length of the packet.
+ * When in the following documentation the \c packet datatype is listed as payload data, such a packet
+ * is meant. Since they are already containing their own length, no explicit length field or separator
+ * is required to pack them. When sending they are just written out. When receiving, the Deserializer
+ * has to read the length first and read the appropriate amount of bytes afterwards.
+ */
+/**
+ * This protocol is a binary protocol (as in: not human readable). The receiver reads only the first byte
+ * of the received data to determine which command has been send. Based on that, it knows whether to expect
+ * a string / an uint8 / a SendPacket. Based on this, it can read until NULL / one byte / as much
+ * as the next two bytes specify. When all parameters have been read the next command starts
+ * without any separator.
+ */
+
+// If anyone removes a command: Please leave a comment which command with which value was removed
+enum class RelayCommand : uint8_t {
+	// Value 0 should not be used
+
+	/**
+	 * Commands send by/to all participants.
+	 */
+	/// \{
+	/**
+	 * Sent by the NetHostProxy or NetClientProxy on connect to the relay.
+	 * Has the following payload:
+	 * \li unsigned_8: Protocol version.
+	 * \li string:     Game name.
+	 * \li string:     For the host: Password that was set on start of the relay.
+	 *                 For clients/observers: String "client".
+	 *
+	 * Is answered by kWelcome or kDisconnect (if a parameter is wrong/unknown).
+	 */
+	kHello = 1,
+
+	/**
+	 * Send by the relay to answer a kHello command.
+	 * Confirms the successful connection with the relay. In the case of a connecting NetClientProxy,
+	 * this does not mean that it can participate on the game. This decision is up to the GameHost as
+	 * soon as it learns about the new client.
+	 * Payload:
+	 * \li unsigned_8: The protocol version. Should be the same as the one send in the kHello.
+	 * \li string:     The name of the hosted game as shown in the internet lobby.
+	 *                 The client might want to check this.
+	 *
+	 * This command and its parameters are not really necessary. But it might be nice to have at least some
+	 * confirmation that we have a connection to a (and the right) relay and not to some other server.
+	 */
+	kWelcome = 2,
+
+	/**
+	 * Can be sent by any participant.
+	 * Might be the result of a protocol violation, an invalid password on connect of the NetHostProxy
+	 * or a regular disconnect (e.g. the game is over).
+	 * After sending or receiving this command, the TCP connection should be closed.
+	 * \note When the game host sends its kDisconnect message, the relay will shut down.
+	 * Payload:
+	 * \li string: An error code describing the reason of the disconnect. Valid values:
+	 *             NORMAL: Regular disconnect (game has ended, host leaves, client leaves, ...);
+	 *             PROTOCOL_VIOLATION: Some protocol error (unknown command, invalid parameters, ...);
+	 *             WRONG_VERSION: The version in the kHello packet is not supported;
+	 *             GAME_UNKNOWN: Game name provided in kHello packet is unknown;
+	 *             NO_HOST: No host is connected to the relay yet;
+	 *             INVALID_CLIENT: Host tried to send a message to a non-existing client
+	 */
+	kDisconnect = 3,
+
+	/**
+	 * The relay sends this message to check for presence and to measure the round-trip-time.
+	 * Has to be answered by kPong immediately.
+	 * Payload:
+	 * \li unsigned_8: A sequence number for this ping request.
+	 */
+	kPing = 4,
+
+	/**
+	 * Send to the relay to answer a kPing message.
+	 * Payload:
+	 * \li unsigned_8: Should be the sequence number found in the ping request.
+	 */
+	kPong = 5,
+
+	/**
+	 * Send to the relay to request the newest ping results.
+	 * No payload.
+	 */
+	kRoundTripTimeRequest = 6,
+
+	/**
+	 * Send by the relay as an answer to the kRoundTripTimeRequest with the following payload:
+	 * \li unsigned_8: Length of the list.
+	 * A list of
+	 * \li unsigned_8: Id of the client.
+	 * \li unsigned_8: The RTT in milliseconds. Capped to max. 255ms.
+	 * \li unsigned_8: Seconds since the last kPong has been received by the relay. Capped to max. 255ms.
+	 */
+	kRoundTripTimeResponse = 7,
+	/// \}
+
+	/**
+	 * Communication between relay and NetHostProxy.
+	 */
+	/// \{
+
+	/**
+	 * Send by the relay to the NetHostProxy to inform that a client established a connection to the relay.
+	 * Payload:
+	 * \li unsigned_8: An id to represent the new client.
+	 */
+	kConnectClient = 11,
+
+	/**
+	 * If send by the NetHostProxy, tells the relay to close the connection to a client.
+	 * If send by the relay, informs the NetHostProxy that the connection to a client has been lost.
+	 * Payload:
+	 * \li unsigned_8: The id of the client.
+	 */
+	kDisconnectClient = 12,
+
+	/**
+	 * The NetHostProxy sends a message to a connected client over the relay.
+	 * Payload:
+	 * \li NULL terminated list of unsigned_8: The ids of the clients.
+	 * \li packet: The SendPacket to relay.
+	 */
+	kToClients = 13,
+
+	/**
+	 * The relay transmits a packet from a client to the NetHostProxy.
+	 * Payload:
+	 * \li unsigned_8: The id of the client.
+	 * \li packet: The SendPacket to relay.
+	 */
+	kFromClient = 14,
+	/// \}
+
+	/**
+	 * Communication between relay and NetHostProxy.
+	 */
+	/// \{
+
+	/**
+	 * The NetClientProxy sends a message to the NetHostProxy over the relay.
+	 * Direct communication between clients is not supported.
+	 * Payload:
+	 * \li packet: The SendPacket to relay.
+	 */
+	kToHost = 21,
+
+	/**
+	 * The relay transmits a packet from a NetHostProxy to the NetClientProxy.
+	 * Payload:
+	 * \li packet: The SendPacket to relay.
+	 */
+	kFromHost = 22
+	/// \}
+};
+
+#endif  // end of include guard: WL_NETWORK_RELAY_PROTOCOL_H
 
=== modified file 'src/ui_fsmenu/internet_lobby.cc'
--- src/ui_fsmenu/internet_lobby.cc	2017-11-25 20:29:26 +0000
+++ src/ui_fsmenu/internet_lobby.cc	2017-12-05 20:38:52 +0000
@@ -193,7 +193,7 @@
 void FullscreenMenuInternetLobby::connect_to_metaserver() {
 	Section& s = g_options.pull_section("global");
 	const std::string& metaserver = s.get_string("metaserver", INTERNET_GAMING_METASERVER.c_str());
-	uint32_t port = s.get_natural("metaserverport", INTERNET_GAMING_PORT);
+	uint32_t port = s.get_natural("metaserverport", kInternetGamingPort);
 	std::string auth = is_registered_ ? password_ : s.get_string("uuid");
 	assert(!auth.empty());
 	InternetGaming::ref().login(nickname_, auth, is_registered_, metaserver, port);
@@ -352,30 +352,40 @@
 	}
 }
 
+bool FullscreenMenuInternetLobby::wait_for_ip() {
+	// Wait until the metaserver provided us with an IP address
+	uint32_t const secs = time(nullptr);
+	while (!InternetGaming::ref().ips().first.is_valid()) {
+		InternetGaming::ref().handle_metaserver_communication();
+		// give some time for the answer + for a relogin, if a problem occurs.
+		if ((kInternetGamingTimeout * 5 / 3) < time(nullptr) - secs) {
+			// Show a popup warning message
+			const std::string warning(
+			   _("Widelands was unable to get the IP address of the server in time. "
+				 "There seems to be a network problem, either on your side or on the side "
+				 "of the server.\n"));
+			UI::WLMessageBox mmb(this, _("Connection timed out"), warning,
+								 UI::WLMessageBox::MBoxType::kOk, UI::Align::kLeft);
+			mmb.run<UI::Panel::Returncodes>();
+			InternetGaming::ref().set_error();
+			return false;
+		}
+	}
+	return true;
+}
+
 /// called when the 'join game' button was clicked
 void FullscreenMenuInternetLobby::clicked_joingame() {
 	if (opengames_list_.has_selection()) {
 		InternetGaming::ref().join_game(opengames_list_.get_selected().name);
 
-		uint32_t const secs = time(nullptr);
-		while (!InternetGaming::ref().ips().first.is_valid()) {
-			InternetGaming::ref().handle_metaserver_communication();
-			// give some time for the answer + for a relogin, if a problem occurs.
-			if ((INTERNET_GAMING_TIMEOUT * 5 / 3) < time(nullptr) - secs) {
-				// Show a popup warning message
-				const std::string warning(
-				   _("Widelands was unable to get the IP address of the server in time.\n"
-				     "There seems to be a network problem, either on your side or on the side\n"
-				     "of the server.\n"));
-				UI::WLMessageBox mmb(this, _("Connection timed out"), warning,
-				                     UI::WLMessageBox::MBoxType::kOk, UI::Align::kLeft);
-				mmb.run<UI::Panel::Returncodes>();
-				return InternetGaming::ref().set_error();
-			}
+		if (!wait_for_ip()) {
+			return;
 		}
 		const std::pair<NetAddress, NetAddress>& ips = InternetGaming::ref().ips();
 
-		GameClient netgame(ips, InternetGaming::ref().get_local_clientname(), true);
+		GameClient netgame(ips, InternetGaming::ref().get_local_clientname(),
+							true, opengames_list_.get_selected().name);
 		netgame.run();
 	} else
 		throw wexception("No server selected! That should not happen!");
@@ -399,6 +409,16 @@
 
 	// Start the game
 	try {
+
+		// Tell the metaserver about it
+		InternetGaming::ref().open_game();
+
+		// Wait for his response with the IPs of the relay server
+		if (!wait_for_ip()) {
+			return;
+		}
+
+		// Start our relay host
 		GameHost netgame(InternetGaming::ref().get_local_clientname(), true);
 		netgame.run();
 	} catch (...) {
 
=== modified file 'src/ui_fsmenu/internet_lobby.h'
--- src/ui_fsmenu/internet_lobby.h	2017-01-25 18:55:59 +0000
+++ src/ui_fsmenu/internet_lobby.h	2017-12-05 20:38:52 +0000
@@ -75,6 +75,7 @@
 	void server_doubleclicked();
 
 	void change_servername();
+	bool wait_for_ip();
 	void clicked_joingame();
 	void clicked_hostgame();
 
 
=== modified file 'src/ui_fsmenu/multiplayer.cc'
--- src/ui_fsmenu/multiplayer.cc	2017-11-25 20:29:26 +0000
+++ src/ui_fsmenu/multiplayer.cc	2017-12-05 20:38:52 +0000
@@ -123,7 +123,7 @@
 
 	// Try to connect to the metaserver
 	const std::string& meta = s.get_string("metaserver", INTERNET_GAMING_METASERVER.c_str());
-	uint32_t port = s.get_natural("metaserverport", INTERNET_GAMING_PORT);
+	uint32_t port = s.get_natural("metaserverport", kInternetGamingPort);
 	std::string auth = register_ ? password_ : s.get_string("uuid");
 	assert(!auth.empty());
 	InternetGaming::ref().login(nickname_, auth, register_, meta, port);