OpenTTD Source: src/network/network_client.cpp Source File

OpenTTD Source 12.0-beta1

network_client.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * OpenTTD 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, version 2.
4 * OpenTTD 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.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
10 #include "../stdafx.h"
11 #include "network_gui.h"
12 #include "../saveload/saveload.h"
13 #include "../saveload/saveload_filter.h"
14 #include "../command_func.h"
15 #include "../console_func.h"
16 #include "../strings_func.h"
17 #include "../window_func.h"
18 #include "../company_func.h"
19 #include "../company_base.h"
20 #include "../company_gui.h"
21 #include "../core/random_func.hpp"
22 #include "../date_func.h"
23 #include "../gfx_func.h"
24 #include "../error.h"
25 #include "../rev.h"
26 #include "core/game_info.h"
27 #include "network.h"
28 #include "network_base.h"
29 #include "network_client.h"
30 #include "network_gamelist.h"
31 #include "../core/backup_type.hpp"
32 #include "../thread.h"
33
34 #include "table/strings.h"
35
36 #include "../safeguards.h"
37
38 /* This file handles all the client-commands */
39
41 struct PacketReader : LoadFilter {
42 static const size_t CHUNK = 32 * 1024;
43
44 std::vector<byte *> blocks;
45 byte *buf;
46 byte *bufe;
47 byte **block;
48 size_t written_bytes;
49 size_t read_bytes;
50
52 PacketReader() : LoadFilter(nullptr), buf(nullptr), bufe(nullptr), block(nullptr), written_bytes(0), read_bytes(0)
53 {
54 }
55
56 ~PacketReader() override
57 {
58 for (auto p : this->blocks) {
59 free(p);
60 }
61 }
62
70 static inline ssize_t TransferOutMemCopy(PacketReader *destination, const char *source, size_t amount)
71 {
72 memcpy(destination->buf, source, amount);
73 destination->buf += amount;
74 destination->written_bytes += amount;
75 return amount;
76 }
77
82 void AddPacket(Packet *p)
83 {
84 assert(this->read_bytes == 0);
85 p->TransferOutWithLimit(TransferOutMemCopy, this->bufe - this->buf, this);
86
87 /* Did everything fit in the current chunk, then we're done. */
88 if (p->RemainingBytesToTransfer() == 0) return;
89
90 /* Allocate a new chunk and add the remaining data. */
91 this->blocks.push_back(this->buf = CallocT<byte>(CHUNK));
92 this->bufe = this->buf + CHUNK;
93
94 p->TransferOutWithLimit(TransferOutMemCopy, this->bufe - this->buf, this);
95 }
96
97 size_t Read(byte *rbuf, size_t size) override
98 {
99 /* Limit the amount to read to whatever we still have. */
100 size_t ret_size = size = std::min(this->written_bytes - this->read_bytes, size);
101 this->read_bytes += ret_size;
102 const byte *rbufe = rbuf + ret_size;
103
104 while (rbuf != rbufe) {
105 if (this->buf == this->bufe) {
106 this->buf = *this->block++;
107 this->bufe = this->buf + CHUNK;
108 }
109
110 size_t to_write = std::min(this->bufe - this->buf, rbufe - rbuf);
111 memcpy(rbuf, this->buf, to_write);
112 rbuf += to_write;
113 this->buf += to_write;
114 }
115
116 return ret_size;
117 }
118
119 void Reset() override
120 {
121 this->read_bytes = 0;
122
123 this->block = this->blocks.data();
124 this->buf = *this->block++;
125 this->bufe = this->buf + CHUNK;
126 }
127 };
128
129
133 void ClientNetworkEmergencySave()
134 {
135 static FiosNumberedSaveName _netsave_ctr("netsave");
136 DoAutoOrNetsave(_netsave_ctr);
137 }
138
139
144 ClientNetworkGameSocketHandler::ClientNetworkGameSocketHandler(SOCKET s, const std::string &connection_string) : NetworkGameSocketHandler(s), connection_string(connection_string), savegame(nullptr), status(STATUS_INACTIVE)
145 {
146 assert(ClientNetworkGameSocketHandler::my_client == nullptr);
147 ClientNetworkGameSocketHandler::my_client = this;
148 }
149
151 ClientNetworkGameSocketHandler::~ClientNetworkGameSocketHandler()
152 {
153 assert(ClientNetworkGameSocketHandler::my_client == this);
154 ClientNetworkGameSocketHandler::my_client = nullptr;
155
156 delete this->savegame;
157 delete this->GetInfo();
158 }
159
160 NetworkRecvStatus ClientNetworkGameSocketHandler::CloseConnection(NetworkRecvStatus status)
161 {
162 assert(status != NETWORK_RECV_STATUS_OKAY);
163 assert(this->sock != INVALID_SOCKET);
164
165 if (!this->HasClientQuit()) {
166 Debug(net, 3, "Closed client connection {}", this->client_id);
167
168 this->SendPackets(true);
169
170 /* Wait a number of ticks so our leave message can reach the server.
171 * This is especially needed for Windows servers as they seem to get
172 * the "socket is closed" message before receiving our leave message,
173 * which would trigger the server to close the connection as well. */
174 CSleep(3 * MILLISECONDS_PER_TICK);
175 }
176
177 delete this;
178
179 return status;
180 }
181
186 void ClientNetworkGameSocketHandler::ClientError(NetworkRecvStatus res)
187 {
188 /* First, send a CLIENT_ERROR to the server, so it knows we are
189 * disconnected (and why!) */
190 NetworkErrorCode errorno;
191
192 /* We just want to close the connection.. */
193 if (res == NETWORK_RECV_STATUS_CLOSE_QUERY) {
194 this->NetworkSocketHandler::MarkClosed();
195 this->CloseConnection(res);
196 _networking = false;
197
198 CloseWindowById(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
199 return;
200 }
201
202 switch (res) {
203 case NETWORK_RECV_STATUS_DESYNC: errorno = NETWORK_ERROR_DESYNC; break;
204 case NETWORK_RECV_STATUS_SAVEGAME: errorno = NETWORK_ERROR_SAVEGAME_FAILED; break;
205 case NETWORK_RECV_STATUS_NEWGRF_MISMATCH: errorno = NETWORK_ERROR_NEWGRF_MISMATCH; break;
206 default: errorno = NETWORK_ERROR_GENERAL; break;
207 }
208
209 if (res == NETWORK_RECV_STATUS_SERVER_ERROR || res == NETWORK_RECV_STATUS_SERVER_FULL ||
210 res == NETWORK_RECV_STATUS_SERVER_BANNED) {
211 /* This means the server closed the connection. Emergency save is
212 * already created if this was appropriate during handling of the
213 * disconnect. */
214 this->CloseConnection(res);
215 } else {
216 /* This means we as client made a boo-boo. */
217 SendError(errorno);
218
219 /* Close connection before we make an emergency save, as the save can
220 * take a bit of time; better that the server doesn't stall while we
221 * are doing the save, and already disconnects us. */
222 this->CloseConnection(res);
223 ClientNetworkEmergencySave();
224 }
225
226 _switch_mode = SM_MENU;
227 _networking = false;
228 }
229
230
236 /* static */ bool ClientNetworkGameSocketHandler::Receive()
237 {
238 if (my_client->CanSendReceive()) {
239 NetworkRecvStatus res = my_client->ReceivePackets();
240 if (res != NETWORK_RECV_STATUS_OKAY) {
241 /* The client made an error of which we can not recover.
242 * Close the connection and drop back to the main menu. */
243 my_client->ClientError(res);
244 return false;
245 }
246 }
247 return _networking;
248 }
249
251 /* static */ void ClientNetworkGameSocketHandler::Send()
252 {
253 my_client->SendPackets();
254 if (my_client != nullptr) my_client->CheckConnection();
255 }
256
261 /* static */ bool ClientNetworkGameSocketHandler::GameLoop()
262 {
263 _frame_counter++;
264
265 NetworkExecuteLocalCommandQueue();
266
267 extern void StateGameLoop();
268 StateGameLoop();
269
270 /* Check if we are in sync! */
271 if (_sync_frame != 0) {
272 if (_sync_frame == _frame_counter) {
273 #ifdef NETWORK_SEND_DOUBLE_SEED
274 if (_sync_seed_1 != _random.state[0] || _sync_seed_2 != _random.state[1]) {
275 #else
276 if (_sync_seed_1 != _random.state[0]) {
277 #endif
278 ShowNetworkError(STR_NETWORK_ERROR_DESYNC);
279 Debug(desync, 1, "sync_err: {:08x}; {:02x}", _date, _date_fract);
280 Debug(net, 0, "Sync error detected");
281 my_client->ClientError(NETWORK_RECV_STATUS_DESYNC);
282 return false;
283 }
284
285 /* If this is the first time we have a sync-frame, we
286 * need to let the server know that we are ready and at the same
287 * frame as it is.. so we can start playing! */
288 if (_network_first_time) {
289 _network_first_time = false;
290 SendAck();
291 }
292
293 _sync_frame = 0;
294 } else if (_sync_frame < _frame_counter) {
295 Debug(net, 1, "Missed frame for sync-test: {} / {}", _sync_frame, _frame_counter);
296 _sync_frame = 0;
297 }
298 }
299
300 return true;
301 }
302
303
305 ClientNetworkGameSocketHandler * ClientNetworkGameSocketHandler::my_client = nullptr;
306
308 static uint32 last_ack_frame;
309
311 static uint32 _password_game_seed;
313 static std::string _password_server_id;
314
316 static uint8 _network_server_max_companies;
318 std::string _network_server_name;
319
321 NetworkJoinInfo _network_join;
322
324 static_assert(NETWORK_SERVER_ID_LENGTH == 16 * 2 + 1);
325
326 /***********
327 * Sending functions
328 * DEF_CLIENT_SEND_COMMAND has no parameters
329 ************/
330
334 NetworkRecvStatus ClientNetworkGameSocketHandler::SendInformationQuery()
335 {
336 my_client->status = STATUS_GAME_INFO;
337 my_client->SendPacket(new Packet(PACKET_CLIENT_GAME_INFO));
338
339 return NETWORK_RECV_STATUS_OKAY;
340 }
341
343 NetworkRecvStatus ClientNetworkGameSocketHandler::SendJoin()
344 {
345 my_client->status = STATUS_JOIN;
346 _network_join_status = NETWORK_JOIN_STATUS_AUTHORIZING;
347 SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
348
349 Packet *p = new Packet(PACKET_CLIENT_JOIN);
350 p->Send_string(GetNetworkRevisionString());
351 p->Send_uint32(_openttd_newgrf_version);
352 p->Send_string(_settings_client.network.client_name); // Client name
353 p->Send_uint8 (_network_join.company); // PlayAs
354 p->Send_uint8 (0); // Used to be language
355 my_client->SendPacket(p);
356 return NETWORK_RECV_STATUS_OKAY;
357 }
358
360 NetworkRecvStatus ClientNetworkGameSocketHandler::SendNewGRFsOk()
361 {
362 Packet *p = new Packet(PACKET_CLIENT_NEWGRFS_CHECKED);
363 my_client->SendPacket(p);
364 return NETWORK_RECV_STATUS_OKAY;
365 }
366
371 NetworkRecvStatus ClientNetworkGameSocketHandler::SendGamePassword(const std::string &password)
372 {
373 Packet *p = new Packet(PACKET_CLIENT_GAME_PASSWORD);
374 p->Send_string(password);
375 my_client->SendPacket(p);
376 return NETWORK_RECV_STATUS_OKAY;
377 }
378
383 NetworkRecvStatus ClientNetworkGameSocketHandler::SendCompanyPassword(const std::string &password)
384 {
385 Packet *p = new Packet(PACKET_CLIENT_COMPANY_PASSWORD);
386 p->Send_string(GenerateCompanyPasswordHash(password, _password_server_id, _password_game_seed));
387 my_client->SendPacket(p);
388 return NETWORK_RECV_STATUS_OKAY;
389 }
390
392 NetworkRecvStatus ClientNetworkGameSocketHandler::SendGetMap()
393 {
394 my_client->status = STATUS_MAP_WAIT;
395
396 Packet *p = new Packet(PACKET_CLIENT_GETMAP);
397 my_client->SendPacket(p);
398 return NETWORK_RECV_STATUS_OKAY;
399 }
400
402 NetworkRecvStatus ClientNetworkGameSocketHandler::SendMapOk()
403 {
404 my_client->status = STATUS_ACTIVE;
405
406 Packet *p = new Packet(PACKET_CLIENT_MAP_OK);
407 my_client->SendPacket(p);
408 return NETWORK_RECV_STATUS_OKAY;
409 }
410
412 NetworkRecvStatus ClientNetworkGameSocketHandler::SendAck()
413 {
414 Packet *p = new Packet(PACKET_CLIENT_ACK);
415
416 p->Send_uint32(_frame_counter);
417 p->Send_uint8 (my_client->token);
418 my_client->SendPacket(p);
419 return NETWORK_RECV_STATUS_OKAY;
420 }
421
426 NetworkRecvStatus ClientNetworkGameSocketHandler::SendCommand(const CommandPacket *cp)
427 {
428 Packet *p = new Packet(PACKET_CLIENT_COMMAND);
429 my_client->NetworkGameSocketHandler::SendCommand(p, cp);
430
431 my_client->SendPacket(p);
432 return NETWORK_RECV_STATUS_OKAY;
433 }
434
436 NetworkRecvStatus ClientNetworkGameSocketHandler::SendChat(NetworkAction action, DestType type, int dest, const std::string &msg, int64 data)
437 {
438 Packet *p = new Packet(PACKET_CLIENT_CHAT);
439
440 p->Send_uint8 (action);
441 p->Send_uint8 (type);
442 p->Send_uint32(dest);
443 p->Send_string(msg);
444 p->Send_uint64(data);
445
446 my_client->SendPacket(p);
447 return NETWORK_RECV_STATUS_OKAY;
448 }
449
451 NetworkRecvStatus ClientNetworkGameSocketHandler::SendError(NetworkErrorCode errorno)
452 {
453 Packet *p = new Packet(PACKET_CLIENT_ERROR);
454
455 p->Send_uint8(errorno);
456 my_client->SendPacket(p);
457 return NETWORK_RECV_STATUS_OKAY;
458 }
459
464 NetworkRecvStatus ClientNetworkGameSocketHandler::SendSetPassword(const std::string &password)
465 {
466 Packet *p = new Packet(PACKET_CLIENT_SET_PASSWORD);
467
468 p->Send_string(GenerateCompanyPasswordHash(password, _password_server_id, _password_game_seed));
469 my_client->SendPacket(p);
470 return NETWORK_RECV_STATUS_OKAY;
471 }
472
477 NetworkRecvStatus ClientNetworkGameSocketHandler::SendSetName(const std::string &name)
478 {
479 Packet *p = new Packet(PACKET_CLIENT_SET_NAME);
480
481 p->Send_string(name);
482 my_client->SendPacket(p);
483 return NETWORK_RECV_STATUS_OKAY;
484 }
485
489 NetworkRecvStatus ClientNetworkGameSocketHandler::SendQuit()
490 {
491 Packet *p = new Packet(PACKET_CLIENT_QUIT);
492
493 my_client->SendPacket(p);
494 return NETWORK_RECV_STATUS_OKAY;
495 }
496
502 NetworkRecvStatus ClientNetworkGameSocketHandler::SendRCon(const std::string &pass, const std::string &command)
503 {
504 Packet *p = new Packet(PACKET_CLIENT_RCON);
505 p->Send_string(pass);
506 p->Send_string(command);
507 my_client->SendPacket(p);
508 return NETWORK_RECV_STATUS_OKAY;
509 }
510
516 NetworkRecvStatus ClientNetworkGameSocketHandler::SendMove(CompanyID company, const std::string &password)
517 {
518 Packet *p = new Packet(PACKET_CLIENT_MOVE);
519 p->Send_uint8(company);
520 p->Send_string(GenerateCompanyPasswordHash(password, _password_server_id, _password_game_seed));
521 my_client->SendPacket(p);
522 return NETWORK_RECV_STATUS_OKAY;
523 }
524
529 bool ClientNetworkGameSocketHandler::IsConnected()
530 {
531 return my_client != nullptr && my_client->status == STATUS_ACTIVE;
532 }
533
534
535 /***********
536 * Receiving functions
537 * DEF_CLIENT_RECEIVE_COMMAND has parameter: Packet *p
538 ************/
539
540 extern bool SafeLoad(const std::string &filename, SaveLoadOperation fop, DetailedFileType dft, GameMode newgm, Subdirectory subdir, struct LoadFilter *lf = nullptr);
541
542 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_FULL(Packet *p)
543 {
544 /* We try to join a server which is full */
545 ShowErrorMessage(STR_NETWORK_ERROR_SERVER_FULL, INVALID_STRING_ID, WL_CRITICAL);
546 CloseWindowById(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
547
548 return NETWORK_RECV_STATUS_SERVER_FULL;
549 }
550
551 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_BANNED(Packet *p)
552 {
553 /* We try to join a server where we are banned */
554 ShowErrorMessage(STR_NETWORK_ERROR_SERVER_BANNED, INVALID_STRING_ID, WL_CRITICAL);
555 CloseWindowById(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
556
557 return NETWORK_RECV_STATUS_SERVER_BANNED;
558 }
559
560 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_GAME_INFO(Packet *p)
561 {
562 if (this->status != STATUS_GAME_INFO) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
563
564 NetworkGameList *item = NetworkGameListAddItem(this->connection_string);
565
566 /* Clear any existing GRFConfig chain. */
567 ClearGRFConfigList(&item->info.grfconfig);
568 /* Retrieve the NetworkGameInfo from the packet. */
569 DeserializeNetworkGameInfo(p, &item->info);
570 /* Check for compatability with the client. */
571 CheckGameCompatibility(item->info);
572 /* Ensure we consider the server online. */
573 item->online = true;
574
575 UpdateNetworkGameWindow();
576
577 return NETWORK_RECV_STATUS_CLOSE_QUERY;
578 }
579
580 /* This packet contains info about the client (playas and name)
581 * as client we save this in NetworkClientInfo, linked via 'client_id'
582 * which is always an unique number on a server. */
583 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_CLIENT_INFO(Packet *p)
584 {
585 NetworkClientInfo *ci;
586 ClientID client_id = (ClientID)p->Recv_uint32();
587 CompanyID playas = (CompanyID)p->Recv_uint8();
588
589 std::string name = p->Recv_string(NETWORK_NAME_LENGTH);
590
591 if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
592 if (this->HasClientQuit()) return NETWORK_RECV_STATUS_CLIENT_QUIT;
593 /* The server validates the name when receiving it from clients, so when it is wrong
594 * here something went really wrong. In the best case the packet got malformed on its
595 * way too us, in the worst case the server is broken or compromised. */
596 if (!NetworkIsValidClientName(name)) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
597
598 ci = NetworkClientInfo::GetByClientID(client_id);
599 if (ci != nullptr) {
600 if (playas == ci->client_playas && name.compare(ci->client_name) != 0) {
601 /* Client name changed, display the change */
602 NetworkTextMessage(NETWORK_ACTION_NAME_CHANGE, CC_DEFAULT, false, ci->client_name, name);
603 } else if (playas != ci->client_playas) {
604 /* The client changed from client-player..
605 * Do not display that for now */
606 }
607
608 /* Make sure we're in the company the server tells us to be in,
609 * for the rare case that we get moved while joining. */
610 if (client_id == _network_own_client_id) SetLocalCompany(!Company::IsValidID(playas) ? COMPANY_SPECTATOR : playas);
611
612 ci->client_playas = playas;
613 ci->client_name = name;
614
615 InvalidateWindowData(WC_CLIENT_LIST, 0);
616
617 return NETWORK_RECV_STATUS_OKAY;
618 }
619
620 /* There are at most as many ClientInfo as ClientSocket objects in a
621 * server. Having more info than a server can have means something
622 * has gone wrong somewhere, i.e. the server has more info than it
623 * has actual clients. That means the server is feeding us an invalid
624 * state. So, bail out! This server is broken. */
625 if (!NetworkClientInfo::CanAllocateItem()) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
626
627 /* We don't have this client_id yet, find an empty client_id, and put the data there */
628 ci = new NetworkClientInfo(client_id);
629 ci->client_playas = playas;
630 if (client_id == _network_own_client_id) this->SetInfo(ci);
631
632 ci->client_name = name;
633
634 InvalidateWindowData(WC_CLIENT_LIST, 0);
635
636 return NETWORK_RECV_STATUS_OKAY;
637 }
638
639 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_ERROR(Packet *p)
640 {
641 static const StringID network_error_strings[] = {
642 STR_NETWORK_ERROR_LOSTCONNECTION, // NETWORK_ERROR_GENERAL
643 STR_NETWORK_ERROR_LOSTCONNECTION, // NETWORK_ERROR_DESYNC
644 STR_NETWORK_ERROR_LOSTCONNECTION, // NETWORK_ERROR_SAVEGAME_FAILED
645 STR_NETWORK_ERROR_LOSTCONNECTION, // NETWORK_ERROR_CONNECTION_LOST
646 STR_NETWORK_ERROR_LOSTCONNECTION, // NETWORK_ERROR_ILLEGAL_PACKET
647 STR_NETWORK_ERROR_LOSTCONNECTION, // NETWORK_ERROR_NEWGRF_MISMATCH
648 STR_NETWORK_ERROR_SERVER_ERROR, // NETWORK_ERROR_NOT_AUTHORIZED
649 STR_NETWORK_ERROR_SERVER_ERROR, // NETWORK_ERROR_NOT_EXPECTED
650 STR_NETWORK_ERROR_WRONG_REVISION, // NETWORK_ERROR_WRONG_REVISION
651 STR_NETWORK_ERROR_LOSTCONNECTION, // NETWORK_ERROR_NAME_IN_USE
652 STR_NETWORK_ERROR_WRONG_PASSWORD, // NETWORK_ERROR_WRONG_PASSWORD
653 STR_NETWORK_ERROR_SERVER_ERROR, // NETWORK_ERROR_COMPANY_MISMATCH
654 STR_NETWORK_ERROR_KICKED, // NETWORK_ERROR_KICKED
655 STR_NETWORK_ERROR_CHEATER, // NETWORK_ERROR_CHEATER
656 STR_NETWORK_ERROR_SERVER_FULL, // NETWORK_ERROR_FULL
657 STR_NETWORK_ERROR_TOO_MANY_COMMANDS, // NETWORK_ERROR_TOO_MANY_COMMANDS
658 STR_NETWORK_ERROR_TIMEOUT_PASSWORD, // NETWORK_ERROR_TIMEOUT_PASSWORD
659 STR_NETWORK_ERROR_TIMEOUT_COMPUTER, // NETWORK_ERROR_TIMEOUT_COMPUTER
660 STR_NETWORK_ERROR_TIMEOUT_MAP, // NETWORK_ERROR_TIMEOUT_MAP
661 STR_NETWORK_ERROR_TIMEOUT_JOIN, // NETWORK_ERROR_TIMEOUT_JOIN
662 STR_NETWORK_ERROR_INVALID_CLIENT_NAME, // NETWORK_ERROR_INVALID_CLIENT_NAME
663 };
664 static_assert(lengthof(network_error_strings) == NETWORK_ERROR_END);
665
666 NetworkErrorCode error = (NetworkErrorCode)p->Recv_uint8();
667
668 /* If we query a server that is 1.11.1 or older, we get an
669 * NETWORK_ERROR_NOT_EXPECTED on requesting the game info. Show a special
670 * error popup in that case.
671 */
672 if (error == NETWORK_ERROR_NOT_EXPECTED && this->status == STATUS_GAME_INFO) {
673 ShowErrorMessage(STR_NETWORK_ERROR_SERVER_TOO_OLD, INVALID_STRING_ID, WL_CRITICAL);
674 return NETWORK_RECV_STATUS_CLOSE_QUERY;
675 }
676
677 StringID err = STR_NETWORK_ERROR_LOSTCONNECTION;
678 if (error < (ptrdiff_t)lengthof(network_error_strings)) err = network_error_strings[error];
679 /* In case of kicking a client, we assume there is a kick message in the packet if we can read one byte */
680 if (error == NETWORK_ERROR_KICKED && p->CanReadFromPacket(1)) {
681 std::string kick_msg = p->Recv_string(NETWORK_CHAT_LENGTH);
682 SetDParamStr(0, kick_msg);
683 ShowErrorMessage(err, STR_NETWORK_ERROR_KICK_MESSAGE, WL_CRITICAL);
684 } else {
685 ShowErrorMessage(err, INVALID_STRING_ID, WL_CRITICAL);
686 }
687
688 /* Perform an emergency save if we had already entered the game */
689 if (this->status == STATUS_ACTIVE) ClientNetworkEmergencySave();
690
691 CloseWindowById(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
692
693 return NETWORK_RECV_STATUS_SERVER_ERROR;
694 }
695
696 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_CHECK_NEWGRFS(Packet *p)
697 {
698 if (this->status != STATUS_JOIN) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
699
700 uint grf_count = p->Recv_uint8();
701 NetworkRecvStatus ret = NETWORK_RECV_STATUS_OKAY;
702
703 /* Check all GRFs */
704 for (; grf_count > 0; grf_count--) {
705 GRFIdentifier c;
706 DeserializeGRFIdentifier(p, &c);
707
708 /* Check whether we know this GRF */
709 const GRFConfig *f = FindGRFConfig(c.grfid, FGCM_EXACT, c.md5sum);
710 if (f == nullptr) {
711 /* We do not know this GRF, bail out of initialization */
712 char buf[sizeof(c.md5sum) * 2 + 1];
713 md5sumToString(buf, lastof(buf), c.md5sum);
714 Debug(grf, 0, "NewGRF {:08X} not found; checksum {}", BSWAP32(c.grfid), buf);
715 ret = NETWORK_RECV_STATUS_NEWGRF_MISMATCH;
716 }
717 }
718
719 if (ret == NETWORK_RECV_STATUS_OKAY) {
720 /* Start receiving the map */
721 return SendNewGRFsOk();
722 }
723
724 /* NewGRF mismatch, bail out */
725 ShowErrorMessage(STR_NETWORK_ERROR_NEWGRF_MISMATCH, INVALID_STRING_ID, WL_CRITICAL);
726 return ret;
727 }
728
729 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_NEED_GAME_PASSWORD(Packet *p)
730 {
731 if (this->status < STATUS_JOIN || this->status >= STATUS_AUTH_GAME) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
732 this->status = STATUS_AUTH_GAME;
733
734 if (!_network_join.server_password.empty()) {
735 return SendGamePassword(_network_join.server_password);
736 }
737
738 ShowNetworkNeedPassword(NETWORK_GAME_PASSWORD);
739
740 return NETWORK_RECV_STATUS_OKAY;
741 }
742
743 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_NEED_COMPANY_PASSWORD(Packet *p)
744 {
745 if (this->status < STATUS_JOIN || this->status >= STATUS_AUTH_COMPANY) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
746 this->status = STATUS_AUTH_COMPANY;
747
748 _password_game_seed = p->Recv_uint32();
749 _password_server_id = p->Recv_string(NETWORK_SERVER_ID_LENGTH);
750 if (this->HasClientQuit()) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
751
752 if (!_network_join.company_password.empty()) {
753 return SendCompanyPassword(_network_join.company_password);
754 }
755
756 ShowNetworkNeedPassword(NETWORK_COMPANY_PASSWORD);
757
758 return NETWORK_RECV_STATUS_OKAY;
759 }
760
761 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_WELCOME(Packet *p)
762 {
763 if (this->status < STATUS_JOIN || this->status >= STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
764 this->status = STATUS_AUTHORIZED;
765
766 _network_own_client_id = (ClientID)p->Recv_uint32();
767
768 /* Initialize the password hash salting variables, even if they were previously. */
769 _password_game_seed = p->Recv_uint32();
770 _password_server_id = p->Recv_string(NETWORK_SERVER_ID_LENGTH);
771
772 /* Start receiving the map */
773 return SendGetMap();
774 }
775
776 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_WAIT(Packet *p)
777 {
778 /* We set the internal wait state when requesting the map. */
779 if (this->status != STATUS_MAP_WAIT) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
780
781 /* But... only now we set the join status to waiting, instead of requesting. */
782 _network_join_status = NETWORK_JOIN_STATUS_WAITING;
783 _network_join_waiting = p->Recv_uint8();
784 SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
785
786 return NETWORK_RECV_STATUS_OKAY;
787 }
788
789 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_BEGIN(Packet *p)
790 {
791 if (this->status < STATUS_AUTHORIZED || this->status >= STATUS_MAP) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
792 this->status = STATUS_MAP;
793
794 if (this->savegame != nullptr) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
795
796 this->savegame = new PacketReader();
797
798 _frame_counter = _frame_counter_server = _frame_counter_max = p->Recv_uint32();
799
800 _network_join_bytes = 0;
801 _network_join_bytes_total = 0;
802
803 _network_join_status = NETWORK_JOIN_STATUS_DOWNLOADING;
804 SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
805
806 return NETWORK_RECV_STATUS_OKAY;
807 }
808
809 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_SIZE(Packet *p)
810 {
811 if (this->status != STATUS_MAP) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
812 if (this->savegame == nullptr) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
813
814 _network_join_bytes_total = p->Recv_uint32();
815 SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
816
817 return NETWORK_RECV_STATUS_OKAY;
818 }
819
820 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_DATA(Packet *p)
821 {
822 if (this->status != STATUS_MAP) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
823 if (this->savegame == nullptr) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
824
825 /* We are still receiving data, put it to the file */
826 this->savegame->AddPacket(p);
827
828 _network_join_bytes = (uint32)this->savegame->written_bytes;
829 SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
830
831 return NETWORK_RECV_STATUS_OKAY;
832 }
833
834 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MAP_DONE(Packet *p)
835 {
836 if (this->status != STATUS_MAP) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
837 if (this->savegame == nullptr) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
838
839 _network_join_status = NETWORK_JOIN_STATUS_PROCESSING;
840 SetWindowDirty(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
841
842 /*
843 * Make sure everything is set for reading.
844 *
845 * We need the local copy and reset this->savegame because when
846 * loading fails the network gets reset upon loading the intro
847 * game, which would cause us to free this->savegame twice.
848 */
849 LoadFilter *lf = this->savegame;
850 this->savegame = nullptr;
851 lf->Reset();
852
853 /* The map is done downloading, load it */
854 ClearErrorMessages();
855 bool load_success = SafeLoad({}, SLO_LOAD, DFT_GAME_FILE, GM_NORMAL, NO_DIRECTORY, lf);
856
857 /* Long savegame loads shouldn't affect the lag calculation! */
858 this->last_packet = std::chrono::steady_clock::now();
859
860 if (!load_success) {
861 CloseWindowById(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
862 ShowErrorMessage(STR_NETWORK_ERROR_SAVEGAMEERROR, INVALID_STRING_ID, WL_CRITICAL);
863 return NETWORK_RECV_STATUS_SAVEGAME;
864 }
865 /* If the savegame has successfully loaded, ALL windows have been removed,
866 * only toolbar/statusbar and gamefield are visible */
867
868 /* Say we received the map and loaded it correctly! */
869 SendMapOk();
870
871 ShowClientList();
872
873 /* New company/spectator (invalid company) or company we want to join is not active
874 * Switch local company to spectator and await the server's judgement */
875 if (_network_join.company == COMPANY_NEW_COMPANY || !Company::IsValidID(_network_join.company)) {
876 SetLocalCompany(COMPANY_SPECTATOR);
877
878 if (_network_join.company != COMPANY_SPECTATOR) {
879 /* We have arrived and ready to start playing; send a command to make a new company;
880 * the server will give us a client-id and let us in */
881 _network_join_status = NETWORK_JOIN_STATUS_REGISTERING;
882 ShowJoinStatusWindow();
883 NetworkSendCommand(0, CCA_NEW, 0, CMD_COMPANY_CTRL, nullptr, {}, _local_company);
884 }
885 } else {
886 /* take control over an existing company */
887 SetLocalCompany(_network_join.company);
888 }
889
890 return NETWORK_RECV_STATUS_OKAY;
891 }
892
893 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_FRAME(Packet *p)
894 {
895 if (this->status != STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
896
897 _frame_counter_server = p->Recv_uint32();
898 _frame_counter_max = p->Recv_uint32();
899 #ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME
900 /* Test if the server supports this option
901 * and if we are at the frame the server is */
902 if (p->pos + 1 < p->size) {
903 _sync_frame = _frame_counter_server;
904 _sync_seed_1 = p->Recv_uint32();
905 #ifdef NETWORK_SEND_DOUBLE_SEED
906 _sync_seed_2 = p->Recv_uint32();
907 #endif
908 }
909 #endif
910 /* Receive the token. */
911 if (p->CanReadFromPacket(sizeof(uint8))) this->token = p->Recv_uint8();
912
913 Debug(net, 7, "Received FRAME {}", _frame_counter_server);
914
915 /* Let the server know that we received this frame correctly
916 * We do this only once per day, to save some bandwidth ;) */
917 if (!_network_first_time && last_ack_frame < _frame_counter) {
918 last_ack_frame = _frame_counter + DAY_TICKS;
919 Debug(net, 7, "Sent ACK at {}", _frame_counter);
920 SendAck();
921 }
922
923 return NETWORK_RECV_STATUS_OKAY;
924 }
925
926 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_SYNC(Packet *p)
927 {
928 if (this->status != STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
929
930 _sync_frame = p->Recv_uint32();
931 _sync_seed_1 = p->Recv_uint32();
932 #ifdef NETWORK_SEND_DOUBLE_SEED
933 _sync_seed_2 = p->Recv_uint32();
934 #endif
935
936 return NETWORK_RECV_STATUS_OKAY;
937 }
938
939 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_COMMAND(Packet *p)
940 {
941 if (this->status != STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
942
943 CommandPacket cp;
944 const char *err = this->ReceiveCommand(p, &cp);
945 cp.frame = p->Recv_uint32();
946 cp.my_cmd = p->Recv_bool();
947
948 if (err != nullptr) {
949 IConsolePrint(CC_WARNING, "Dropping server connection due to {}.", err);
950 return NETWORK_RECV_STATUS_MALFORMED_PACKET;
951 }
952
953 this->incoming_queue.Append(&cp);
954
955 return NETWORK_RECV_STATUS_OKAY;
956 }
957
958 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_CHAT(Packet *p)
959 {
960 if (this->status != STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
961
962 std::string name;
963 const NetworkClientInfo *ci = nullptr, *ci_to;
964
965 NetworkAction action = (NetworkAction)p->Recv_uint8();
966 ClientID client_id = (ClientID)p->Recv_uint32();
967 bool self_send = p->Recv_bool();
968 std::string msg = p->Recv_string(NETWORK_CHAT_LENGTH);
969 int64 data = p->Recv_uint64();
970
971 ci_to = NetworkClientInfo::GetByClientID(client_id);
972 if (ci_to == nullptr) return NETWORK_RECV_STATUS_OKAY;
973
974 /* Did we initiate the action locally? */
975 if (self_send) {
976 switch (action) {
977 case NETWORK_ACTION_CHAT_CLIENT:
978 /* For speaking to client we need the client-name */
979 name = ci_to->client_name;
980 ci = NetworkClientInfo::GetByClientID(_network_own_client_id);
981 break;
982
983 /* For speaking to company, we need the company-name */
984 case NETWORK_ACTION_CHAT_COMPANY: {
985 StringID str = Company::IsValidID(ci_to->client_playas) ? STR_COMPANY_NAME : STR_NETWORK_SPECTATORS;
986 SetDParam(0, ci_to->client_playas);
987
988 name = GetString(str);
989 ci = NetworkClientInfo::GetByClientID(_network_own_client_id);
990 break;
991 }
992
993 default: return NETWORK_RECV_STATUS_MALFORMED_PACKET;
994 }
995 } else {
996 /* Display message from somebody else */
997 name = ci_to->client_name;
998 ci = ci_to;
999 }
1000
1001 if (ci != nullptr) {
1002 NetworkTextMessage(action, GetDrawStringCompanyColour(ci->client_playas), self_send, name, msg, data);
1003 }
1004 return NETWORK_RECV_STATUS_OKAY;
1005 }
1006
1007 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_ERROR_QUIT(Packet *p)
1008 {
1009 if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
1010
1011 ClientID client_id = (ClientID)p->Recv_uint32();
1012
1013 NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(client_id);
1014 if (ci != nullptr) {
1015 NetworkTextMessage(NETWORK_ACTION_LEAVE, CC_DEFAULT, false, ci->client_name, "", GetNetworkErrorMsg((NetworkErrorCode)p->Recv_uint8()));
1016 delete ci;
1017 }
1018
1019 InvalidateWindowData(WC_CLIENT_LIST, 0);
1020
1021 return NETWORK_RECV_STATUS_OKAY;
1022 }
1023
1024 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_QUIT(Packet *p)
1025 {
1026 if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
1027
1028 ClientID client_id = (ClientID)p->Recv_uint32();
1029
1030 NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(client_id);
1031 if (ci != nullptr) {
1032 NetworkTextMessage(NETWORK_ACTION_LEAVE, CC_DEFAULT, false, ci->client_name, "", STR_NETWORK_MESSAGE_CLIENT_LEAVING);
1033 delete ci;
1034 } else {
1035 Debug(net, 1, "Unknown client ({}) is leaving the game", client_id);
1036 }
1037
1038 InvalidateWindowData(WC_CLIENT_LIST, 0);
1039
1040 /* If we come here it means we could not locate the client.. strange :s */
1041 return NETWORK_RECV_STATUS_OKAY;
1042 }
1043
1044 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_JOIN(Packet *p)
1045 {
1046 if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
1047
1048 ClientID client_id = (ClientID)p->Recv_uint32();
1049
1050 NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(client_id);
1051 if (ci != nullptr) {
1052 NetworkTextMessage(NETWORK_ACTION_JOIN, CC_DEFAULT, false, ci->client_name);
1053 }
1054
1055 InvalidateWindowData(WC_CLIENT_LIST, 0);
1056
1057 return NETWORK_RECV_STATUS_OKAY;
1058 }
1059
1060 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_SHUTDOWN(Packet *p)
1061 {
1062 /* Only when we're trying to join we really
1063 * care about the server shutting down. */
1064 if (this->status >= STATUS_JOIN) {
1065 ShowErrorMessage(STR_NETWORK_MESSAGE_SERVER_SHUTDOWN, INVALID_STRING_ID, WL_CRITICAL);
1066 }
1067
1068 if (this->status == STATUS_ACTIVE) ClientNetworkEmergencySave();
1069
1070 return NETWORK_RECV_STATUS_SERVER_ERROR;
1071 }
1072
1073 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_NEWGAME(Packet *p)
1074 {
1075 /* Only when we're trying to join we really
1076 * care about the server shutting down. */
1077 if (this->status >= STATUS_JOIN) {
1078 /* To throttle the reconnects a bit, every clients waits its
1079 * Client ID modulo 16. This way reconnects should be spread
1080 * out a bit. */
1081 _network_reconnect = _network_own_client_id % 16;
1082 ShowErrorMessage(STR_NETWORK_MESSAGE_SERVER_REBOOT, INVALID_STRING_ID, WL_CRITICAL);
1083 }
1084
1085 if (this->status == STATUS_ACTIVE) ClientNetworkEmergencySave();
1086
1087 return NETWORK_RECV_STATUS_SERVER_ERROR;
1088 }
1089
1090 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_RCON(Packet *p)
1091 {
1092 if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
1093
1094 TextColour colour_code = (TextColour)p->Recv_uint16();
1095 if (!IsValidConsoleColour(colour_code)) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
1096
1097 std::string rcon_out = p->Recv_string(NETWORK_RCONCOMMAND_LENGTH);
1098
1099 IConsolePrint(colour_code, rcon_out);
1100
1101 return NETWORK_RECV_STATUS_OKAY;
1102 }
1103
1104 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_MOVE(Packet *p)
1105 {
1106 if (this->status < STATUS_AUTHORIZED) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
1107
1108 /* Nothing more in this packet... */
1109 ClientID client_id = (ClientID)p->Recv_uint32();
1110 CompanyID company_id = (CompanyID)p->Recv_uint8();
1111
1112 if (client_id == 0) {
1113 /* definitely an invalid client id, debug message and do nothing. */
1114 Debug(net, 1, "Received invalid client index = 0");
1115 return NETWORK_RECV_STATUS_MALFORMED_PACKET;
1116 }
1117
1118 const NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(client_id);
1119 /* Just make sure we do not try to use a client_index that does not exist */
1120 if (ci == nullptr) return NETWORK_RECV_STATUS_OKAY;
1121
1122 /* if not valid player, force spectator, else check player exists */
1123 if (!Company::IsValidID(company_id)) company_id = COMPANY_SPECTATOR;
1124
1125 if (client_id == _network_own_client_id) {
1126 SetLocalCompany(company_id);
1127 }
1128
1129 return NETWORK_RECV_STATUS_OKAY;
1130 }
1131
1132 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_CONFIG_UPDATE(Packet *p)
1133 {
1134 if (this->status < STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
1135
1136 _network_server_max_companies = p->Recv_uint8();
1137 _network_server_name = p->Recv_string(NETWORK_NAME_LENGTH);
1138
1139 return NETWORK_RECV_STATUS_OKAY;
1140 }
1141
1142 NetworkRecvStatus ClientNetworkGameSocketHandler::Receive_SERVER_COMPANY_UPDATE(Packet *p)
1143 {
1144 if (this->status < STATUS_ACTIVE) return NETWORK_RECV_STATUS_MALFORMED_PACKET;
1145
1146 _network_company_passworded = p->Recv_uint16();
1147 SetWindowClassesDirty(WC_COMPANY);
1148
1149 return NETWORK_RECV_STATUS_OKAY;
1150 }
1151
1155 void ClientNetworkGameSocketHandler::CheckConnection()
1156 {
1157 /* Only once we're authorized we can expect a steady stream of packets. */
1158 if (this->status < STATUS_AUTHORIZED) return;
1159
1160 /* 5 seconds are roughly twice the server's "you're slow" threshold (1 game day). */
1161 std::chrono::steady_clock::duration lag = std::chrono::steady_clock::now() - this->last_packet;
1162 if (lag < std::chrono::seconds(5)) return;
1163
1164 /* 20 seconds are (way) more than 4 game days after which
1165 * the server will forcefully disconnect you. */
1166 if (lag > std::chrono::seconds(20)) {
1167 this->NetworkGameSocketHandler::CloseConnection();
1168 return;
1169 }
1170
1171 /* Prevent showing the lag message every tick; just update it when needed. */
1172 static std::chrono::steady_clock::duration last_lag = {};
1173 if (std::chrono::duration_cast<std::chrono::seconds>(last_lag) == std::chrono::duration_cast<std::chrono::seconds>(lag)) return;
1174
1175 last_lag = lag;
1176 SetDParam(0, std::chrono::duration_cast<std::chrono::seconds>(lag).count());
1177 ShowErrorMessage(STR_NETWORK_ERROR_CLIENT_GUI_LOST_CONNECTION_CAPTION, STR_NETWORK_ERROR_CLIENT_GUI_LOST_CONNECTION, WL_INFO);
1178 }
1179
1180
1182 void NetworkClient_Connected()
1183 {
1184 /* Set the frame-counter to 0 so nothing happens till we are ready */
1185 _frame_counter = 0;
1186 _frame_counter_server = 0;
1187 last_ack_frame = 0;
1188 /* Request the game-info */
1189 MyClient::SendJoin();
1190 }
1191
1197 void NetworkClientSendRcon(const std::string &password, const std::string &command)
1198 {
1199 MyClient::SendRCon(password, command);
1200 }
1201
1208 void NetworkClientRequestMove(CompanyID company_id, const std::string &pass)
1209 {
1210 MyClient::SendMove(company_id, pass);
1211 }
1212
1217 void NetworkClientsToSpectators(CompanyID cid)
1218 {
1219 Backup<CompanyID> cur_company(_current_company, FILE_LINE);
1220 /* If our company is changing owner, go to spectators */
1221 if (cid == _local_company) SetLocalCompany(COMPANY_SPECTATOR);
1222
1223 for (NetworkClientInfo *ci : NetworkClientInfo::Iterate()) {
1224 if (ci->client_playas != cid) continue;
1225 NetworkTextMessage(NETWORK_ACTION_COMPANY_SPECTATOR, CC_DEFAULT, false, ci->client_name);
1226 ci->client_playas = COMPANY_SPECTATOR;
1227 }
1228
1229 cur_company.Restore();
1230 }
1231
1239 bool NetworkIsValidClientName(const std::string_view client_name)
1240 {
1241 if (client_name.empty()) return false;
1242 if (client_name[0] == ' ') return false;
1243 return true;
1244 }
1245
1261 bool NetworkValidateClientName(std::string &client_name)
1262 {
1263 StrTrimInPlace(client_name);
1264 if (NetworkIsValidClientName(client_name)) return true;
1265
1266 ShowErrorMessage(STR_NETWORK_ERROR_BAD_PLAYER_NAME, INVALID_STRING_ID, WL_ERROR);
1267 return false;
1268 }
1269
1277 bool NetworkValidateOurClientName()
1278 {
1279 return NetworkValidateClientName(_settings_client.network.client_name);
1280 }
1281
1286 void NetworkUpdateClientName(const std::string &client_name)
1287 {
1288 NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(_network_own_client_id);
1289 if (ci == nullptr) return;
1290
1291 /* Don't change the name if it is the same as the old name */
1292 if (client_name.compare(ci->client_name) != 0) {
1293 if (!_network_server) {
1294 MyClient::SendSetName(client_name);
1295 } else {
1296 /* Copy to a temporary buffer so no #n gets added after our name in the settings when there are duplicate names. */
1297 std::string temporary_name = client_name;
1298 if (NetworkMakeClientNameUnique(temporary_name)) {
1299 NetworkTextMessage(NETWORK_ACTION_NAME_CHANGE, CC_DEFAULT, false, ci->client_name, temporary_name);
1300 ci->client_name = temporary_name;
1301 NetworkUpdateClientInfo(CLIENT_ID_SERVER);
1302 }
1303 }
1304 }
1305 }
1306
1315 void NetworkClientSendChat(NetworkAction action, DestType type, int dest, const std::string &msg, int64 data)
1316 {
1317 MyClient::SendChat(action, type, dest, msg, data);
1318 }
1319
1324 void NetworkClientSetCompanyPassword(const std::string &password)
1325 {
1326 MyClient::SendSetPassword(password);
1327 }
1328
1334 bool NetworkClientPreferTeamChat(const NetworkClientInfo *cio)
1335 {
1336 /* Only companies actually playing can speak to team. Eg spectators cannot */
1337 if (!_settings_client.gui.prefer_teamchat || !Company::IsValidID(cio->client_playas)) return false;
1338
1339 for (const NetworkClientInfo *ci : NetworkClientInfo::Iterate()) {
1340 if (ci->client_playas == cio->client_playas && ci != cio) return true;
1341 }
1342
1343 return false;
1344 }
1345
1350 bool NetworkMaxCompaniesReached()
1351 {
1352 return Company::GetNumItems() >= (_network_server ? _settings_client.network.max_companies : _network_server_max_companies);
1353 }
NetworkClientSendRcon
void NetworkClientSendRcon(const std::string &password, const std::string &command)
Send a remote console command.
Definition: network_client.cpp:1197
ClientNetworkGameSocketHandler::Receive_SERVER_FRAME
NetworkRecvStatus Receive_SERVER_FRAME(Packet *p) override
Sends the current frame counter to the client: uint32 Frame counter uint32 Frame counter max (how far...
Definition: network_client.cpp:893
PacketReader::AddPacket
void AddPacket(Packet *p)
Add a packet to this buffer.
Definition: network_client.cpp:82
_network_join_bytes_total
uint32 _network_join_bytes_total
The total number of bytes to download.
Definition: network_gui.cpp:2117
DestType
DestType
Destination of our chat messages.
Definition: network_type.h:89
ClientNetworkGameSocketHandler::SendNewGRFsOk
static NetworkRecvStatus SendNewGRFsOk()
Tell the server we got all the NewGRFs.
Definition: network_client.cpp:360
InvalidateWindowData
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3218
ClientNetworkGameSocketHandler::Receive_SERVER_CHAT
NetworkRecvStatus Receive_SERVER_CHAT(Packet *p) override
Sends a chat-packet to the client: uint8 ID of the action (see NetworkAction).
Definition: network_client.cpp:958
NETWORK_RECV_STATUS_CLIENT_QUIT
@ NETWORK_RECV_STATUS_CLIENT_QUIT
The connection is lost gracefully. Other clients are already informed of this leaving client.
Definition: core.h:27
_frame_counter
uint32 _frame_counter
The current frame.
Definition: network.cpp:70
PACKET_CLIENT_ERROR
@ PACKET_CLIENT_ERROR
A client reports an error to the server.
Definition: tcp_game.h:124
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3120
NetworkValidateOurClientName
bool NetworkValidateOurClientName()
Convenience method for NetworkValidateClientName on _settings_client.network.client_name.
Definition: network_client.cpp:1277
FindGRFConfig
const GRFConfig * FindGRFConfig(uint32 grfid, FindGRFConfigMode mode, const uint8 *md5sum, uint32 desired_version)
Find a NewGRF in the scanned list.
Definition: newgrf_config.cpp:736
NetworkGameSocketHandler::ReceivePackets
NetworkRecvStatus ReceivePackets()
Do the actual receiving of packets.
Definition: tcp_game.cpp:133
CSleep
void CSleep(int milliseconds)
Sleep on the current thread for a defined time.
Definition: thread.h:23
NetworkValidateClientName
bool NetworkValidateClientName(std::string &client_name)
Trim the given client name in place, i.e.
Definition: network_client.cpp:1261
NETWORK_RECV_STATUS_DESYNC
@ NETWORK_RECV_STATUS_DESYNC
A desync did occur.
Definition: core.h:24
ClientNetworkGameSocketHandler::STATUS_AUTH_COMPANY
@ STATUS_AUTH_COMPANY
Last action was requesting company password.
Definition: network_client.h:29
NetworkClientInfo::client_name
std::string client_name
Name of the client.
Definition: network_base.h:26
_password_game_seed
static uint32 _password_game_seed
One bit of 'entropy' used to generate a salt for the company passwords.
Definition: network_client.cpp:311
_network_join_waiting
uint8 _network_join_waiting
The number of clients waiting in front of us.
Definition: network_gui.cpp:2115
ClearGRFConfigList
void ClearGRFConfigList(GRFConfig **config)
Clear a GRF Config list, freeing all nodes.
Definition: newgrf_config.cpp:400
NetworkJoinInfo::company_password
std::string company_password
The password of the company to join.
Definition: network_client.h:119
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
ClientNetworkGameSocketHandler::Receive_SERVER_BANNED
NetworkRecvStatus Receive_SERVER_BANNED(Packet *p) override
Notification that the client trying to join is banned.
Definition: network_client.cpp:551
NETWORK_NAME_LENGTH
static const uint NETWORK_NAME_LENGTH
The maximum length of the server name and map name, in bytes including '\0'.
Definition: config.h:55
NetworkClientInfo::client_playas
CompanyID client_playas
As which company is this client playing (CompanyID)
Definition: network_base.h:27
ClientNetworkEmergencySave
void ClientNetworkEmergencySave()
Create an emergency savegame when the network connection is lost.
Definition: network_client.cpp:133
_date_fract
DateFract _date_fract
Fractional part of the day.
Definition: date.cpp:29
NetworkClientRequestMove
void NetworkClientRequestMove(CompanyID company_id, const std::string &pass)
Notify the server of this client wanting to be moved to another company.
Definition: network_client.cpp:1208
_network_server
bool _network_server
network-server is active
Definition: network.cpp:57
SaveLoadOperation
SaveLoadOperation
Operation performed on the file.
Definition: fileio_type.h:47
ClientNetworkGameSocketHandler::ClientNetworkGameSocketHandler
ClientNetworkGameSocketHandler(SOCKET s, const std::string &connection_string)
Create a new socket for the client side of the game connection.
Definition: network_client.cpp:144
_network_company_passworded
CompanyMask _network_company_passworded
Bitmask of the password status of all companies.
Definition: network.cpp:79
NetworkAction
NetworkAction
Actions that can be used for NetworkTextMessage.
Definition: network_type.h:99
NetworkClientPreferTeamChat
bool NetworkClientPreferTeamChat(const NetworkClientInfo *cio)
Tell whether the client has team members who they can chat to.
Definition: network_client.cpp:1334
CommandPacket::frame
uint32 frame
the frame in which this packet is executed
Definition: network_internal.h:112
NetworkGameSocketHandler::last_packet
std::chrono::steady_clock::time_point last_packet
Time we received the last frame.
Definition: tcp_game.h:505
WC_CLIENT_LIST
@ WC_CLIENT_LIST
Client list; Window numbers:
Definition: window_type.h:470
ClientNetworkGameSocketHandler::Receive_SERVER_COMPANY_UPDATE
NetworkRecvStatus Receive_SERVER_COMPANY_UPDATE(Packet *p) override
Update the clients knowledge of which company is password protected: uint16 Bitwise representation of...
Definition: network_client.cpp:1142
ClientNetworkGameSocketHandler::CheckConnection
void CheckConnection()
Check the connection's state, i.e.
Definition: network_client.cpp:1155
NetworkJoinInfo::server_password
std::string server_password
The password of the server to join.
Definition: network_client.h:118
DeserializeGRFIdentifier
void DeserializeGRFIdentifier(Packet *p, GRFIdentifier *grf)
Deserializes the GRFIdentifier (GRF ID and MD5 checksum) from the packet.
Definition: game_info.cpp:377
NetworkGameSocketHandler::SetInfo
void SetInfo(NetworkClientInfo *info)
Sets the client info for this socket handler.
Definition: tcp_game.h:520
NetworkUpdateClientInfo
void NetworkUpdateClientInfo(ClientID client_id)
Send updated client info of a particular client.
Definition: network_server.cpp:1426
ClientNetworkGameSocketHandler::GameLoop
static bool GameLoop()
Actual game loop for the client.
Definition: network_client.cpp:261
PacketReader::block
byte ** block
The block we're reading from/writing to.
Definition: network_client.cpp:47
ClientNetworkGameSocketHandler::Receive_SERVER_GAME_INFO
NetworkRecvStatus Receive_SERVER_GAME_INFO(Packet *p) override
Sends information about the game.
Definition: network_client.cpp:560
NETWORK_CHAT_LENGTH
static const uint NETWORK_CHAT_LENGTH
The maximum length of a chat message, in bytes including '\0'.
Definition: config.h:66
PACKET_CLIENT_COMMAND
@ PACKET_CLIENT_COMMAND
Client executed a command and sends it to the server.
Definition: tcp_game.h:96
SetLocalCompany
void SetLocalCompany(CompanyID new_company)
Sets the local company and updates the settings that are set on a per-company basis to reflect the co...
Definition: company_cmd.cpp:102
DFT_GAME_FILE
@ DFT_GAME_FILE
Save game or scenario file.
Definition: fileio_type.h:31
NetworkTCPSocketHandler::sock
SOCKET sock
The socket currently connected to.
Definition: tcp.h:39
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:250
PacketReader::written_bytes
size_t written_bytes
The total number of bytes we've written.
Definition: network_client.cpp:48
GetNetworkRevisionString
std::string_view GetNetworkRevisionString()
Get the network version string used by this build.
Definition: game_info.cpp:43
_random
Randomizer _random
Random used in the game state calculations.
Definition: random_func.cpp:25
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:52
UpdateNetworkGameWindow
void UpdateNetworkGameWindow()
Update the network new window because a new server is found on the network.
Definition: network_gui.cpp:66
NetworkGameListAddItem
NetworkGameList * NetworkGameListAddItem(const std::string &connection_string)
Add a new item to the linked gamelist.
Definition: network_gamelist.cpp:32
PACKET_CLIENT_QUIT
@ PACKET_CLIENT_QUIT
A client tells the server it is going to quit.
Definition: tcp_game.h:122
network_gui.h
_network_join_status
NetworkJoinStatus _network_join_status
The status of joining.
Definition: network_gui.cpp:2114
PACKET_CLIENT_GETMAP
@ PACKET_CLIENT_GETMAP
Client requests the actual map.
Definition: tcp_game.h:74
ClientNetworkGameSocketHandler::Receive_SERVER_ERROR
NetworkRecvStatus Receive_SERVER_ERROR(Packet *p) override
The client made an error: uint8 Error code caused (see NetworkErrorCode).
Definition: network_client.cpp:639
WC_COMPANY
@ WC_COMPANY
Company view; Window numbers:
Definition: window_type.h:361
GetNetworkErrorMsg
StringID GetNetworkErrorMsg(NetworkErrorCode err)
Retrieve the string id of an internal error number.
Definition: network.cpp:297
_network_server_name
std::string _network_server_name
The current name of the server you are on.
Definition: network_client.cpp:318
ClientNetworkGameSocketHandler::my_client
static ClientNetworkGameSocketHandler * my_client
This is us!
Definition: network_client.h:42
ClientNetworkGameSocketHandler::Receive_SERVER_MAP_BEGIN
NetworkRecvStatus Receive_SERVER_MAP_BEGIN(Packet *p) override
Sends that the server will begin with sending the map to the client: uint32 Current frame.
Definition: network_client.cpp:789
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
ClientNetworkGameSocketHandler::CloseConnection
NetworkRecvStatus CloseConnection(NetworkRecvStatus status) override
Close the network connection due to the given status.
Definition: network_client.cpp:160
NetworkGameSocketHandler
Base socket handler for all TCP sockets.
Definition: tcp_game.h:153
Packet::Send_uint8
void Send_uint8(uint8 data)
Package a 8 bits integer in the packet.
Definition: packet.cpp:129
LoadFilter::Reset
virtual void Reset()
Reset this filter to read from the beginning of the file.
Definition: saveload_filter.h:43
GRFIdentifier::md5sum
uint8 md5sum[16]
MD5 checksum of file to distinguish files with the same GRF ID (eg. newer version of GRF)
Definition: newgrf_config.h:85
PacketReader::Read
size_t Read(byte *rbuf, size_t size) override
Read a given number of bytes from the savegame.
Definition: network_client.cpp:97
ClientNetworkGameSocketHandler::Receive_SERVER_CLIENT_INFO
NetworkRecvStatus Receive_SERVER_CLIENT_INFO(Packet *p) override
Send information about a client: uint32 ID of the client (always unique on a server.
Definition: network_client.cpp:583
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:196
NetworkSendCommand
void NetworkSendCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback, const std::string &text, CompanyID company)
Prepare a DoCommand to be send over the network.
Definition: network_command.cpp:136
CC_DEFAULT
static const TextColour CC_DEFAULT
Default colour of the console.
Definition: console_type.h:23
_frame_counter_max
uint32 _frame_counter_max
To where we may go with our clients.
Definition: network.cpp:69
PacketReader
Read some packets, and when do use that data as initial load filter.
Definition: network_client.cpp:41
GRFIdentifier::grfid
uint32 grfid
GRF ID (defined by Action 0x08)
Definition: newgrf_config.h:84
_network_first_time
bool _network_first_time
Whether we have finished joining or not.
Definition: network.cpp:78
PACKET_CLIENT_CHAT
@ PACKET_CLIENT_CHAT
Client said something that should be distributed.
Definition: tcp_game.h:100
ClientNetworkGameSocketHandler::Receive_SERVER_NEWGAME
NetworkRecvStatus Receive_SERVER_NEWGAME(Packet *p) override
Let the clients know that the server is loading a new map.
Definition: network_client.cpp:1073
network_base.h
ShowErrorMessage
void ShowErrorMessage(StringID summary_msg, StringID detailed_msg, WarningLevel wl, int x=0, int y=0, const GRFFile *textref_stack_grffile=nullptr, uint textref_stack_size=0, const uint32 *textref_stack=nullptr)
Display an error message in a window.
Definition: error_gui.cpp:383
PacketReader::read_bytes
size_t read_bytes
The total number of read bytes.
Definition: network_client.cpp:49
Packet::Send_uint32
void Send_uint32(uint32 data)
Package a 32 bits integer in the packet.
Definition: packet.cpp:150
PACKET_CLIENT_JOIN
@ PACKET_CLIENT_JOIN
The client telling the server it wants to join.
Definition: tcp_game.h:38
ClientNetworkGameSocketHandler::SendChat
static NetworkRecvStatus SendChat(NetworkAction action, DestType type, int dest, const std::string &msg, int64 data)
Send a chat-packet over the network.
Definition: network_client.cpp:436
Packet::CanReadFromPacket
bool CanReadFromPacket(size_t bytes_to_read, bool close_connection=false)
Is it safe to read from the packet, i.e.
Definition: packet.cpp:218
Packet::Recv_string
std::string Recv_string(size_t length, StringValidationSettings settings=SVS_REPLACE_WITH_QUESTION_MARK)
Reads characters (bytes) from the packet until it finds a '\0', or reaches a maximum of length charac...
Definition: packet.cpp:380
ClientNetworkGameSocketHandler::Receive_SERVER_NEED_COMPANY_PASSWORD
NetworkRecvStatus Receive_SERVER_NEED_COMPANY_PASSWORD(Packet *p) override
Indication to the client that the server needs a company password: uint32 Generation seed.
Definition: network_client.cpp:743
CommandQueue::Append
void Append(CommandPacket *p)
Append a CommandPacket at the end of the queue.
Definition: network_command.cpp:57
ClientNetworkGameSocketHandler::Receive_SERVER_NEED_GAME_PASSWORD
NetworkRecvStatus Receive_SERVER_NEED_GAME_PASSWORD(Packet *p) override
Indication to the client that the server needs a game password.
Definition: network_client.cpp:729
ClientNetworkGameSocketHandler::SendJoin
static NetworkRecvStatus SendJoin()
Tell the server we would like to join.
Definition: network_client.cpp:343
last_ack_frame
static uint32 last_ack_frame
Last frame we performed an ack.
Definition: network_client.cpp:308
NetworkClientInfo::GetByClientID
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it's client-identifier.
Definition: network.cpp:112
_frame_counter_server
uint32 _frame_counter_server
The frame_counter of the server, if in network-mode.
Definition: network.cpp:68
NetworkJoinInfo::company
CompanyID company
The company to join.
Definition: network_client.h:117
GRFIdentifier
Basic data to distinguish a GRF.
Definition: newgrf_config.h:83
Packet::TransferOutWithLimit
ssize_t TransferOutWithLimit(F transfer_function, size_t limit, D destination, Args &&... args)
Transfer data from the packet to the given function.
Definition: packet.h:111
ClientNetworkGameSocketHandler::SendMove
static NetworkRecvStatus SendMove(CompanyID company, const std::string &password)
Ask the server to move us.
Definition: network_client.cpp:516
ClientNetworkGameSocketHandler::STATUS_MAP
@ STATUS_MAP
The client is downloading the map.
Definition: network_client.h:32
ClientNetworkGameSocketHandler::SendCompanyPassword
static NetworkRecvStatus SendCompanyPassword(const std::string &password)
Set the company password as requested.
Definition: network_client.cpp:383
ClearErrorMessages
void ClearErrorMessages()
Clear all errors from the queue.
Definition: error_gui.cpp:341
ClientNetworkGameSocketHandler::Receive_SERVER_MAP_DATA
NetworkRecvStatus Receive_SERVER_MAP_DATA(Packet *p) override
Sends the data of the map to the client: Contains a part of the map (until max size of packet).
Definition: network_client.cpp:820
COMPANY_NEW_COMPANY
@ COMPANY_NEW_COMPANY
The client wants a new company.
Definition: company_type.h:34
SLO_LOAD
@ SLO_LOAD
File is being loaded.
Definition: fileio_type.h:49
ClientNetworkGameSocketHandler::Receive_SERVER_FULL
NetworkRecvStatus Receive_SERVER_FULL(Packet *p) override
Notification that the server is full.
Definition: network_client.cpp:542
ClientNetworkGameSocketHandler::SendInformationQuery
static NetworkRecvStatus SendInformationQuery()
Make sure the server ID length is the same as a md5 hash.
Definition: network_client.cpp:334
PacketReader::CHUNK
static const size_t CHUNK
32 KiB chunks of memory.
Definition: network_client.cpp:42
Packet::Recv_uint32
uint32 Recv_uint32()
Read a 32 bits integer from the packet.
Definition: packet.cpp:335
ClientNetworkGameSocketHandler::SendSetName
static NetworkRecvStatus SendSetName(const std::string &name)
Tell the server that we like to change the name of the client.
Definition: network_client.cpp:477
CommandPacket
Everything we need to know about a command to be able to execute it.
Definition: network_internal.h:107
_date
Date _date
Current date in days (day counter)
Definition: date.cpp:28
ClientNetworkGameSocketHandler::Receive_SERVER_CHECK_NEWGRFS
NetworkRecvStatus Receive_SERVER_CHECK_NEWGRFS(Packet *p) override
Sends information about all used GRFs to the client: uint8 Amount of GRFs (the following data is repe...
Definition: network_client.cpp:696
GRFConfig
Information about GRF, used in the game and (part of it) in savegames.
Definition: newgrf_config.h:155
PacketReader::blocks
std::vector< byte * > blocks
Buffer with blocks of allocated memory.
Definition: network_client.cpp:44
NETWORK_RECV_STATUS_NEWGRF_MISMATCH
@ NETWORK_RECV_STATUS_NEWGRF_MISMATCH
We did not have the required NewGRFs.
Definition: core.h:25
NetworkMaxCompaniesReached
bool NetworkMaxCompaniesReached()
Check if max_companies has been reached on the server (local check only).
Definition: network_client.cpp:1350
NETWORK_RECV_STATUS_SERVER_FULL
@ NETWORK_RECV_STATUS_SERVER_FULL
The server is full.
Definition: core.h:30
ClientNetworkGameSocketHandler::IsConnected
static bool IsConnected()
Check whether the client is actually connected (and in the game).
Definition: network_client.cpp:529
StrTrimInPlace
void StrTrimInPlace(std::string &str)
Trim the spaces from given string in place, i.e.
Definition: string.cpp:355
NETWORK_RECV_STATUS_SERVER_ERROR
@ NETWORK_RECV_STATUS_SERVER_ERROR
The server told us we made an error.
Definition: core.h:29
GenerateCompanyPasswordHash
std::string GenerateCompanyPasswordHash(const std::string &password, const std::string &password_server_id, uint32 password_game_seed)
Hash the given password using server ID and game seed.
Definition: network.cpp:175
ClientNetworkGameSocketHandler::Receive_SERVER_WELCOME
NetworkRecvStatus Receive_SERVER_WELCOME(Packet *p) override
The client is joined and ready to receive their map: uint32 Own client ID.
Definition: network_client.cpp:761
ClientID
ClientID
'Unique' identifier to be given to clients
Definition: network_type.h:47
ClientNetworkGameSocketHandler::Receive_SERVER_JOIN
NetworkRecvStatus Receive_SERVER_JOIN(Packet *p) override
A client joined (PACKET_CLIENT_MAP_OK), what usually directly follows is a PACKET_SERVER_CLIENT_INFO:...
Definition: network_client.cpp:1044
_password_server_id
static std::string _password_server_id
The other bit of 'entropy' used to generate a salt for the company passwords.
Definition: network_client.cpp:313
NETWORK_RECV_STATUS_SERVER_BANNED
@ NETWORK_RECV_STATUS_SERVER_BANNED
The server has banned us.
Definition: core.h:31
NetworkUpdateClientName
void NetworkUpdateClientName(const std::string &client_name)
Send the server our name as callback from the setting.
Definition: network_client.cpp:1286
ClientNetworkGameSocketHandler::connection_string
std::string connection_string
Address we are connected to.
Definition: network_client.h:18
NetworkClient_Connected
void NetworkClient_Connected()
Is called after a client is connected to the server.
Definition: network_client.cpp:1182
PACKET_CLIENT_NEWGRFS_CHECKED
@ PACKET_CLIENT_NEWGRFS_CHECKED
Client acknowledges that it has all required NewGRFs.
Definition: tcp_game.h:61
CCA_NEW
@ CCA_NEW
Create a new company.
Definition: company_type.h:65
_sync_seed_1
uint32 _sync_seed_1
Seed to compare during sync checks.
Definition: network.cpp:73
PacketReader::Reset
void Reset() override
Reset this filter to read from the beginning of the file.
Definition: network_client.cpp:119
NetworkClientsToSpectators
void NetworkClientsToSpectators(CompanyID cid)
Move the clients of a company to the spectators.
Definition: network_client.cpp:1217
WL_INFO
@ WL_INFO
Used for DoCommand-like (and some non-fatal AI GUI) errors/information.
Definition: error.h:22
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
ClientNetworkGameSocketHandler::STATUS_JOIN
@ STATUS_JOIN
We are trying to join a server.
Definition: network_client.h:26
NetworkSocketHandler::MarkClosed
void MarkClosed()
Mark the connection as closed.
Definition: core.h:60
NETWORK_COMPANY_PASSWORD
@ NETWORK_COMPANY_PASSWORD
The password of the company.
Definition: network_type.h:82
PACKET_CLIENT_GAME_INFO
@ PACKET_CLIENT_GAME_INFO
Request information about the server.
Definition: tcp_game.h:47
NetworkSettings::client_name
std::string client_name
name of the player (as client)
Definition: settings_type.h:284
IsValidConsoleColour
bool IsValidConsoleColour(TextColour c)
Check whether the given TextColour is valid for console usage.
Definition: console_gui.cpp:524
NETWORK_RECV_STATUS_CLOSE_QUERY
@ NETWORK_RECV_STATUS_CLOSE_QUERY
Done querying the server.
Definition: core.h:32
NetworkTCPSocketHandler::SendPacket
virtual void SendPacket(Packet *packet)
This function puts the packet in the send-queue and it is send as soon as possible.
Definition: tcp.cpp:81
CLIENT_ID_SERVER
@ CLIENT_ID_SERVER
Servers always have this ID.
Definition: network_type.h:49
ClientNetworkGameSocketHandler::SendRCon
static NetworkRecvStatus SendRCon(const std::string &password, const std::string &command)
Send a console command.
Definition: network_client.cpp:502
NETWORK_SERVER_ID_LENGTH
static const uint NETWORK_SERVER_ID_LENGTH
The maximum length of the network id of the servers, in bytes including '\0'.
Definition: config.h:59
_networking
bool _networking
are we in networking mode?
Definition: network.cpp:56
ClientNetworkGameSocketHandler::STATUS_MAP_WAIT
@ STATUS_MAP_WAIT
The client is waiting as someone else is downloading the map.
Definition: network_client.h:31
network_client.h
CommandPacket::my_cmd
bool my_cmd
did the command originate from "me"
Definition: network_internal.h:113
DoAutoOrNetsave
void DoAutoOrNetsave(FiosNumberedSaveName &counter)
Create an autosave or netsave.
Definition: saveload.cpp:3331
_network_reconnect
uint8 _network_reconnect
Reconnect timeout.
Definition: network.cpp:64
PACKET_CLIENT_MAP_OK
@ PACKET_CLIENT_MAP_OK
Client tells the server that it received the whole map.
Definition: tcp_game.h:80
Packet
Internal entity of a packet.
Definition: packet.h:44
GameMode
GameMode
Mode which defines the state of the game.
Definition: openttd.h:17
NetworkGameSocketHandler::ReceiveCommand
const char * ReceiveCommand(Packet *p, CommandPacket *cp)
Receives a command from the network.
Definition: network_command.cpp:295
Randomizer::state
uint32 state[2]
The state of the randomizer.
Definition: random_func.hpp:23
PacketReader::buf
byte * buf
Buffer we're going to write to/read from.
Definition: network_client.cpp:45
BSWAP32
static uint32 BSWAP32(uint32 x)
Perform a 32 bits endianness bitswap on x.
Definition: bitmath_func.hpp:390
GUISettings::prefer_teamchat
bool prefer_teamchat
choose the chat message target with <ENTER>, true=all clients, false=your team
Definition: settings_type.h:121
DeserializeNetworkGameInfo
void DeserializeNetworkGameInfo(Packet *p, NetworkGameInfo *info, const GameInfoNewGRFLookupTable *newgrf_lookup_table)
Deserializes the NetworkGameInfo struct from the packet.
Definition: game_info.cpp:256
_network_server_max_companies
static uint8 _network_server_max_companies
Maximum number of companies of the currently joined server.
Definition: network_client.cpp:316
StateGameLoop
void StateGameLoop()
State controlling game loop.
Definition: openttd.cpp:1316
_network_own_client_id
ClientID _network_own_client_id
Our client identifier.
Definition: network.cpp:62
NetworkClientSendChat
void NetworkClientSendChat(NetworkAction action, DestType type, int dest, const std::string &msg, int64 data)
Send a chat message.
Definition: network_client.cpp:1315
PACKET_CLIENT_SET_NAME
@ PACKET_CLIENT_SET_NAME
A client changes its name.
Definition: tcp_game.h:113
ClientNetworkGameSocketHandler::Receive
static bool Receive()
Check whether we received/can send some data from/to the server and when that's the case handle it ap...
Definition: network_client.cpp:236
NetworkGameSocketHandler::GetInfo
NetworkClientInfo * GetInfo() const
Gets the client info of this socket handler.
Definition: tcp_game.h:530
ClientNetworkGameSocketHandler::Receive_SERVER_CONFIG_UPDATE
NetworkRecvStatus Receive_SERVER_CONFIG_UPDATE(Packet *p) override
Update the clients knowledge of the max settings: uint8 Maximum number of companies allowed.
Definition: network_client.cpp:1132
_switch_mode
SwitchMode _switch_mode
The next mainloop command.
Definition: gfx.cpp:46
StringID
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
NetworkSocketHandler::HasClientQuit
bool HasClientQuit() const
Whether the current client connected to the socket has quit.
Definition: core.h:68
NetworkTCPSocketHandler::SendPackets
SendPacketsState SendPackets(bool closing_down=false)
Sends all the buffered packets out for this client.
Definition: tcp.cpp:99
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
NETWORK_RCONCOMMAND_LENGTH
static const uint NETWORK_RCONCOMMAND_LENGTH
The maximum length of a rconsole command, in bytes including '\0'.
Definition: config.h:64
NetworkTCPSocketHandler::CanSendReceive
bool CanSendReceive()
Check whether this socket can send or receive something.
Definition: tcp.cpp:218
Pool::PoolItem<&_networkclientinfo_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:386
FiosNumberedSaveName
A savegame name automatically numbered.
Definition: fios.h:131
DetailedFileType
DetailedFileType
Kinds of files in each AbstractFileType.
Definition: fileio_type.h:28
Pool::PoolItem<&_company_pool >::GetNumItems
static size_t GetNumItems()
Returns number of valid items in the pool.
Definition: pool_type.hpp:367
ClientNetworkGameSocketHandler::SendCommand
static NetworkRecvStatus SendCommand(const CommandPacket *cp)
Send a command to the server.
Definition: network_client.cpp:426
PacketReader::TransferOutMemCopy
static ssize_t TransferOutMemCopy(PacketReader *destination, const char *source, size_t amount)
Simple wrapper around fwrite to be able to pass it to Packet's TransferOut.
Definition: network_client.cpp:70
Backup::Restore
void Restore()
Restore the variable.
Definition: backup_type.hpp:112
ClientNetworkGameSocketHandler::STATUS_GAME_INFO
@ STATUS_GAME_INFO
We are trying to get the game information.
Definition: network_client.h:25
Packet::Recv_bool
bool Recv_bool()
Read a boolean from the packet.
Definition: packet.cpp:297
Packet::Send_uint64
void Send_uint64(uint64 data)
Package a 64 bits integer in the packet.
Definition: packet.cpp:163
ClientNetworkGameSocketHandler::Receive_SERVER_ERROR_QUIT
NetworkRecvStatus Receive_SERVER_ERROR_QUIT(Packet *p) override
Inform all clients that one client made an error and thus has quit/been disconnected: uint32 ID of th...
Definition: network_client.cpp:1007
GetDrawStringCompanyColour
TextColour GetDrawStringCompanyColour(CompanyID company)
Get the colour for DrawString-subroutines which matches the colour of the company.
Definition: company_cmd.cpp:131
NetworkClientSetCompanyPassword
void NetworkClientSetCompanyPassword(const std::string &password)
Set/Reset company password on the client side.
Definition: network_client.cpp:1324
NO_DIRECTORY
@ NO_DIRECTORY
A path without any base directory.
Definition: fileio_type.h:125
ClientNetworkGameSocketHandler::STATUS_AUTHORIZED
@ STATUS_AUTHORIZED
The client is authorized at the server.
Definition: network_client.h:30
COMPANY_SPECTATOR
@ COMPANY_SPECTATOR
The client is spectating.
Definition: company_type.h:35
PACKET_CLIENT_GAME_PASSWORD
@ PACKET_CLIENT_GAME_PASSWORD
Clients sends the (hashed) game password.
Definition: tcp_game.h:65
NetworkJoinInfo
Information required to join a server.
Definition: network_client.h:114
NetworkRecvStatus
NetworkRecvStatus
Status of a network client; reasons why a client has quit.
Definition: core.h:22
ClientNetworkGameSocketHandler::SendError
static NetworkRecvStatus SendError(NetworkErrorCode errorno)
Send an error-packet over the network.
Definition: network_client.cpp:451
WC_NETWORK_STATUS_WINDOW
@ WC_NETWORK_STATUS_WINDOW
Network status window; Window numbers:
Definition: window_type.h:477
ClientNetworkGameSocketHandler::Receive_SERVER_SYNC
NetworkRecvStatus Receive_SERVER_SYNC(Packet *p) override
Sends a sync-check to the client: uint32 Frame counter.
Definition: network_client.cpp:926
ClientNetworkGameSocketHandler::ClientError
void ClientError(NetworkRecvStatus res)
Handle an error coming from the client side.
Definition: network_client.cpp:186
ClientNetworkGameSocketHandler::token
byte token
The token we need to send back to the server to prove we're the right client.
Definition: network_client.h:20
Pool::PoolItem<&_networkclientinfo_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:307
ClientNetworkGameSocketHandler::STATUS_AUTH_GAME
@ STATUS_AUTH_GAME
Last action was requesting game (server) password.
Definition: network_client.h:28
PacketReader::bufe
byte * bufe
End of the buffer we write to/read from.
Definition: network_client.cpp:46
Subdirectory
Subdirectory
The different kinds of subdirectories OpenTTD uses.
Definition: fileio_type.h:108
game_info.h
ClientNetworkGameSocketHandler::NetworkExecuteLocalCommandQueue
friend void NetworkExecuteLocalCommandQueue()
Execute all commands on the local command queue that ought to be executed this frame.
Definition: network_command.cpp:190
PACKET_CLIENT_RCON
@ PACKET_CLIENT_RCON
Client asks the server to execute some command.
Definition: tcp_game.h:104
Packet::Recv_uint8
uint8 Recv_uint8()
Read a 8 bits integer from the packet.
Definition: packet.cpp:306
ClientNetworkGameSocketHandler::~ClientNetworkGameSocketHandler
~ClientNetworkGameSocketHandler()
Clear whatever we assigned.
Definition: network_client.cpp:151
WL_ERROR
@ WL_ERROR
Errors (eg. saving/loading failed)
Definition: error.h:24
ClientNetworkGameSocketHandler::Receive_SERVER_COMMAND
NetworkRecvStatus Receive_SERVER_COMMAND(Packet *p) override
Sends a DoCommand to the client: uint8 ID of the company (0..MAX_COMPANIES-1).
Definition: network_client.cpp:939
SM_MENU
@ SM_MENU
Switch to game intro menu.
Definition: openttd.h:32
ClientNetworkGameSocketHandler
Class for handling the client side of the game connection.
Definition: network_client.h:16
CMD_COMPANY_CTRL
@ CMD_COMPANY_CTRL
used in multiplayer to create a new companies etc.
Definition: command_type.h:281
ClientNetworkGameSocketHandler::Receive_SERVER_SHUTDOWN
NetworkRecvStatus Receive_SERVER_SHUTDOWN(Packet *p) override
Let the clients know that the server is closing.
Definition: network_client.cpp:1060
NetworkGameSocketHandler::incoming_queue
CommandQueue incoming_queue
The command-queue awaiting handling.
Definition: tcp_game.h:504
_sync_frame
uint32 _sync_frame
The frame to perform the sync check.
Definition: network.cpp:77
error
void CDECL error(const char *s,...)
Error handling for fatal non-user errors.
Definition: openttd.cpp:132
CheckGameCompatibility
void CheckGameCompatibility(NetworkGameInfo &ngi)
Check if an game entry is compatible with our client.
Definition: game_info.cpp:107
NetworkGameList
Structure with information shown in the game list (GUI)
Definition: network_gamelist.h:18
network.h
NetworkGameSocketHandler::client_id
ClientID client_id
Client identifier.
Definition: tcp_game.h:501
Packet::Send_string
void Send_string(const std::string_view data)
Sends a string over the network.
Definition: packet.cpp:181
MILLISECONDS_PER_TICK
static const uint MILLISECONDS_PER_TICK
The number of milliseconds per game tick.
Definition: gfx_type.h:310
Debug
#define Debug(name, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
ClientNetworkGameSocketHandler::SendGetMap
static NetworkRecvStatus SendGetMap()
Request the map from the server.
Definition: network_client.cpp:392
LoadFilter
Interface for filtering a savegame till it is loaded.
Definition: saveload_filter.h:14
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:378
ClientNetworkGameSocketHandler::Receive_SERVER_RCON
NetworkRecvStatus Receive_SERVER_RCON(Packet *p) override
Send the result of an issues RCon command back to the client: uint16 Colour code.
Definition: network_client.cpp:1090
ClientSettings::network
NetworkSettings network
settings related to the network
Definition: settings_type.h:594
Packet::Recv_uint64
uint64 Recv_uint64()
Read a 64 bits integer from the packet.
Definition: packet.cpp:352
CloseWindowById
void CloseWindowById(WindowClass cls, WindowNumber number, bool force)
Close a window by its class and window number (if it is open).
Definition: window.cpp:1176
ClientNetworkGameSocketHandler::SendMapOk
static NetworkRecvStatus SendMapOk()
Tell the server we received the complete map.
Definition: network_client.cpp:402
NetworkGameSocketHandler::CloseConnection
NetworkRecvStatus CloseConnection(bool error=true) override
Functions to help ReceivePacket/SendPacket a bit A socket can make errors.
Definition: tcp_game.cpp:41
PACKET_CLIENT_ACK
@ PACKET_CLIENT_ACK
The client tells the server which frame it has executed.
Definition: tcp_game.h:92
PACKET_CLIENT_MOVE
@ PACKET_CLIENT_MOVE
A client would like to be moved to another company.
Definition: tcp_game.h:108
ClientNetworkGameSocketHandler::savegame
struct PacketReader * savegame
Packet reader for reading the savegame.
Definition: network_client.h:19
ClientNetworkGameSocketHandler::SendAck
static NetworkRecvStatus SendAck()
Send an acknowledgement from the server's ticks.
Definition: network_client.cpp:412
NETWORK_RECV_STATUS_OKAY
@ NETWORK_RECV_STATUS_OKAY
Everything is okay.
Definition: core.h:23
network_gamelist.h
SafeLoad
bool SafeLoad(const std::string &filename, SaveLoadOperation fop, DetailedFileType dft, GameMode newgm, Subdirectory subdir, struct LoadFilter *lf=nullptr)
Load the specified savegame but on error do different things.
Definition: openttd.cpp:933
ClientNetworkGameSocketHandler::Receive_SERVER_MAP_DONE
NetworkRecvStatus Receive_SERVER_MAP_DONE(Packet *p) override
Sends that all data of the map are sent to the client:
Definition: network_client.cpp:834
PacketReader::PacketReader
PacketReader()
Initialise everything.
Definition: network_client.cpp:52
md5sumToString
char * md5sumToString(char *buf, const char *last, const uint8 md5sum[16])
Convert the md5sum to a hexadecimal string representation.
Definition: string.cpp:553
ClientNetworkGameSocketHandler::SendQuit
static NetworkRecvStatus SendQuit()
Tell the server we would like to quit.
Definition: network_client.cpp:489
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:326
ClientNetworkGameSocketHandler::STATUS_ACTIVE
@ STATUS_ACTIVE
The client is active within in the game.
Definition: network_client.h:33
ClientNetworkGameSocketHandler::status
ServerStatus status
Status of the connection with the server.
Definition: network_client.h:37
FGCM_EXACT
@ FGCM_EXACT
Only find Grfs matching md5sum.
Definition: newgrf_config.h:199
NETWORK_RECV_STATUS_SAVEGAME
@ NETWORK_RECV_STATUS_SAVEGAME
Something went wrong (down)loading the savegame.
Definition: core.h:26
ClientNetworkGameSocketHandler::SendGamePassword
static NetworkRecvStatus SendGamePassword(const std::string &password)
Set the game password as requested.
Definition: network_client.cpp:371
NetworkGameList::info
NetworkGameInfo info
The game information of this server.
Definition: network_gamelist.h:21
ClientNetworkGameSocketHandler::Receive_SERVER_MAP_SIZE
NetworkRecvStatus Receive_SERVER_MAP_SIZE(Packet *p) override
Sends the size of the map to the client.
Definition: network_client.cpp:809
WN_NETWORK_STATUS_WINDOW_JOIN
@ WN_NETWORK_STATUS_WINDOW_JOIN
Network join status.
Definition: window_type.h:31
CC_WARNING
static const TextColour CC_WARNING
Colour for warning lines.
Definition: console_type.h:25
free
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: stdafx.h:460
NetworkMakeClientNameUnique
bool NetworkMakeClientNameUnique(std::string &new_name)
Check whether a name is unique, and otherwise try to make it unique.
Definition: network_server.cpp:1541
ClientNetworkGameSocketHandler::Receive_SERVER_QUIT
NetworkRecvStatus Receive_SERVER_QUIT(Packet *p) override
Notification that a client left the game: uint32 ID of the client.
Definition: network_client.cpp:1024
Packet::RemainingBytesToTransfer
size_t RemainingBytesToTransfer() const
Get the amount of bytes that are still available for the Transfer functions.
Definition: packet.cpp:402
_network_join
NetworkJoinInfo _network_join
Information about the game to join to.
Definition: network_client.cpp:321
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3146
NetworkGameList::online
bool online
False if the server did not respond (default status)
Definition: network_gamelist.h:23
lastof
#define lastof(x)
Get the last element of an fixed size array.
Definition: stdafx.h:394
ClientNetworkGameSocketHandler::Receive_SERVER_MOVE
NetworkRecvStatus Receive_SERVER_MOVE(Packet *p) override
Move a client from one company into another: uint32 ID of the client.
Definition: network_client.cpp:1104
NetworkServerGameInfo::grfconfig
GRFConfig * grfconfig
List of NewGRF files used.
Definition: game_info.h:94
ClientNetworkGameSocketHandler::SendSetPassword
static NetworkRecvStatus SendSetPassword(const std::string &password)
Tell the server that we like to change the password of the company.
Definition: network_client.cpp:464
ClientNetworkGameSocketHandler::Send
static void Send()
Send the packets of this socket handler.
Definition: network_client.cpp:251
_network_join_bytes
uint32 _network_join_bytes
The number of bytes we already downloaded.
Definition: network_gui.cpp:2116
DAY_TICKS
static const int DAY_TICKS
1 day is 74 ticks; _date_fract used to be uint16 and incremented by 885.
Definition: date_type.h:28
NetworkErrorCode
NetworkErrorCode
The error codes we send around in the protocols.
Definition: network_type.h:118
NetworkClientInfo
Container for all information known about a client.
Definition: network_base.h:24
NetworkIsValidClientName
bool NetworkIsValidClientName(const std::string_view client_name)
Check whether the given client name is deemed valid for use in network games.
Definition: network_client.cpp:1239
PACKET_CLIENT_SET_PASSWORD
@ PACKET_CLIENT_SET_PASSWORD
A client (re)sets its company's password.
Definition: tcp_game.h:112
SetDParamStr
void SetDParamStr(uint n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition: strings.cpp:296
PACKET_CLIENT_COMPANY_PASSWORD
@ PACKET_CLIENT_COMPANY_PASSWORD
Client sends the (hashed) company password.
Definition: tcp_game.h:67
INVALID_STRING_ID
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition: settings_type.h:593
WL_CRITICAL
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
Definition: error.h:25
NETWORK_GAME_PASSWORD
@ NETWORK_GAME_PASSWORD
The password of the game.
Definition: network_type.h:81
Packet::Recv_uint16
uint16 Recv_uint16()
Read a 16 bits integer from the packet.
Definition: packet.cpp:320
NetworkSettings::max_companies
uint8 max_companies
maximum amount of companies
Definition: settings_type.h:292
Packet::pos
PacketSize pos
The current read/write position in the packet.
Definition: packet.h:49
ClientNetworkGameSocketHandler::Receive_SERVER_WAIT
NetworkRecvStatus Receive_SERVER_WAIT(Packet *p) override
Notification that another client is currently receiving the map: uint8 Number of clients waiting in f...
Definition: network_client.cpp:776
NETWORK_RECV_STATUS_MALFORMED_PACKET
@ NETWORK_RECV_STATUS_MALFORMED_PACKET
We apparently send a malformed packet.
Definition: core.h:28
IConsolePrint
void IConsolePrint(TextColour colour_code, const std::string &string)
Handle the printing of text entered into the console or redirected there by any other means.
Definition: console.cpp:94