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

OpenTTD Source 1.11.0-RC1

network.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
12 #include "../strings_func.h"
13 #include "../command_func.h"
14 #include "../date_func.h"
15 #include "network_admin.h"
16 #include "network_client.h"
17 #include "network_server.h"
18 #include "network_content.h"
19 #include "network_udp.h"
20 #include "network_gamelist.h"
21 #include "network_base.h"
22 #include "core/udp.h"
23 #include "core/host.h"
24 #include "network_gui.h"
25 #include "../console_func.h"
26 #include "../3rdparty/md5/md5.h"
27 #include "../core/random_func.hpp"
28 #include "../window_func.h"
29 #include "../company_func.h"
30 #include "../company_base.h"
31 #include "../landscape_type.h"
32 #include "../rev.h"
33 #include "../core/pool_func.hpp"
34 #include "../gfx_func.h"
35 #include "../error.h"
36
37 #include "../safeguards.h"
38
39 #ifdef DEBUG_DUMP_COMMANDS
40 #include "../fileio_func.h"
42 bool _ddc_fastforward = true;
43 #endif /* DEBUG_DUMP_COMMANDS */
44
46 static_assert(NetworkClientInfoPool::MAX_SIZE == NetworkClientSocketPool::MAX_SIZE);
47
49 NetworkClientInfoPool _networkclientinfo_pool("NetworkClientInfo");
50 INSTANTIATE_POOL_METHODS(NetworkClientInfo)
51
52 bool _networking;
53 bool _network_server;
54 bool _network_available;
55 bool _network_dedicated;
56 bool _is_network_server;
57 NetworkServerGameInfo _network_game_info;
58 NetworkCompanyState *_network_company_states = nullptr;
59 ClientID _network_own_client_id;
60 ClientID _redirect_console_to_client;
61 bool _network_need_advertise;
62 uint8 _network_reconnect;
63 StringList _network_bind_list;
64 StringList _network_host_list;
65 StringList _network_ban_list;
66 uint32 _frame_counter_server;
67 uint32 _frame_counter_max;
68 uint32 _frame_counter;
69 uint32 _last_sync_frame;
70 NetworkAddressList _broadcast_list;
71 uint32 _sync_seed_1;
72 #ifdef NETWORK_SEND_DOUBLE_SEED
73 uint32 _sync_seed_2;
74 #endif
75 uint32 _sync_frame;
76 bool _network_first_time;
77 bool _network_udp_server;
78 uint16 _network_udp_broadcast;
79 uint8 _network_advertise_retries;
80 CompanyMask _network_company_passworded;
81
82 /* Check whether NETWORK_NUM_LANDSCAPES is still in sync with NUM_LANDSCAPE */
83 static_assert((int)NETWORK_NUM_LANDSCAPES == (int)NUM_LANDSCAPE);
84 static_assert((int)NETWORK_COMPANY_NAME_LENGTH == MAX_LENGTH_COMPANY_NAME_CHARS * MAX_CHAR_LENGTH);
85
86 extern NetworkUDPSocketHandler *_udp_client_socket;
87 extern NetworkUDPSocketHandler *_udp_server_socket;
88 extern NetworkUDPSocketHandler *_udp_master_socket;
89
91 byte _network_clients_connected = 0;
92
93 /* Some externs / forwards */
94 extern void StateGameLoop();
95
100 bool HasClients()
101 {
102 return !NetworkClientSocket::Iterate().empty();
103 }
104
108 NetworkClientInfo::~NetworkClientInfo()
109 {
110 /* Delete the chat window, if you were chatting with this client. */
111 InvalidateWindowData(WC_SEND_NETWORK_MSG, DESTTYPE_CLIENT, this->client_id);
112 }
113
119 /* static */ NetworkClientInfo *NetworkClientInfo::GetByClientID(ClientID client_id)
120 {
121 for (NetworkClientInfo *ci : NetworkClientInfo::Iterate()) {
122 if (ci->client_id == client_id) return ci;
123 }
124
125 return nullptr;
126 }
127
133 /* static */ ServerNetworkGameSocketHandler *ServerNetworkGameSocketHandler::GetByClientID(ClientID client_id)
134 {
135 for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
136 if (cs->client_id == client_id) return cs;
137 }
138
139 return nullptr;
140 }
141
142 byte NetworkSpectatorCount()
143 {
144 byte count = 0;
145
146 for (const NetworkClientInfo *ci : NetworkClientInfo::Iterate()) {
147 if (ci->client_playas == COMPANY_SPECTATOR) count++;
148 }
149
150 /* Don't count a dedicated server as spectator */
151 if (_network_dedicated) count--;
152
153 return count;
154 }
155
162 const char *NetworkChangeCompanyPassword(CompanyID company_id, const char *password)
163 {
164 if (strcmp(password, "*") == 0) password = "";
165
166 if (_network_server) {
167 NetworkServerSetCompanyPassword(company_id, password, false);
168 } else {
169 NetworkClientSetCompanyPassword(password);
170 }
171
172 return password;
173 }
174
182 const char *GenerateCompanyPasswordHash(const char *password, const char *password_server_id, uint32 password_game_seed)
183 {
184 if (StrEmpty(password)) return password;
185
186 char salted_password[NETWORK_SERVER_ID_LENGTH];
187
188 memset(salted_password, 0, sizeof(salted_password));
189 seprintf(salted_password, lastof(salted_password), "%s", password);
190 /* Add the game seed and the server's ID as the salt. */
191 for (uint i = 0; i < NETWORK_SERVER_ID_LENGTH - 1; i++) {
192 salted_password[i] ^= password_server_id[i] ^ (password_game_seed >> (i % 32));
193 }
194
195 Md5 checksum;
196 uint8 digest[16];
197 static char hashed_password[NETWORK_SERVER_ID_LENGTH];
198
199 /* Generate the MD5 hash */
200 checksum.Append(salted_password, sizeof(salted_password) - 1);
201 checksum.Finish(digest);
202
203 for (int di = 0; di < 16; di++) seprintf(hashed_password + di * 2, lastof(hashed_password), "%02x", digest[di]);
204
205 return hashed_password;
206 }
207
213 bool NetworkCompanyIsPassworded(CompanyID company_id)
214 {
215 return HasBit(_network_company_passworded, company_id);
216 }
217
218 /* This puts a text-message to the console, or in the future, the chat-box,
219 * (to keep it all a bit more general)
220 * If 'self_send' is true, this is the client who is sending the message */
221 void NetworkTextMessage(NetworkAction action, TextColour colour, bool self_send, const char *name, const char *str, int64 data)
222 {
223 StringID strid;
224 switch (action) {
225 case NETWORK_ACTION_SERVER_MESSAGE:
226 /* Ignore invalid messages */
227 strid = STR_NETWORK_SERVER_MESSAGE;
228 colour = CC_DEFAULT;
229 break;
230 case NETWORK_ACTION_COMPANY_SPECTATOR:
231 colour = CC_DEFAULT;
232 strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_SPECTATE;
233 break;
234 case NETWORK_ACTION_COMPANY_JOIN:
235 colour = CC_DEFAULT;
236 strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_JOIN;
237 break;
238 case NETWORK_ACTION_COMPANY_NEW:
239 colour = CC_DEFAULT;
240 strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_NEW;
241 break;
242 case NETWORK_ACTION_JOIN:
243 /* Show the Client ID for the server but not for the client. */
244 strid = _network_server ? STR_NETWORK_MESSAGE_CLIENT_JOINED_ID : STR_NETWORK_MESSAGE_CLIENT_JOINED;
245 break;
246 case NETWORK_ACTION_LEAVE: strid = STR_NETWORK_MESSAGE_CLIENT_LEFT; break;
247 case NETWORK_ACTION_NAME_CHANGE: strid = STR_NETWORK_MESSAGE_NAME_CHANGE; break;
248 case NETWORK_ACTION_GIVE_MONEY: strid = STR_NETWORK_MESSAGE_GIVE_MONEY; break;
249 case NETWORK_ACTION_CHAT_COMPANY: strid = self_send ? STR_NETWORK_CHAT_TO_COMPANY : STR_NETWORK_CHAT_COMPANY; break;
250 case NETWORK_ACTION_CHAT_CLIENT: strid = self_send ? STR_NETWORK_CHAT_TO_CLIENT : STR_NETWORK_CHAT_CLIENT; break;
251 case NETWORK_ACTION_KICKED: strid = STR_NETWORK_MESSAGE_KICKED; break;
252 default: strid = STR_NETWORK_CHAT_ALL; break;
253 }
254
255 char message[1024];
256 SetDParamStr(0, name);
257 SetDParamStr(1, str);
258 SetDParam(2, data);
259
260 /* All of these strings start with "***". These characters are interpreted as both left-to-right and
261 * right-to-left characters depending on the context. As the next text might be an user's name, the
262 * user name's characters will influence the direction of the "***" instead of the language setting
263 * of the game. Manually set the direction of the "***" by inserting a text-direction marker. */
264 char *msg_ptr = message + Utf8Encode(message, _current_text_dir == TD_LTR ? CHAR_TD_LRM : CHAR_TD_RLM);
265 GetString(msg_ptr, strid, lastof(message));
266
267 DEBUG(desync, 1, "msg: %08x; %02x; %s", _date, _date_fract, message);
268 IConsolePrintF(colour, "%s", message);
269 NetworkAddChatMessage((TextColour)colour, _settings_client.gui.network_chat_timeout, "%s", message);
270 }
271
272 /* Calculate the frame-lag of a client */
273 uint NetworkCalculateLag(const NetworkClientSocket *cs)
274 {
275 int lag = cs->last_frame_server - cs->last_frame;
276 /* This client has missed his ACK packet after 1 DAY_TICKS..
277 * so we increase his lag for every frame that passes!
278 * The packet can be out by a max of _net_frame_freq */
279 if (cs->last_frame_server + DAY_TICKS + _settings_client.network.frame_freq < _frame_counter) {
280 lag += _frame_counter - (cs->last_frame_server + DAY_TICKS + _settings_client.network.frame_freq);
281 }
282 return lag;
283 }
284
285
286 /* There was a non-recoverable error, drop back to the main menu with a nice
287 * error */
288 void NetworkError(StringID error_string)
289 {
290 _switch_mode = SM_MENU;
291 ShowErrorMessage(error_string, INVALID_STRING_ID, WL_CRITICAL);
292 }
293
299 StringID GetNetworkErrorMsg(NetworkErrorCode err)
300 {
301 /* List of possible network errors, used by
302 * PACKET_SERVER_ERROR and PACKET_CLIENT_ERROR */
303 static const StringID network_error_strings[] = {
304 STR_NETWORK_ERROR_CLIENT_GENERAL,
305 STR_NETWORK_ERROR_CLIENT_DESYNC,
306 STR_NETWORK_ERROR_CLIENT_SAVEGAME,
307 STR_NETWORK_ERROR_CLIENT_CONNECTION_LOST,
308 STR_NETWORK_ERROR_CLIENT_PROTOCOL_ERROR,
309 STR_NETWORK_ERROR_CLIENT_NEWGRF_MISMATCH,
310 STR_NETWORK_ERROR_CLIENT_NOT_AUTHORIZED,
311 STR_NETWORK_ERROR_CLIENT_NOT_EXPECTED,
312 STR_NETWORK_ERROR_CLIENT_WRONG_REVISION,
313 STR_NETWORK_ERROR_CLIENT_NAME_IN_USE,
314 STR_NETWORK_ERROR_CLIENT_WRONG_PASSWORD,
315 STR_NETWORK_ERROR_CLIENT_COMPANY_MISMATCH,
316 STR_NETWORK_ERROR_CLIENT_KICKED,
317 STR_NETWORK_ERROR_CLIENT_CHEATER,
318 STR_NETWORK_ERROR_CLIENT_SERVER_FULL,
319 STR_NETWORK_ERROR_CLIENT_TOO_MANY_COMMANDS,
320 STR_NETWORK_ERROR_CLIENT_TIMEOUT_PASSWORD,
321 STR_NETWORK_ERROR_CLIENT_TIMEOUT_COMPUTER,
322 STR_NETWORK_ERROR_CLIENT_TIMEOUT_MAP,
323 STR_NETWORK_ERROR_CLIENT_TIMEOUT_JOIN,
324 };
325 static_assert(lengthof(network_error_strings) == NETWORK_ERROR_END);
326
327 if (err >= (ptrdiff_t)lengthof(network_error_strings)) err = NETWORK_ERROR_GENERAL;
328
329 return network_error_strings[err];
330 }
331
337 void NetworkHandlePauseChange(PauseMode prev_mode, PauseMode changed_mode)
338 {
339 if (!_networking) return;
340
341 switch (changed_mode) {
342 case PM_PAUSED_NORMAL:
343 case PM_PAUSED_JOIN:
344 case PM_PAUSED_GAME_SCRIPT:
345 case PM_PAUSED_ACTIVE_CLIENTS:
346 case PM_PAUSED_LINK_GRAPH: {
347 bool changed = ((_pause_mode == PM_UNPAUSED) != (prev_mode == PM_UNPAUSED));
348 bool paused = (_pause_mode != PM_UNPAUSED);
349 if (!paused && !changed) return;
350
351 StringID str;
352 if (!changed) {
353 int i = -1;
354
355 if ((_pause_mode & PM_PAUSED_NORMAL) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL);
356 if ((_pause_mode & PM_PAUSED_JOIN) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS);
357 if ((_pause_mode & PM_PAUSED_GAME_SCRIPT) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_GAME_SCRIPT);
358 if ((_pause_mode & PM_PAUSED_ACTIVE_CLIENTS) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS);
359 if ((_pause_mode & PM_PAUSED_LINK_GRAPH) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_LINK_GRAPH);
360 str = STR_NETWORK_SERVER_MESSAGE_GAME_STILL_PAUSED_1 + i;
361 } else {
362 switch (changed_mode) {
363 case PM_PAUSED_NORMAL: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL); break;
364 case PM_PAUSED_JOIN: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS); break;
365 case PM_PAUSED_GAME_SCRIPT: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_GAME_SCRIPT); break;
366 case PM_PAUSED_ACTIVE_CLIENTS: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS); break;
367 case PM_PAUSED_LINK_GRAPH: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_LINK_GRAPH); break;
368 default: NOT_REACHED();
369 }
370 str = paused ? STR_NETWORK_SERVER_MESSAGE_GAME_PAUSED : STR_NETWORK_SERVER_MESSAGE_GAME_UNPAUSED;
371 }
372
373 char buffer[DRAW_STRING_BUFFER];
374 GetString(buffer, str, lastof(buffer));
375 NetworkTextMessage(NETWORK_ACTION_SERVER_MESSAGE, CC_DEFAULT, false, nullptr, buffer);
376 break;
377 }
378
379 default:
380 return;
381 }
382 }
383
384
393 static void CheckPauseHelper(bool pause, PauseMode pm)
394 {
395 if (pause == ((_pause_mode & pm) != PM_UNPAUSED)) return;
396
397 DoCommandP(0, pm, pause ? 1 : 0, CMD_PAUSE);
398 }
399
405 static uint NetworkCountActiveClients()
406 {
407 uint count = 0;
408
409 for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
410 if (cs->status != NetworkClientSocket::STATUS_ACTIVE) continue;
411 if (!Company::IsValidID(cs->GetInfo()->client_playas)) continue;
412 count++;
413 }
414
415 return count;
416 }
417
421 static void CheckMinActiveClients()
422 {
423 if ((_pause_mode & PM_PAUSED_ERROR) != PM_UNPAUSED ||
424 !_network_dedicated ||
425 (_settings_client.network.min_active_clients == 0 && (_pause_mode & PM_PAUSED_ACTIVE_CLIENTS) == PM_UNPAUSED)) {
426 return;
427 }
428 CheckPauseHelper(NetworkCountActiveClients() < _settings_client.network.min_active_clients, PM_PAUSED_ACTIVE_CLIENTS);
429 }
430
435 static bool NetworkHasJoiningClient()
436 {
437 for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
438 if (cs->status >= NetworkClientSocket::STATUS_AUTHORIZED && cs->status < NetworkClientSocket::STATUS_ACTIVE) return true;
439 }
440
441 return false;
442 }
443
447 static void CheckPauseOnJoin()
448 {
449 if ((_pause_mode & PM_PAUSED_ERROR) != PM_UNPAUSED ||
450 (!_settings_client.network.pause_on_join && (_pause_mode & PM_PAUSED_JOIN) == PM_UNPAUSED)) {
451 return;
452 }
453 CheckPauseHelper(NetworkHasJoiningClient(), PM_PAUSED_JOIN);
454 }
455
464 void ParseConnectionString(const char **company, const char **port, char *connection_string)
465 {
466 bool ipv6 = (strchr(connection_string, ':') != strrchr(connection_string, ':'));
467 char *p;
468 for (p = connection_string; *p != '\0'; p++) {
469 switch (*p) {
470 case '[':
471 ipv6 = true;
472 break;
473
474 case ']':
475 ipv6 = false;
476 break;
477
478 case '#':
479 *company = p + 1;
480 *p = '\0';
481 break;
482
483 case ':':
484 if (ipv6) break;
485 *port = p + 1;
486 *p = '\0';
487 break;
488 }
489 }
490 }
491
497 /* static */ void ServerNetworkGameSocketHandler::AcceptConnection(SOCKET s, const NetworkAddress &address)
498 {
499 /* Register the login */
500 _network_clients_connected++;
501
502 SetWindowDirty(WC_CLIENT_LIST, 0);
503 ServerNetworkGameSocketHandler *cs = new ServerNetworkGameSocketHandler(s);
504 cs->client_address = address; // Save the IP of the client
505 }
506
511 static void InitializeNetworkPools(bool close_admins = true)
512 {
513 PoolBase::Clean(PT_NCLIENT | (close_admins ? PT_NADMIN : PT_NONE));
514 }
515
520 void NetworkClose(bool close_admins)
521 {
522 if (_network_server) {
523 if (close_admins) {
524 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::Iterate()) {
525 as->CloseConnection(true);
526 }
527 }
528
529 for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
530 cs->CloseConnection(NETWORK_RECV_STATUS_CONN_LOST);
531 }
532 ServerNetworkGameSocketHandler::CloseListeners();
533 ServerNetworkAdminSocketHandler::CloseListeners();
534 } else if (MyClient::my_client != nullptr) {
535 MyClient::SendQuit();
536 MyClient::my_client->CloseConnection(NETWORK_RECV_STATUS_CONN_LOST);
537 }
538
539 TCPConnecter::KillAll();
540
541 _networking = false;
542 _network_server = false;
543
544 NetworkFreeLocalCommandQueue();
545
546 free(_network_company_states);
547 _network_company_states = nullptr;
548
549 InitializeNetworkPools(close_admins);
550 }
551
552 /* Initializes the network (cleans sockets and stuff) */
553 static void NetworkInitialize(bool close_admins = true)
554 {
555 InitializeNetworkPools(close_admins);
556 NetworkUDPInitialize();
557
558 _sync_frame = 0;
559 _network_first_time = true;
560
561 _network_reconnect = 0;
562 }
563
565 class TCPQueryConnecter : TCPConnecter {
566 public:
567 TCPQueryConnecter(const NetworkAddress &address) : TCPConnecter(address) {}
568
569 void OnFailure() override
570 {
571 NetworkDisconnect();
572 }
573
574 void OnConnect(SOCKET s) override
575 {
576 _networking = true;
577 new ClientNetworkGameSocketHandler(s);
578 MyClient::SendCompanyInformationQuery();
579 }
580 };
581
582 /* Query a server to fetch his game-info
583 * If game_info is true, only the gameinfo is fetched,
584 * else only the client_info is fetched */
585 void NetworkTCPQueryServer(NetworkAddress address)
586 {
587 if (!_network_available) return;
588
589 NetworkDisconnect();
590 NetworkInitialize();
591
592 new TCPQueryConnecter(address);
593 }
594
595 /* Validates an address entered as a string and adds the server to
596 * the list. If you use this function, the games will be marked
597 * as manually added. */
598 void NetworkAddServer(const char *b)
599 {
600 if (*b != '\0') {
601 const char *port = nullptr;
602 const char *company = nullptr;
603 char host[NETWORK_HOSTNAME_LENGTH];
604 uint16 rport;
605
606 strecpy(host, b, lastof(host));
607
608 strecpy(_settings_client.network.connect_to_ip, b, lastof(_settings_client.network.connect_to_ip));
609 rport = NETWORK_DEFAULT_PORT;
610
611 ParseConnectionString(&company, &port, host);
612 if (port != nullptr) rport = atoi(port);
613
614 NetworkUDPQueryServer(NetworkAddress(host, rport), true);
615 }
616 }
617
623 void GetBindAddresses(NetworkAddressList *addresses, uint16 port)
624 {
625 for (const auto &iter : _network_bind_list) {
626 addresses->emplace_back(iter.c_str(), port);
627 }
628
629 /* No address, so bind to everything. */
630 if (addresses->size() == 0) {
631 addresses->emplace_back("", port);
632 }
633 }
634
635 /* Generates the list of manually added hosts from NetworkGameList and
636 * dumps them into the array _network_host_list. This array is needed
637 * by the function that generates the config file. */
638 void NetworkRebuildHostList()
639 {
640 _network_host_list.clear();
641
642 for (NetworkGameList *item = _network_game_list; item != nullptr; item = item->next) {
643 if (item->manually) _network_host_list.emplace_back(item->address.GetAddressAsString(false));
644 }
645 }
646
648 class TCPClientConnecter : TCPConnecter {
649 public:
650 TCPClientConnecter(const NetworkAddress &address) : TCPConnecter(address) {}
651
652 void OnFailure() override
653 {
654 NetworkError(STR_NETWORK_ERROR_NOCONNECTION);
655 }
656
657 void OnConnect(SOCKET s) override
658 {
659 _networking = true;
660 new ClientNetworkGameSocketHandler(s);
661 IConsoleCmdExec("exec scripts/on_client.scr 0");
662 NetworkClient_Connected();
663 }
664 };
665
666
667 /* Used by clients, to connect to a server */
668 void NetworkClientConnectGame(NetworkAddress address, CompanyID join_as, const char *join_server_password, const char *join_company_password)
669 {
670 if (!_network_available) return;
671
672 if (address.GetPort() == 0) return;
673
674 strecpy(_settings_client.network.last_host, address.GetHostname(), lastof(_settings_client.network.last_host));
675 _settings_client.network.last_port = address.GetPort();
676 _network_join_as = join_as;
677 _network_join_server_password = join_server_password;
678 _network_join_company_password = join_company_password;
679
680 NetworkDisconnect();
681 NetworkInitialize();
682
683 _network_join_status = NETWORK_JOIN_STATUS_CONNECTING;
684 ShowJoinStatusWindow();
685
686 new TCPClientConnecter(address);
687 }
688
689 static void NetworkInitGameInfo()
690 {
691 if (StrEmpty(_settings_client.network.server_name)) {
692 seprintf(_settings_client.network.server_name, lastof(_settings_client.network.server_name), "Unnamed Server");
693 }
694
695 /* The server is a client too */
696 _network_game_info.clients_on = _network_dedicated ? 0 : 1;
697
698 /* There should be always space for the server. */
699 assert(NetworkClientInfo::CanAllocateItem());
700 NetworkClientInfo *ci = new NetworkClientInfo(CLIENT_ID_SERVER);
701 ci->client_playas = _network_dedicated ? COMPANY_SPECTATOR : COMPANY_FIRST;
702
703 strecpy(ci->client_name, _settings_client.network.client_name, lastof(ci->client_name));
704 }
705
706 bool NetworkServerStart()
707 {
708 if (!_network_available) return false;
709
710 /* Call the pre-scripts */
711 IConsoleCmdExec("exec scripts/pre_server.scr 0");
712 if (_network_dedicated) IConsoleCmdExec("exec scripts/pre_dedicated.scr 0");
713
714 NetworkDisconnect(false, false);
715 NetworkInitialize(false);
716 DEBUG(net, 1, "starting listeners for clients");
717 if (!ServerNetworkGameSocketHandler::Listen(_settings_client.network.server_port)) return false;
718
719 /* Only listen for admins when the password isn't empty. */
720 if (!StrEmpty(_settings_client.network.admin_password)) {
721 DEBUG(net, 1, "starting listeners for admins");
722 if (!ServerNetworkAdminSocketHandler::Listen(_settings_client.network.server_admin_port)) return false;
723 }
724
725 /* Try to start UDP-server */
726 DEBUG(net, 1, "starting listeners for incoming server queries");
727 _network_udp_server = _udp_server_socket->Listen();
728
729 _network_company_states = CallocT<NetworkCompanyState>(MAX_COMPANIES);
730 _network_server = true;
731 _networking = true;
732 _frame_counter = 0;
733 _frame_counter_server = 0;
734 _frame_counter_max = 0;
735 _last_sync_frame = 0;
736 _network_own_client_id = CLIENT_ID_SERVER;
737
738 _network_clients_connected = 0;
739 _network_company_passworded = 0;
740
741 NetworkInitGameInfo();
742
743 /* execute server initialization script */
744 IConsoleCmdExec("exec scripts/on_server.scr 0");
745 /* if the server is dedicated ... add some other script */
746 if (_network_dedicated) IConsoleCmdExec("exec scripts/on_dedicated.scr 0");
747
748 /* Try to register us to the master server */
749 _network_need_advertise = true;
750 NetworkUDPAdvertise();
751
752 /* welcome possibly still connected admins - this can only happen on a dedicated server. */
753 if (_network_dedicated) ServerNetworkAdminSocketHandler::WelcomeAll();
754
755 return true;
756 }
757
758 /* The server is rebooting...
759 * The only difference with NetworkDisconnect, is the packets that is sent */
760 void NetworkReboot()
761 {
762 if (_network_server) {
763 for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
764 cs->SendNewGame();
765 cs->SendPackets();
766 }
767
768 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
769 as->SendNewGame();
770 as->SendPackets();
771 }
772 }
773
774 /* For non-dedicated servers we have to kick the admins as we are not
775 * certain that we will end up in a new network game. */
776 NetworkClose(!_network_dedicated);
777 }
778
784 void NetworkDisconnect(bool blocking, bool close_admins)
785 {
786 if (_network_server) {
787 for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
788 cs->SendShutdown();
789 cs->SendPackets();
790 }
791
792 if (close_admins) {
793 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
794 as->SendShutdown();
795 as->SendPackets();
796 }
797 }
798 }
799
800 if (_settings_client.network.server_advertise) NetworkUDPRemoveAdvertise(blocking);
801
802 DeleteWindowById(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
803
804 NetworkClose(close_admins);
805
806 /* Reinitialize the UDP stack, i.e. close all existing connections. */
807 NetworkUDPInitialize();
808 }
809
814 static bool NetworkReceive()
815 {
816 if (_network_server) {
817 ServerNetworkAdminSocketHandler::Receive();
818 return ServerNetworkGameSocketHandler::Receive();
819 } else {
820 return ClientNetworkGameSocketHandler::Receive();
821 }
822 }
823
824 /* This sends all buffered commands (if possible) */
825 static void NetworkSend()
826 {
827 if (_network_server) {
828 ServerNetworkAdminSocketHandler::Send();
829 ServerNetworkGameSocketHandler::Send();
830 } else {
831 ClientNetworkGameSocketHandler::Send();
832 }
833 }
834
840 void NetworkBackgroundLoop()
841 {
842 _network_content_client.SendReceive();
843 TCPConnecter::CheckCallbacks();
844 NetworkHTTPSocketHandler::HTTPReceive();
845
846 NetworkBackgroundUDPLoop();
847 }
848
849 /* The main loop called from ttd.c
850 * Here we also have to do StateGameLoop if needed! */
851 void NetworkGameLoop()
852 {
853 if (!_networking) return;
854
855 if (!NetworkReceive()) return;
856
857 if (_network_server) {
858 /* Log the sync state to check for in-syncedness of replays. */
859 if (_date_fract == 0) {
860 /* We don't want to log multiple times if paused. */
861 static Date last_log;
862 if (last_log != _date) {
863 DEBUG(desync, 1, "sync: %08x; %02x; %08x; %08x", _date, _date_fract, _random.state[0], _random.state[1]);
864 last_log = _date;
865 }
866 }
867
868 #ifdef DEBUG_DUMP_COMMANDS
869 /* Loading of the debug commands from -ddesync>=1 */
870 static FILE *f = FioFOpenFile("commands.log", "rb", SAVE_DIR);
871 static Date next_date = 0;
872 static uint32 next_date_fract;
873 static CommandPacket *cp = nullptr;
874 static bool check_sync_state = false;
875 static uint32 sync_state[2];
876 if (f == nullptr && next_date == 0) {
877 DEBUG(net, 0, "Cannot open commands.log");
878 next_date = 1;
879 }
880
881 while (f != nullptr && !feof(f)) {
882 if (_date == next_date && _date_fract == next_date_fract) {
883 if (cp != nullptr) {
884 NetworkSendCommand(cp->tile, cp->p1, cp->p2, cp->cmd & ~CMD_FLAGS_MASK, nullptr, cp->text, cp->company);
885 DEBUG(net, 0, "injecting: %08x; %02x; %02x; %06x; %08x; %08x; %08x; \"%s\" (%s)", _date, _date_fract, (int)_current_company, cp->tile, cp->p1, cp->p2, cp->cmd, cp->text, GetCommandName(cp->cmd));
886 free(cp);
887 cp = nullptr;
888 }
889 if (check_sync_state) {
890 if (sync_state[0] == _random.state[0] && sync_state[1] == _random.state[1]) {
891 DEBUG(net, 0, "sync check: %08x; %02x; match", _date, _date_fract);
892 } else {
893 DEBUG(net, 0, "sync check: %08x; %02x; mismatch expected {%08x, %08x}, got {%08x, %08x}",
894 _date, _date_fract, sync_state[0], sync_state[1], _random.state[0], _random.state[1]);
895 NOT_REACHED();
896 }
897 check_sync_state = false;
898 }
899 }
900
901 if (cp != nullptr || check_sync_state) break;
902
903 char buff[4096];
904 if (fgets(buff, lengthof(buff), f) == nullptr) break;
905
906 char *p = buff;
907 /* Ignore the "[date time] " part of the message */
908 if (*p == '[') {
909 p = strchr(p, ']');
910 if (p == nullptr) break;
911 p += 2;
912 }
913
914 if (strncmp(p, "cmd: ", 5) == 0
915 #ifdef DEBUG_FAILED_DUMP_COMMANDS
916 || strncmp(p, "cmdf: ", 6) == 0
917 #endif
918 ) {
919 p += 5;
920 if (*p == ' ') p++;
921 cp = CallocT<CommandPacket>(1);
922 int company;
923 static_assert(sizeof(cp->text) == 128);
924 int ret = sscanf(p, "%x; %x; %x; %x; %x; %x; %x; \"%127[^\"]\"", &next_date, &next_date_fract, &company, &cp->tile, &cp->p1, &cp->p2, &cp->cmd, cp->text);
925 /* There are 8 pieces of data to read, however the last is a
926 * string that might or might not exist. Ignore it if that
927 * string misses because in 99% of the time it's not used. */
928 assert(ret == 8 || ret == 7);
929 cp->company = (CompanyID)company;
930 } else if (strncmp(p, "join: ", 6) == 0) {
931 /* Manually insert a pause when joining; this way the client can join at the exact right time. */
932 int ret = sscanf(p + 6, "%x; %x", &next_date, &next_date_fract);
933 assert(ret == 2);
934 DEBUG(net, 0, "injecting pause for join at %08x:%02x; please join when paused", next_date, next_date_fract);
935 cp = CallocT<CommandPacket>(1);
936 cp->company = COMPANY_SPECTATOR;
937 cp->cmd = CMD_PAUSE;
938 cp->p1 = PM_PAUSED_NORMAL;
939 cp->p2 = 1;
940 _ddc_fastforward = false;
941 } else if (strncmp(p, "sync: ", 6) == 0) {
942 int ret = sscanf(p + 6, "%x; %x; %x; %x", &next_date, &next_date_fract, &sync_state[0], &sync_state[1]);
943 assert(ret == 4);
944 check_sync_state = true;
945 } else if (strncmp(p, "msg: ", 5) == 0 || strncmp(p, "client: ", 8) == 0 ||
946 strncmp(p, "load: ", 6) == 0 || strncmp(p, "save: ", 6) == 0) {
947 /* A message that is not very important to the log playback, but part of the log. */
948 #ifndef DEBUG_FAILED_DUMP_COMMANDS
949 } else if (strncmp(p, "cmdf: ", 6) == 0) {
950 DEBUG(net, 0, "Skipping replay of failed command: %s", p + 6);
951 #endif
952 } else {
953 /* Can't parse a line; what's wrong here? */
954 DEBUG(net, 0, "trying to parse: %s", p);
955 NOT_REACHED();
956 }
957 }
958 if (f != nullptr && feof(f)) {
959 DEBUG(net, 0, "End of commands.log");
960 fclose(f);
961 f = nullptr;
962 }
963 #endif /* DEBUG_DUMP_COMMANDS */
964 if (_frame_counter >= _frame_counter_max) {
965 /* Only check for active clients just before we're going to send out
966 * the commands so we don't send multiple pause/unpause commands when
967 * the frame_freq is more than 1 tick. Same with distributing commands. */
968 CheckPauseOnJoin();
969 CheckMinActiveClients();
970 NetworkDistributeCommands();
971 }
972
973 bool send_frame = false;
974
975 /* We first increase the _frame_counter */
976 _frame_counter++;
977 /* Update max-frame-counter */
978 if (_frame_counter > _frame_counter_max) {
979 _frame_counter_max = _frame_counter + _settings_client.network.frame_freq;
980 send_frame = true;
981 }
982
983 NetworkExecuteLocalCommandQueue();
984
985 /* Then we make the frame */
986 StateGameLoop();
987
988 _sync_seed_1 = _random.state[0];
989 #ifdef NETWORK_SEND_DOUBLE_SEED
990 _sync_seed_2 = _random.state[1];
991 #endif
992
993 NetworkServer_Tick(send_frame);
994 } else {
995 /* Client */
996
997 /* Make sure we are at the frame were the server is (quick-frames) */
998 if (_frame_counter_server > _frame_counter) {
999 /* Run a number of frames; when things go bad, get out. */
1000 while (_frame_counter_server > _frame_counter) {
1001 if (!ClientNetworkGameSocketHandler::GameLoop()) return;
1002 }
1003 } else {
1004 /* Else, keep on going till _frame_counter_max */
1005 if (_frame_counter_max > _frame_counter) {
1006 /* Run one frame; if things went bad, get out. */
1007 if (!ClientNetworkGameSocketHandler::GameLoop()) return;
1008 }
1009 }
1010 }
1011
1012 NetworkSend();
1013 }
1014
1015 static void NetworkGenerateServerId()
1016 {
1017 Md5 checksum;
1018 uint8 digest[16];
1019 char hex_output[16 * 2 + 1];
1020 char coding_string[NETWORK_NAME_LENGTH];
1021 int di;
1022
1023 seprintf(coding_string, lastof(coding_string), "%d%s", (uint)Random(), "OpenTTD Server ID");
1024
1025 /* Generate the MD5 hash */
1026 checksum.Append((const uint8*)coding_string, strlen(coding_string));
1027 checksum.Finish(digest);
1028
1029 for (di = 0; di < 16; ++di) {
1030 seprintf(hex_output + di * 2, lastof(hex_output), "%02x", digest[di]);
1031 }
1032
1033 /* _settings_client.network.network_id is our id */
1034 seprintf(_settings_client.network.network_id, lastof(_settings_client.network.network_id), "%s", hex_output);
1035 }
1036
1037 void NetworkStartDebugLog(NetworkAddress address)
1038 {
1039 extern SOCKET _debug_socket; // Comes from debug.c
1040
1041 DEBUG(net, 0, "Redirecting DEBUG() to %s:%d", address.GetHostname(), address.GetPort());
1042
1043 SOCKET s = address.Connect();
1044 if (s == INVALID_SOCKET) {
1045 DEBUG(net, 0, "Failed to open socket for redirection DEBUG()");
1046 return;
1047 }
1048
1049 _debug_socket = s;
1050
1051 DEBUG(net, 0, "DEBUG() is now redirected");
1052 }
1053
1055 void NetworkStartUp()
1056 {
1057 DEBUG(net, 3, "[core] starting network...");
1058
1059 /* Network is available */
1060 _network_available = NetworkCoreInitialize();
1061 _network_dedicated = false;
1062 _network_need_advertise = true;
1063 _network_advertise_retries = 0;
1064
1065 /* Generate an server id when there is none yet */
1066 if (StrEmpty(_settings_client.network.network_id)) NetworkGenerateServerId();
1067
1068 memset(&_network_game_info, 0, sizeof(_network_game_info));
1069
1070 NetworkInitialize();
1071 DEBUG(net, 3, "[core] network online, multiplayer available");
1072 NetworkFindBroadcastIPs(&_broadcast_list);
1073 }
1074
1076 void NetworkShutDown()
1077 {
1078 NetworkDisconnect(true);
1079 NetworkUDPClose();
1080
1081 DEBUG(net, 3, "[core] shutting down network");
1082
1083 _network_available = false;
1084
1085 NetworkCoreShutdown();
1086 }
1087
1092 static const uint GITHASH_SUFFIX_LEN = 12;
1093
1098 const char * GetNetworkRevisionString()
1099 {
1100 /* This will be allocated on heap and never free'd, but only once so not a "real" leak. */
1101 static char *network_revision = nullptr;
1102
1103 if (!network_revision) {
1104 /* Start by taking a chance on the full revision string. */
1105 network_revision = stredup(_openttd_revision);
1106 /* Ensure it's not longer than the packet buffer length. */
1107 if (strlen(network_revision) >= NETWORK_REVISION_LENGTH) network_revision[NETWORK_REVISION_LENGTH - 1] = '\0';
1108
1109 /* Tag names are not mangled further. */
1110 if (_openttd_revision_tagged) {
1111 DEBUG(net, 1, "Network revision name is '%s'", network_revision);
1112 return network_revision;
1113 }
1114
1115 /* Prepare a prefix of the git hash.
1116 * Size is length + 1 for terminator, +2 for -g prefix. */
1117 assert(_openttd_revision_modified < 3);
1118 char githash_suffix[GITHASH_SUFFIX_LEN + 1] = "-";
1119 githash_suffix[1] = "gum"[_openttd_revision_modified];
1120 for (uint i = 2; i < GITHASH_SUFFIX_LEN; i++) {
1121 githash_suffix[i] = _openttd_revision_hash[i-2];
1122 }
1123
1124 /* Where did the hash start in the original string?
1125 * Overwrite from that position, unless that would go past end of packet buffer length. */
1126 ptrdiff_t hashofs = strrchr(_openttd_revision, '-') - _openttd_revision;
1127 if (hashofs + strlen(githash_suffix) + 1 > NETWORK_REVISION_LENGTH) hashofs = strlen(network_revision) - strlen(githash_suffix);
1128 /* Replace the git hash in revision string. */
1129 strecpy(network_revision + hashofs, githash_suffix, network_revision + NETWORK_REVISION_LENGTH);
1130 assert(strlen(network_revision) < NETWORK_REVISION_LENGTH); // strlen does not include terminator, constant does, hence strictly less than
1131 DEBUG(net, 1, "Network revision name is '%s'", network_revision);
1132 }
1133
1134 return network_revision;
1135 }
1136
1137 static const char *ExtractNetworkRevisionHash(const char *revstr)
1138 {
1139 return strrchr(revstr, '-');
1140 }
1141
1147 bool IsNetworkCompatibleVersion(const char *other)
1148 {
1149 if (strncmp(GetNetworkRevisionString(), other, NETWORK_REVISION_LENGTH - 1) == 0) return true;
1150
1151 /* If this version is tagged, then the revision string must be a complete match,
1152 * since there is no git hash suffix in it.
1153 * This is needed to avoid situations like "1.9.0-beta1" comparing equal to "2.0.0-beta1". */
1154 if (_openttd_revision_tagged) return false;
1155
1156 const char *hash1 = ExtractNetworkRevisionHash(GetNetworkRevisionString());
1157 const char *hash2 = ExtractNetworkRevisionHash(other);
1158 return hash1 && hash2 && (strncmp(hash1, hash2, GITHASH_SUFFIX_LEN) == 0);
1159 }
1160
1161 #ifdef __EMSCRIPTEN__
1162 extern "C" {
1163
1164 void CDECL em_openttd_add_server(const char *host, int port)
1165 {
1166 NetworkUDPQueryServer(NetworkAddress(host, port), true);
1167 }
1168
1169 }
1170 #endif
network_content.h
TCPConnecter::CheckCallbacks
static void CheckCallbacks()
Check whether we need to call the callback, i.e.
Definition: tcp_connect.cpp:65
TCPConnecter::TCPConnecter
TCPConnecter(const NetworkAddress &address)
Create a new connecter for the given address.
Definition: tcp_connect.cpp:26
host.h
NetworkAddress::Connect
SOCKET Connect()
Connect to the given address.
Definition: address.cpp:340
CommandContainer::cmd
uint32 cmd
command being executed.
Definition: command_type.h:483
NetworkSettings::client_name
char client_name[NETWORK_CLIENT_NAME_LENGTH]
name of the player (as client)
Definition: settings_type.h:270
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:3321
_frame_counter
uint32 _frame_counter
The current frame.
Definition: network.cpp:68
_udp_client_socket
NetworkUDPSocketHandler * _udp_client_socket
udp client socket
Definition: network_udp.cpp:46
NETWORK_DEFAULT_PORT
static const uint16 NETWORK_DEFAULT_PORT
The default port of the game server (TCP & UDP)
Definition: config.h:29
NetworkClientSetCompanyPassword
void NetworkClientSetCompanyPassword(const char *password)
Set/Reset company password on the client side.
Definition: network_client.cpp:1293
SAVE_DIR
@ SAVE_DIR
Base directory for all savegames.
Definition: fileio_type.h:110
NetworkUDPSocketHandler
Base socket handler for all UDP sockets.
Definition: udp.h:46
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3220
ClientNetworkContentSocketHandler::SendReceive
void SendReceive()
Check whether we received/can send some data from/to the content server and when that's the case hand...
Definition: network_content.cpp:779
NetworkServerSetCompanyPassword
void NetworkServerSetCompanyPassword(CompanyID company_id, const char *password, bool already_hashed)
Set/Reset a company password on the server end.
Definition: network_server.cpp:1780
_network_game_info
NetworkServerGameInfo _network_game_info
Information about our game.
Definition: network.cpp:57
GetBindAddresses
void GetBindAddresses(NetworkAddressList *addresses, uint16 port)
Get the addresses to bind to.
Definition: network.cpp:623
NetworkSettings::frame_freq
uint8 frame_freq
how often do we send commands to the clients
Definition: settings_type.h:251
NetworkSettings::server_port
uint16 server_port
port the server listens on
Definition: settings_type.h:262
TCPConnecter
"Helper" class for creating TCP connections in a non-blocking manner
Definition: tcp.h:64
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:40
NetworkClientInfo::client_playas
CompanyID client_playas
As which company is this client playing (CompanyID)
Definition: network_base.h:27
TD_LTR
@ TD_LTR
Text is written left-to-right by default.
Definition: strings_type.h:23
NetworkSettings::connect_to_ip
char connect_to_ip[NETWORK_HOSTNAME_LENGTH]
default for the "Add server" query
Definition: settings_type.h:272
_network_join_as
CompanyID _network_join_as
Who would we like to join as.
Definition: network_client.cpp:326
_date_fract
DateFract _date_fract
Fractional part of the day.
Definition: date.cpp:29
NetworkCompanyState
Some state information of a company, especially for servers.
Definition: network_type.h:64
_network_server
bool _network_server
network-server is active
Definition: network.cpp:53
_network_udp_broadcast
uint16 _network_udp_broadcast
Timeout for the UDP broadcasts.
Definition: network.cpp:78
_network_company_passworded
CompanyMask _network_company_passworded
Bitmask of the password status of all companies.
Definition: network.cpp:80
GetCommandName
const char * GetCommandName(uint32 cmd)
Definition: command.cpp:407
NetworkAction
NetworkAction
Actions that can be used for NetworkTextMessage.
Definition: network_type.h:91
NetworkClientInfo::client_name
char client_name[NETWORK_CLIENT_NAME_LENGTH]
Name of the client.
Definition: network_base.h:25
NETWORK_NUM_LANDSCAPES
static const uint NETWORK_NUM_LANDSCAPES
The number of landscapes in OpenTTD.
Definition: config.h:70
GetNetworkRevisionString
const char * GetNetworkRevisionString()
Get the network version string used by this build.
Definition: network.cpp:1098
WC_CLIENT_LIST
@ WC_CLIENT_LIST
Client list; Window numbers:
Definition: window_type.h:472
ServerNetworkAdminSocketHandler::WelcomeAll
static void WelcomeAll()
Send a Welcome packet to all connected admins.
Definition: network_admin.cpp:989
NetworkSettings::network_id
char network_id[NETWORK_SERVER_ID_LENGTH]
network ID for servers
Definition: settings_type.h:273
ClientNetworkGameSocketHandler::GameLoop
static bool GameLoop()
Actual game loop for the client.
Definition: network_client.cpp:266
TCPQueryConnecter::OnFailure
void OnFailure() override
Callback for when the connection attempt failed.
Definition: network.cpp:569
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
NetworkHasJoiningClient
static bool NetworkHasJoiningClient()
Checks whether there is a joining client.
Definition: network.cpp:435
Utf8Encode
size_t Utf8Encode(T buf, WChar c)
Encode a unicode character and place it in the buffer.
Definition: string.cpp:523
_networkclientinfo_pool
NetworkClientInfoPool _networkclientinfo_pool("NetworkClientInfo")
Make sure both pools have the same size.
NetworkSettings::pause_on_join
bool pause_on_join
pause the game when people join
Definition: settings_type.h:261
NetworkServerGameInfo
The game information that is not generated on-the-fly and has to be sent to the clients.
Definition: game.h:24
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:250
CommandContainer::p2
uint32 p2
parameter p2.
Definition: command_type.h:482
NetworkHandlePauseChange
void NetworkHandlePauseChange(PauseMode prev_mode, PauseMode changed_mode)
Handle the pause mode change so we send the right messages to the chat.
Definition: network.cpp:337
ServerNetworkAdminSocketHandler::IterateActive
static Pool::IterateWrapperFiltered< ServerNetworkAdminSocketHandler, ServerNetworkAdminSocketHandlerFilter > IterateActive(size_t from=0)
Returns an iterable ensemble of all active admin sockets.
Definition: network_admin.h:95
_random
Randomizer _random
Random used in the game state calculations.
Definition: random_func.cpp:25
CommandContainer::text
char text[32 *MAX_CHAR_LENGTH]
possible text sent for name changes etc, in bytes including '\0'.
Definition: command_type.h:485
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:79
_network_bind_list
StringList _network_bind_list
The addresses to bind on.
Definition: network.cpp:63
NetworkUDPAdvertise
void NetworkUDPAdvertise()
Register us to the master server This function checks if it needs to send an advertise.
Definition: network_udp.cpp:571
NetworkBackgroundLoop
void NetworkBackgroundLoop()
We have to do some (simple) background stuff that runs normally, even when we are not in multiplayer.
Definition: network.cpp:840
network_gui.h
_network_join_status
NetworkJoinStatus _network_join_status
The status of joining.
Definition: network_gui.cpp:1976
GetNetworkErrorMsg
StringID GetNetworkErrorMsg(NetworkErrorCode err)
Retrieve the string id of an internal error number.
Definition: network.cpp:299
ClientNetworkGameSocketHandler::my_client
static ClientNetworkGameSocketHandler * my_client
This is us!
Definition: network_client.h:41
_network_join_company_password
const char * _network_join_company_password
Company password from -P argument.
Definition: network_client.cpp:331
NetworkSettings::admin_password
char admin_password[NETWORK_PASSWORD_LENGTH]
password for the admin network
Definition: settings_type.h:268
_redirect_console_to_client
ClientID _redirect_console_to_client
If not invalid, redirect the console output to a client.
Definition: network.cpp:60
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:159
GenerateCompanyPasswordHash
const char * GenerateCompanyPasswordHash(const char *password, const char *password_server_id, uint32 password_game_seed)
Hash the given password using server ID and game seed.
Definition: network.cpp:182
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:199
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:67
_network_first_time
bool _network_first_time
Whether we have finished joining or not.
Definition: network.cpp:76
NetworkServer_Tick
void NetworkServer_Tick(bool send_frame)
This is called every tick if this is a _network_server.
Definition: network_server.cpp:1809
ServerNetworkAdminSocketHandler::Send
static void Send()
Send the packets for the server sockets.
Definition: network_admin.cpp:95
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:372
MAX_CHAR_LENGTH
static const int MAX_CHAR_LENGTH
Max. length of UTF-8 encoded unicode character.
Definition: strings_type.h:18
_network_game_list
NetworkGameList * _network_game_list
Game list of this client.
Definition: network_gamelist.cpp:23
MAX_LENGTH_COMPANY_NAME_CHARS
static const uint MAX_LENGTH_COMPANY_NAME_CHARS
The maximum length of a company name in characters including '\0'.
Definition: company_type.h:40
NetworkClientInfo::~NetworkClientInfo
~NetworkClientInfo()
Basically a client is leaving us right now.
Definition: network.cpp:108
PM_UNPAUSED
@ PM_UNPAUSED
A normal unpaused game.
Definition: openttd.h:59
HasClients
bool HasClients()
Return whether there is any client connected or trying to connect at all.
Definition: network.cpp:100
NetworkUDPQueryServer
void NetworkUDPQueryServer(NetworkAddress address, bool manually)
Query a specific server.
Definition: network_udp.cpp:78
COMPANY_FIRST
@ COMPANY_FIRST
First company, same as owner.
Definition: company_type.h:22
NetworkClientInfo::GetByClientID
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it's client-identifier.
Definition: network.cpp:119
TCPQueryConnecter::OnConnect
void OnConnect(SOCKET s) override
Callback when the connection succeeded.
Definition: network.cpp:574
_frame_counter_server
uint32 _frame_counter_server
The frame_counter of the server, if in network-mode.
Definition: network.cpp:66
CommandPacket::company
CompanyID company
company that is executing the command
Definition: network_internal.h:153
CommandContainer::p1
uint32 p1
parameter p1.
Definition: command_type.h:481
ServerNetworkGameSocketHandler::Send
static void Send()
Send the packets for the server sockets.
Definition: network_server.cpp:330
_network_join_server_password
const char * _network_join_server_password
Login password from -p argument.
Definition: network_client.cpp:329
NETWORK_RECV_STATUS_CONN_LOST
@ NETWORK_RECV_STATUS_CONN_LOST
The connection is 'just' lost.
Definition: core.h:27
DRAW_STRING_BUFFER
static const int DRAW_STRING_BUFFER
Size of the buffer used for drawing strings.
Definition: gfx_func.h:85
CommandPacket
Everything we need to know about a command to be able to execute it.
Definition: network_internal.h:149
_date
Date _date
Current date in days (day counter)
Definition: date.cpp:28
DoCommandP
bool DoCommandP(const CommandContainer *container, bool my_cmd)
Shortcut for the long DoCommandP when having a container with the data.
Definition: command.cpp:541
NetworkSettings::last_host
char last_host[NETWORK_HOSTNAME_LENGTH]
IP address of the last joined server.
Definition: settings_type.h:285
NetworkAddressList
std::vector< NetworkAddress > NetworkAddressList
Type for a list of addresses.
Definition: address.h:20
CMD_PAUSE
@ CMD_PAUSE
pause the game
Definition: command_type.h:256
Pool::MAX_SIZE
static const size_t MAX_SIZE
Make template parameter accessible from outside.
Definition: pool_type.hpp:85
DEBUG
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:35
TCPListenHandler< ServerNetworkAdminSocketHandler, ADMIN_PACKET_SERVER_FULL, ADMIN_PACKET_SERVER_BANNED >::Receive
static bool Receive()
Handle the receiving of packets.
Definition: tcp_listen.h:99
FioFOpenFile
FILE * FioFOpenFile(const std::string &filename, const char *mode, Subdirectory subdir, size_t *filesize)
Opens a OpenTTD file somewhere in a personal or global directory.
Definition: fileio.cpp:406
NetworkAddress::GetHostname
const char * GetHostname()
Get the hostname; in case it wasn't given the IPv4 dotted representation is given.
Definition: address.cpp:22
ClientID
ClientID
'Unique' identifier to be given to clients
Definition: network_type.h:39
Date
int32 Date
The type to store our dates in.
Definition: date_type.h:14
NetworkSettings::min_active_clients
uint8 min_active_clients
minimum amount of active clients to unpause the game
Definition: settings_type.h:282
ParseConnectionString
void ParseConnectionString(const char **company, const char **port, char *connection_string)
Converts a string to ip/port/company Format: IP:port::company.
Definition: network.cpp:464
_pause_mode
PauseMode _pause_mode
The current pause mode.
Definition: gfx.cpp:47
NetworkClient_Connected
void NetworkClient_Connected()
Is called after a client is connected to the server.
Definition: network_client.cpp:1203
IsNetworkCompatibleVersion
bool IsNetworkCompatibleVersion(const char *other)
Checks whether the given version string is compatible with our version.
Definition: network.cpp:1147
TCPClientConnecter::OnFailure
void OnFailure() override
Callback for when the connection attempt failed.
Definition: network.cpp:652
_sync_seed_1
uint32 _sync_seed_1
Seed to compare during sync checks.
Definition: network.cpp:71
NetworkAddress::GetPort
uint16 GetPort() const
Get the port.
Definition: address.cpp:35
MAX_COMPANIES
@ MAX_COMPANIES
Maximum number of companies.
Definition: company_type.h:23
StringList
std::vector< std::string > StringList
Type for a list of strings.
Definition: string_type.h:58
TCPClientConnecter
Non blocking connection create to actually connect to servers.
Definition: network.cpp:648
NetworkDisconnect
void NetworkDisconnect(bool blocking, bool close_admins)
We want to disconnect from the host/clients.
Definition: network.cpp:784
CHAR_TD_RLM
static const WChar CHAR_TD_RLM
The next character acts like a right-to-left character.
Definition: string_type.h:40
InitializeNetworkPools
static void InitializeNetworkPools(bool close_admins=true)
Resets the pools used for network clients, and the admin pool if needed.
Definition: network.cpp:511
PoolBase::Clean
static void Clean(PoolType)
Clean all pools of given type.
Definition: pool_func.cpp:30
_udp_server_socket
NetworkUDPSocketHandler * _udp_server_socket
udp server socket
Definition: network_udp.cpp:47
NetworkShutDown
void NetworkShutDown()
This shuts the network down.
Definition: network.cpp:1076
CLIENT_ID_SERVER
@ CLIENT_ID_SERVER
Servers always have this ID.
Definition: network_type.h:41
PT_NADMIN
@ PT_NADMIN
Network admin pool.
Definition: pool_type.hpp:21
_network_company_states
NetworkCompanyState * _network_company_states
Statistics about some companies.
Definition: network.cpp:58
NetworkUDPRemoveAdvertise
void NetworkUDPRemoveAdvertise(bool blocking)
Remove our advertise from the master-server.
Definition: network_udp.cpp:519
StrEmpty
static bool StrEmpty(const char *s)
Check if a string buffer is empty.
Definition: string_func.h:60
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:43
_networking
bool _networking
are we in networking mode?
Definition: network.cpp:52
NetworkSettings::last_port
uint16 last_port
port of the last joined server
Definition: settings_type.h:286
CheckPauseHelper
static void CheckPauseHelper(bool pause, PauseMode pm)
Helper function for the pause checkers.
Definition: network.cpp:393
PT_NONE
@ PT_NONE
No pool is selected.
Definition: pool_type.hpp:18
ServerNetworkGameSocketHandler::GetByClientID
static ServerNetworkGameSocketHandler * GetByClientID(ClientID client_id)
Return the client state given it's client-identifier.
Definition: network.cpp:133
network_client.h
CMD_FLAGS_MASK
@ CMD_FLAGS_MASK
mask for all command flags
Definition: command_type.h:381
NetworkSettings::server_name
char server_name[NETWORK_NAME_LENGTH]
name of the server
Definition: settings_type.h:265
PauseMode
PauseMode
Modes of pausing we've got.
Definition: openttd.h:58
_network_reconnect
uint8 _network_reconnect
Reconnect timeout.
Definition: network.cpp:62
network_server.h
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:55
TCPConnecter::KillAll
static void KillAll()
Kill all connection attempts.
Definition: tcp_connect.cpp:94
TCPConnecter::address
NetworkAddress address
Address we're connecting to.
Definition: tcp.h:77
PM_PAUSED_GAME_SCRIPT
@ PM_PAUSED_GAME_SCRIPT
A game paused by a game script.
Definition: openttd.h:65
Randomizer::state
uint32 state[2]
The state of the randomizer.
Definition: random_func.hpp:23
NETWORK_REVISION_LENGTH
static const uint NETWORK_REVISION_LENGTH
The maximum length of the revision, in bytes including '\0'.
Definition: config.h:44
ServerNetworkGameSocketHandler::AcceptConnection
static void AcceptConnection(SOCKET s, const NetworkAddress &address)
Handle the accepting of a connection to the server.
Definition: network.cpp:497
PT_NCLIENT
@ PT_NCLIENT
Network client pools.
Definition: pool_type.hpp:20
NetworkCompanyIsPassworded
bool NetworkCompanyIsPassworded(CompanyID company_id)
Check if the company we want to join requires a password.
Definition: network.cpp:213
NetworkClientInfo::client_id
ClientID client_id
Client identifier (same as ClientState->client_id)
Definition: network_base.h:24
StateGameLoop
void StateGameLoop()
State controlling game loop.
Definition: openttd.cpp:1344
_network_own_client_id
ClientID _network_own_client_id
Our client identifier.
Definition: network.cpp:59
ClientNetworkGameSocketHandler::SendCompanyInformationQuery
static NetworkRecvStatus SendCompanyInformationQuery()
Make sure the server ID length is the same as a md5 hash.
Definition: network_client.cpp:342
NetworkSettings::server_advertise
bool server_advertise
advertise the server to the masterserver
Definition: settings_type.h:269
NetworkBackgroundUDPLoop
void NetworkBackgroundUDPLoop()
Receive the UDP packets.
Definition: network_udp.cpp:647
NetworkCoreShutdown
void NetworkCoreShutdown()
Shuts down the network core (as that is needed for some platforms.
Definition: core.cpp:44
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:241
_network_content_client
ClientNetworkContentSocketHandler _network_content_client
The client we use to connect to the server.
Definition: network_content.cpp:35
ServerNetworkGameSocketHandler
Class for handling the server side of the game connection.
Definition: network_server.h:24
PM_PAUSED_ACTIVE_CLIENTS
@ PM_PAUSED_ACTIVE_CLIENTS
A game paused for 'min_active_clients'.
Definition: openttd.h:64
_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
_ddc_fastforward
#define _ddc_fastforward
Helper variable to make the dedicated server go fast until the (first) join.
Definition: network_internal.h:47
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
NetworkAddress
Wrapper for (un)resolved network addresses; there's no reason to transform a numeric IP to a string a...
Definition: address.h:29
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:378
Pool
Base class for all pools.
Definition: pool_type.hpp:81
DeleteWindowById
void DeleteWindowById(WindowClass cls, WindowNumber number, bool force)
Delete a window by its class and window number (if it is open).
Definition: window.cpp:1165
network_udp.h
NetworkSendCommand
void NetworkSendCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback, const char *text, CompanyID company)
Prepare a DoCommand to be send over the network.
Definition: network_command.cpp:136
COMPANY_SPECTATOR
@ COMPANY_SPECTATOR
The client is spectating.
Definition: company_type.h:35
ServerNetworkAdminSocketHandler
Class for handling the server side of the game connection.
Definition: network_admin.h:25
CheckPauseOnJoin
static void CheckPauseOnJoin()
Check whether we should pause on join.
Definition: network.cpp:447
_network_clients_connected
byte _network_clients_connected
The amount of clients connected.
Definition: network.cpp:91
WC_NETWORK_STATUS_WINDOW
@ WC_NETWORK_STATUS_WINDOW
Network status window; Window numbers:
Definition: window_type.h:485
NetworkUDPInitialize
void NetworkUDPInitialize()
Initialize the whole UDP bit.
Definition: network_udp.cpp:603
PM_PAUSED_NORMAL
@ PM_PAUSED_NORMAL
A game normally paused.
Definition: openttd.h:60
NetworkHTTPSocketHandler::HTTPReceive
static void HTTPReceive()
Do the receiving for all HTTP connections.
Definition: tcp_http.cpp:295
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:299
NetworkCountActiveClients
static uint NetworkCountActiveClients()
Counts the number of active clients connected.
Definition: network.cpp:405
NetworkUDPSocketHandler::Listen
bool Listen()
Start listening on the given host and port.
Definition: udp.cpp:43
seprintf
int CDECL seprintf(char *str, const char *last, const char *format,...)
Safer implementation of snprintf; same as snprintf except:
Definition: string.cpp:442
udp.h
_network_need_advertise
bool _network_need_advertise
Whether we need to advertise.
Definition: network.cpp:61
SM_MENU
@ SM_MENU
Switch to game intro menu.
Definition: openttd.h:31
ClientNetworkGameSocketHandler
Class for handling the client side of the game connection.
Definition: network_client.h:16
PM_PAUSED_LINK_GRAPH
@ PM_PAUSED_LINK_GRAPH
A game paused due to the link graph schedule lagging.
Definition: openttd.h:66
NetworkFindBroadcastIPs
void NetworkFindBroadcastIPs(NetworkAddressList *broadcast)
Find the IPv4 broadcast addresses; IPv6 uses a completely different strategy for broadcasting.
Definition: host.cpp:194
_network_udp_server
bool _network_udp_server
Is the UDP server started?
Definition: network.cpp:77
INSTANTIATE_POOL_METHODS
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
Definition: pool_func.hpp:224
stredup
char * stredup(const char *s, const char *last)
Create a duplicate of the given string.
Definition: string.cpp:137
PM_PAUSED_JOIN
@ PM_PAUSED_JOIN
A game paused for 'pause_on_join'.
Definition: openttd.h:62
_sync_frame
uint32 _sync_frame
The frame to perform the sync check.
Definition: network.cpp:75
NetworkGameList
Structure with information shown in the game list (GUI)
Definition: network_gamelist.h:17
CheckMinActiveClients
static void CheckMinActiveClients()
Check if the minimum number of active clients has been reached and pause or unpause the game as appro...
Definition: network.cpp:421
NetworkChangeCompanyPassword
const char * NetworkChangeCompanyPassword(CompanyID company_id, const char *password)
Change the company password of a given company.
Definition: network.cpp:162
NetworkGameSocketHandler::client_id
ClientID client_id
Client identifier.
Definition: tcp_game.h:518
WC_SEND_NETWORK_MSG
@ WC_SEND_NETWORK_MSG
Chatbox; Window numbers:
Definition: window_type.h:491
CHAR_TD_LRM
static const WChar CHAR_TD_LRM
The next character acts like a left-to-right character.
Definition: string_type.h:39
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:367
_network_ban_list
StringList _network_ban_list
The banned clients.
Definition: network.cpp:65
NetworkUDPClose
void NetworkUDPClose()
Close all UDP related stuff.
Definition: network_udp.cpp:628
ClientSettings::network
NetworkSettings network
settings related to the network
Definition: settings_type.h:578
NetworkClose
void NetworkClose(bool close_admins)
Close current connections.
Definition: network.cpp:520
ServerNetworkGameSocketHandler::ServerNetworkGameSocketHandler
ServerNetworkGameSocketHandler(SOCKET s)
Create a new socket for the server side of the game connection.
Definition: network_server.cpp:217
ServerNetworkGameSocketHandler::client_address
NetworkAddress client_address
IP-address of the client (so he can be banned)
Definition: network_server.h:73
NETWORK_HOSTNAME_LENGTH
static const uint NETWORK_HOSTNAME_LENGTH
The maximum length of the host name, in bytes including '\0'.
Definition: config.h:42
NetworkCoreInitialize
bool NetworkCoreInitialize()
Initializes the network core (as that is needed for some platforms.
Definition: core.cpp:24
IConsoleCmdExec
void IConsoleCmdExec(const char *cmdstr, const uint recurse_count)
Execute a given command passed to us.
Definition: console.cpp:407
NetworkGameList::next
NetworkGameList * next
Next pointer to make a linked game list.
Definition: network_gamelist.h:23
network_gamelist.h
DESTTYPE_CLIENT
@ DESTTYPE_CLIENT
Send message/notice to only a certain client (Private)
Definition: network_type.h:84
NetworkExecuteLocalCommandQueue
void NetworkExecuteLocalCommandQueue()
Execute all commands on the local command queue that ought to be executed this frame.
Definition: network_command.cpp:191
ClientNetworkGameSocketHandler::SendQuit
static NetworkRecvStatus SendQuit()
Tell the server we would like to quit.
Definition: network_client.cpp:500
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:318
TCPListenHandler< ServerNetworkGameSocketHandler, PACKET_SERVER_FULL, PACKET_SERVER_BANNED >::CloseListeners
static void CloseListeners()
Close the sockets we're listening on.
Definition: tcp_listen.h:162
NetworkStartUp
void NetworkStartUp()
This tries to launch the network for a given OS.
Definition: network.cpp:1055
_network_host_list
StringList _network_host_list
The servers we know.
Definition: network.cpp:64
network_admin.h
CommandContainer::tile
TileIndex tile
tile command being executed on.
Definition: command_type.h:480
NetworkServerGameInfo::clients_on
byte clients_on
Current count of clients on server.
Definition: game.h:26
_network_available
bool _network_available
is network mode available?
Definition: network.cpp:54
strecpy
char * strecpy(char *dst, const char *src, const char *last)
Copies characters from one buffer to another.
Definition: string.cpp:112
WN_NETWORK_STATUS_WINDOW_JOIN
@ WN_NETWORK_STATUS_WINDOW_JOIN
Network join status.
Definition: window_type.h:32
free
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: stdafx.h:454
NetworkReceive
static bool NetworkReceive()
Receives something from the network.
Definition: network.cpp:814
PM_PAUSED_ERROR
@ PM_PAUSED_ERROR
A game paused because a (critical) error.
Definition: openttd.h:63
NetworkFreeLocalCommandQueue
void NetworkFreeLocalCommandQueue()
Free the local command queues.
Definition: network_command.cpp:225
GITHASH_SUFFIX_LEN
static const uint GITHASH_SUFFIX_LEN
How many hex digits of the git hash to include in network revision string.
Definition: network.cpp:1092
_network_advertise_retries
uint8 _network_advertise_retries
The number of advertisement retries we did.
Definition: network.cpp:79
GUISettings::network_chat_timeout
uint16 network_chat_timeout
timeout of chat messages in seconds
Definition: settings_type.h:171
_udp_master_socket
NetworkUDPSocketHandler * _udp_master_socket
udp master socket
Definition: network_udp.cpp:48
lastof
#define lastof(x)
Get the last element of an fixed size array.
Definition: stdafx.h:383
_broadcast_list
NetworkAddressList _broadcast_list
List of broadcast addresses.
Definition: network.cpp:70
ClientNetworkGameSocketHandler::Send
static void Send()
Send the packets of this socket handler.
Definition: network_client.cpp:256
NetworkSettings::server_admin_port
uint16 server_admin_port
port the server listens on for the admin network
Definition: settings_type.h:263
TCPQueryConnecter
Non blocking connection create to query servers.
Definition: network.cpp:565
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
_current_text_dir
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:48
_last_sync_frame
uint32 _last_sync_frame
Used in the server to store the last time a sync packet was sent to clients.
Definition: network.cpp:69
_is_network_server
bool _is_network_server
Does this client wants to be a network-server?
Definition: network.cpp:56
NetworkErrorCode
NetworkErrorCode
The error codes we send around in the protocols.
Definition: network_type.h:110
NetworkClientInfo
Container for all information known about a client.
Definition: network_base.h:23
TCPListenHandler< ServerNetworkGameSocketHandler, PACKET_SERVER_FULL, PACKET_SERVER_BANNED >::Listen
static bool Listen(uint16 port)
Listen on a particular port.
Definition: tcp_listen.h:141
IConsolePrintF
void CDECL IConsolePrintF(TextColour colour_code, const char *format,...)
Handle the printing of text entered into the console or redirected there by any other means.
Definition: console.cpp:125
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:286
TCPClientConnecter::OnConnect
void OnConnect(SOCKET s) override
Callback when the connection succeeded.
Definition: network.cpp:657
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:577
WL_CRITICAL
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
Definition: error.h:25
NetworkAddChatMessage
void CDECL NetworkAddChatMessage(TextColour colour, uint duration, const char *message,...)
Add a text message to the 'chat window' to be shown.
Definition: network_chat_gui.cpp:80
NetworkDistributeCommands
void NetworkDistributeCommands()
Distribute the commands of ourself and the clients.
Definition: network_command.cpp:279
NETWORK_COMPANY_NAME_LENGTH
static const uint NETWORK_COMPANY_NAME_LENGTH
The maximum length of the company name, in bytes including '\0'.
Definition: config.h:41