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

OpenTTD Source 15.0-beta1

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 "../timer/timer_game_tick.h"
15#include "../timer/timer_game_economy.h"
16#include "network_admin.h"
17#include "network_client.h"
18#include "network_query.h"
19#include "network_server.h"
20#include "network_content.h"
21#include "network_udp.h"
22#include "network_gamelist.h"
23#include "network_base.h"
24#include "network_coordinator.h"
25#include "core/udp.h"
26#include "core/host.h"
27#include "network_gui.h"
28#include "../console_func.h"
29#include "../3rdparty/md5/md5.h"
30#include "../core/random_func.hpp"
31#include "../window_func.h"
32#include "../company_func.h"
33#include "../company_base.h"
34#include "../landscape_type.h"
35#include "../rev.h"
36#include "../core/pool_func.hpp"
37#include "../gfx_func.h"
38#include "../error.h"
39#include "../misc_cmd.h"
40#ifdef DEBUG_DUMP_COMMANDS
41# include "../fileio_func.h"
42#endif
43#include <charconv>
44#include <sstream>
45#include <iomanip>
46
47#include "../safeguards.h"
48
49#ifdef DEBUG_DUMP_COMMANDS
55bool _ddc_fastforward = true;
56#endif /* DEBUG_DUMP_COMMANDS */
57
59static_assert(NetworkClientInfoPool::MAX_SIZE == NetworkClientSocketPool::MAX_SIZE);
60
62 NetworkClientInfoPool _networkclientinfo_pool("NetworkClientInfo");
63 INSTANTIATE_POOL_METHODS(NetworkClientInfo)
64
65bool _networking;
66 bool _network_server;
67 bool _network_available;
68 bool _network_dedicated;
69 bool _is_network_server;
70 ClientID _network_own_client_id;
71 ClientID _redirect_console_to_client;
72uint8_t _network_reconnect;
73 StringList _network_bind_list;
74 StringList _network_host_list;
75 StringList _network_ban_list;
76uint32_t _frame_counter_server;
77uint32_t _frame_counter_max;
78uint32_t _frame_counter;
79uint32_t _last_sync_frame;
80 NetworkAddressList _broadcast_list;
81uint32_t _sync_seed_1;
82#ifdef NETWORK_SEND_DOUBLE_SEED
83uint32_t _sync_seed_2;
84#endif
85uint32_t _sync_frame;
86 bool _network_first_time;
87
89uint8_t _network_clients_connected = 0;
90
91extern std::string GenerateUid(std::string_view subject);
92
97 bool HasClients()
98{
99 return !NetworkClientSocket::Iterate().empty();
100}
101
105NetworkClientInfo::~NetworkClientInfo()
106{
107 /* Delete the chat window, if you were chatting with this client. */
108 InvalidateWindowData(WC_SEND_NETWORK_MSG, DESTTYPE_CLIENT, this->client_id);
109}
110
116/* static */ NetworkClientInfo *NetworkClientInfo::GetByClientID(ClientID client_id)
117{
118 for (NetworkClientInfo *ci : NetworkClientInfo::Iterate()) {
119 if (ci->client_id == client_id) return ci;
120 }
121
122 return nullptr;
123}
124
130 bool NetworkClientInfo::CanJoinCompany(CompanyID company_id) const
131{
132 Company *c = Company::GetIfValid(company_id);
133 return c != nullptr && c->allow_list.Contains(this->public_key);
134}
135
141 bool NetworkCanJoinCompany(CompanyID company_id)
142{
143 NetworkClientInfo *info = NetworkClientInfo::GetByClientID(_network_own_client_id);
144 return info != nullptr && info->CanJoinCompany(company_id);
145}
146
152/* static */ ServerNetworkGameSocketHandler *ServerNetworkGameSocketHandler::GetByClientID(ClientID client_id)
153{
154 for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
155 if (cs->client_id == client_id) return cs;
156 }
157
158 return nullptr;
159}
160
161
168 static auto FindKey(auto *authorized_keys, std::string_view authorized_key)
169{
170 return std::ranges::find_if(*authorized_keys, [authorized_key](auto &value) { return StrEqualsIgnoreCase(value, authorized_key); });
171}
172
178 bool NetworkAuthorizedKeys::Contains(std::string_view key) const
179{
180 return FindKey(this, key) != this->end();
181}
182
188 bool NetworkAuthorizedKeys::Add(std::string_view key)
189{
190 if (key.empty()) return false;
191
192 auto iter = FindKey(this, key);
193 if (iter != this->end()) return false;
194
195 this->emplace_back(key);
196 return true;
197}
198
204 bool NetworkAuthorizedKeys::Remove(std::string_view key)
205{
206 auto iter = FindKey(this, key);
207 if (iter == this->end()) return false;
208
209 this->erase(iter);
210 return true;
211}
212
213
214uint8_t NetworkSpectatorCount()
215{
216 uint8_t count = 0;
217
218 for (const NetworkClientInfo *ci : NetworkClientInfo::Iterate()) {
219 if (ci->client_playas == COMPANY_SPECTATOR) count++;
220 }
221
222 /* Don't count a dedicated server as spectator */
223 if (_network_dedicated) count--;
224
225 return count;
226}
227
228
229/* This puts a text-message to the console, or in the future, the chat-box,
230 * (to keep it all a bit more general)
231 * If 'self_send' is true, this is the client who is sending the message */
232void NetworkTextMessage(NetworkAction action, TextColour colour, bool self_send, const std::string &name, const std::string &str, int64_t data, const std::string &data_str)
233{
234 StringID strid;
235 switch (action) {
236 case NETWORK_ACTION_SERVER_MESSAGE:
237 /* Ignore invalid messages */
238 strid = STR_NETWORK_SERVER_MESSAGE;
239 colour = CC_DEFAULT;
240 break;
241 case NETWORK_ACTION_COMPANY_SPECTATOR:
242 colour = CC_DEFAULT;
243 strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_SPECTATE;
244 break;
245 case NETWORK_ACTION_COMPANY_JOIN:
246 colour = CC_DEFAULT;
247 strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_JOIN;
248 break;
249 case NETWORK_ACTION_COMPANY_NEW:
250 colour = CC_DEFAULT;
251 strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_NEW;
252 break;
253 case NETWORK_ACTION_JOIN:
254 /* Show the Client ID for the server but not for the client. */
255 strid = _network_server ? STR_NETWORK_MESSAGE_CLIENT_JOINED_ID : STR_NETWORK_MESSAGE_CLIENT_JOINED;
256 break;
257 case NETWORK_ACTION_LEAVE: strid = STR_NETWORK_MESSAGE_CLIENT_LEFT; break;
258 case NETWORK_ACTION_NAME_CHANGE: strid = STR_NETWORK_MESSAGE_NAME_CHANGE; break;
259 case NETWORK_ACTION_GIVE_MONEY: strid = STR_NETWORK_MESSAGE_GIVE_MONEY; break;
260 case NETWORK_ACTION_CHAT_COMPANY: strid = self_send ? STR_NETWORK_CHAT_TO_COMPANY : STR_NETWORK_CHAT_COMPANY; break;
261 case NETWORK_ACTION_CHAT_CLIENT: strid = self_send ? STR_NETWORK_CHAT_TO_CLIENT : STR_NETWORK_CHAT_CLIENT; break;
262 case NETWORK_ACTION_KICKED: strid = STR_NETWORK_MESSAGE_KICKED; break;
263 case NETWORK_ACTION_EXTERNAL_CHAT: strid = STR_NETWORK_CHAT_EXTERNAL; break;
264 default: strid = STR_NETWORK_CHAT_ALL; break;
265 }
266
267 SetDParamStr(0, name);
268 SetDParamStr(1, str);
269 SetDParam(2, data);
270 SetDParamStr(3, data_str);
271
272 /* All of these strings start with "***". These characters are interpreted as both left-to-right and
273 * right-to-left characters depending on the context. As the next text might be an user's name, the
274 * user name's characters will influence the direction of the "***" instead of the language setting
275 * of the game. Manually set the direction of the "***" by inserting a text-direction marker. */
276 std::ostringstream stream;
277 std::ostreambuf_iterator<char> iterator(stream);
278 Utf8Encode(iterator, _current_text_dir == TD_LTR ? CHAR_TD_LRM : CHAR_TD_RLM);
279 std::string message = stream.str() + GetString(strid);
280
281 Debug(desync, 1, "msg: {:08x}; {:02x}; {}", TimerGameEconomy::date, TimerGameEconomy::date_fract, message);
282 IConsolePrint(colour, message);
283 NetworkAddChatMessage(colour, _settings_client.gui.network_chat_timeout, message);
284}
285
286/* Calculate the frame-lag of a client */
287uint NetworkCalculateLag(const NetworkClientSocket *cs)
288{
289 int lag = cs->last_frame_server - cs->last_frame;
290 /* This client has missed their ACK packet after 1 DAY_TICKS..
291 * so we increase their lag for every frame that passes!
292 * The packet can be out by a max of _net_frame_freq */
293 if (cs->last_frame_server + Ticks::DAY_TICKS + _settings_client.network.frame_freq < _frame_counter) {
294 lag += _frame_counter - (cs->last_frame_server + Ticks::DAY_TICKS + _settings_client.network.frame_freq);
295 }
296 return lag;
297}
298
299
300/* There was a non-recoverable error, drop back to the main menu with a nice
301 * error */
302void ShowNetworkError(StringID error_string)
303{
304 _switch_mode = SM_MENU;
305 ShowErrorMessage(error_string, INVALID_STRING_ID, WL_CRITICAL);
306}
307
313 StringID GetNetworkErrorMsg(NetworkErrorCode err)
314{
315 /* List of possible network errors, used by
316 * PACKET_SERVER_ERROR and PACKET_CLIENT_ERROR */
317 static const StringID network_error_strings[] = {
318 STR_NETWORK_ERROR_CLIENT_GENERAL,
319 STR_NETWORK_ERROR_CLIENT_DESYNC,
320 STR_NETWORK_ERROR_CLIENT_SAVEGAME,
321 STR_NETWORK_ERROR_CLIENT_CONNECTION_LOST,
322 STR_NETWORK_ERROR_CLIENT_PROTOCOL_ERROR,
323 STR_NETWORK_ERROR_CLIENT_NEWGRF_MISMATCH,
324 STR_NETWORK_ERROR_CLIENT_NOT_AUTHORIZED,
325 STR_NETWORK_ERROR_CLIENT_NOT_EXPECTED,
326 STR_NETWORK_ERROR_CLIENT_WRONG_REVISION,
327 STR_NETWORK_ERROR_CLIENT_NAME_IN_USE,
328 STR_NETWORK_ERROR_CLIENT_WRONG_PASSWORD,
329 STR_NETWORK_ERROR_CLIENT_COMPANY_MISMATCH,
330 STR_NETWORK_ERROR_CLIENT_KICKED,
331 STR_NETWORK_ERROR_CLIENT_CHEATER,
332 STR_NETWORK_ERROR_CLIENT_SERVER_FULL,
333 STR_NETWORK_ERROR_CLIENT_TOO_MANY_COMMANDS,
334 STR_NETWORK_ERROR_CLIENT_TIMEOUT_PASSWORD,
335 STR_NETWORK_ERROR_CLIENT_TIMEOUT_COMPUTER,
336 STR_NETWORK_ERROR_CLIENT_TIMEOUT_MAP,
337 STR_NETWORK_ERROR_CLIENT_TIMEOUT_JOIN,
338 STR_NETWORK_ERROR_CLIENT_INVALID_CLIENT_NAME,
339 STR_NETWORK_ERROR_CLIENT_NOT_ON_ALLOW_LIST,
340 STR_NETWORK_ERROR_CLIENT_NO_AUTHENTICATION_METHOD_AVAILABLE,
341 };
342 static_assert(lengthof(network_error_strings) == NETWORK_ERROR_END);
343
344 if (err >= (ptrdiff_t)lengthof(network_error_strings)) err = NETWORK_ERROR_GENERAL;
345
346 return network_error_strings[err];
347}
348
354 void NetworkHandlePauseChange(PauseMode prev_mode, PauseMode changed_mode)
355{
356 if (!_networking) return;
357
358 switch (changed_mode) {
359 case PM_PAUSED_NORMAL:
360 case PM_PAUSED_JOIN:
361 case PM_PAUSED_GAME_SCRIPT:
362 case PM_PAUSED_ACTIVE_CLIENTS:
363 case PM_PAUSED_LINK_GRAPH: {
364 bool changed = ((_pause_mode == PM_UNPAUSED) != (prev_mode == PM_UNPAUSED));
365 bool paused = (_pause_mode != PM_UNPAUSED);
366 if (!paused && !changed) return;
367
368 StringID str;
369 if (!changed) {
370 int i = -1;
371
372 if ((_pause_mode & PM_PAUSED_NORMAL) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL);
373 if ((_pause_mode & PM_PAUSED_JOIN) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS);
374 if ((_pause_mode & PM_PAUSED_GAME_SCRIPT) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_GAME_SCRIPT);
375 if ((_pause_mode & PM_PAUSED_ACTIVE_CLIENTS) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS);
376 if ((_pause_mode & PM_PAUSED_LINK_GRAPH) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_LINK_GRAPH);
377 str = STR_NETWORK_SERVER_MESSAGE_GAME_STILL_PAUSED_1 + i;
378 } else {
379 switch (changed_mode) {
380 case PM_PAUSED_NORMAL: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL); break;
381 case PM_PAUSED_JOIN: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS); break;
382 case PM_PAUSED_GAME_SCRIPT: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_GAME_SCRIPT); break;
383 case PM_PAUSED_ACTIVE_CLIENTS: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS); break;
384 case PM_PAUSED_LINK_GRAPH: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_LINK_GRAPH); break;
385 default: NOT_REACHED();
386 }
387 str = paused ? STR_NETWORK_SERVER_MESSAGE_GAME_PAUSED : STR_NETWORK_SERVER_MESSAGE_GAME_UNPAUSED;
388 }
389
390 NetworkTextMessage(NETWORK_ACTION_SERVER_MESSAGE, CC_DEFAULT, false, "", GetString(str));
391 break;
392 }
393
394 default:
395 return;
396 }
397}
398
399
408 static void CheckPauseHelper(bool pause, PauseMode pm)
409{
410 if (pause == ((_pause_mode & pm) != PM_UNPAUSED)) return;
411
412 Command<CMD_PAUSE>::Post(pm, pause);
413}
414
420 static uint NetworkCountActiveClients()
421{
422 uint count = 0;
423
424 for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
425 if (cs->status != NetworkClientSocket::STATUS_ACTIVE) continue;
426 if (!Company::IsValidID(cs->GetInfo()->client_playas)) continue;
427 count++;
428 }
429
430 return count;
431}
432
436 static void CheckMinActiveClients()
437{
438 if ((_pause_mode & PM_PAUSED_ERROR) != PM_UNPAUSED ||
439 !_network_dedicated ||
440 (_settings_client.network.min_active_clients == 0 && (_pause_mode & PM_PAUSED_ACTIVE_CLIENTS) == PM_UNPAUSED)) {
441 return;
442 }
443 CheckPauseHelper(NetworkCountActiveClients() < _settings_client.network.min_active_clients, PM_PAUSED_ACTIVE_CLIENTS);
444}
445
450 static bool NetworkHasJoiningClient()
451{
452 for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
453 if (cs->status >= NetworkClientSocket::STATUS_AUTHORIZED && cs->status < NetworkClientSocket::STATUS_ACTIVE) return true;
454 }
455
456 return false;
457}
458
462 static void CheckPauseOnJoin()
463{
464 if ((_pause_mode & PM_PAUSED_ERROR) != PM_UNPAUSED ||
465 (!_settings_client.network.pause_on_join && (_pause_mode & PM_PAUSED_JOIN) == PM_UNPAUSED)) {
466 return;
467 }
468 CheckPauseHelper(NetworkHasJoiningClient(), PM_PAUSED_JOIN);
469}
470
477std::string_view ParseCompanyFromConnectionString(const std::string &connection_string, CompanyID *company_id)
478{
479 std::string_view ip = connection_string;
480 if (company_id == nullptr) return ip;
481
482 size_t offset = ip.find_last_of('#');
483 if (offset != std::string::npos) {
484 std::string_view company_string = ip.substr(offset + 1);
485 ip = ip.substr(0, offset);
486
487 uint8_t company_value;
488 auto [_, err] = std::from_chars(company_string.data(), company_string.data() + company_string.size(), company_value);
489 if (err == std::errc()) {
490 if (company_value != COMPANY_NEW_COMPANY && company_value != COMPANY_SPECTATOR) {
491 if (company_value > MAX_COMPANIES || company_value == 0) {
492 *company_id = COMPANY_SPECTATOR;
493 } else {
494 /* "#1" means the first company, which has index 0. */
495 *company_id = (CompanyID)(company_value - 1);
496 }
497 } else {
498 *company_id = (CompanyID)company_value;
499 }
500 }
501 }
502
503 return ip;
504}
505
521std::string_view ParseFullConnectionString(const std::string &connection_string, uint16_t &port, CompanyID *company_id)
522{
523 std::string_view ip = ParseCompanyFromConnectionString(connection_string, company_id);
524
525 size_t port_offset = ip.find_last_of(':');
526 size_t ipv6_close = ip.find_last_of(']');
527 if (port_offset != std::string::npos && (ipv6_close == std::string::npos || ipv6_close < port_offset)) {
528 std::string_view port_string = ip.substr(port_offset + 1);
529 ip = ip.substr(0, port_offset);
530 std::from_chars(port_string.data(), port_string.data() + port_string.size(), port);
531 }
532 return ip;
533}
534
541std::string NormalizeConnectionString(const std::string &connection_string, uint16_t default_port)
542{
543 uint16_t port = default_port;
544 std::string_view ip = ParseFullConnectionString(connection_string, port);
545 return std::string(ip) + ":" + std::to_string(port);
546}
547
556 NetworkAddress ParseConnectionString(const std::string &connection_string, uint16_t default_port)
557{
558 uint16_t port = default_port;
559 std::string_view ip = ParseFullConnectionString(connection_string, port);
560 return NetworkAddress(ip, port);
561}
562
568/* static */ void ServerNetworkGameSocketHandler::AcceptConnection(SOCKET s, const NetworkAddress &address)
569{
570 /* Register the login */
571 _network_clients_connected++;
572
573 ServerNetworkGameSocketHandler *cs = new ServerNetworkGameSocketHandler(s);
574 cs->client_address = address; // Save the IP of the client
575
576 InvalidateWindowData(WC_CLIENT_LIST, 0);
577}
578
583 static void InitializeNetworkPools(bool close_admins = true)
584{
585 PoolBase::Clean(PT_NCLIENT | (close_admins ? PT_NADMIN : PT_NONE));
586}
587
592 void NetworkClose(bool close_admins)
593{
594 if (_network_server) {
595 if (close_admins) {
596 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::Iterate()) {
597 as->CloseConnection(true);
598 }
599 }
600
601 for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
602 cs->CloseConnection(NETWORK_RECV_STATUS_CLIENT_QUIT);
603 }
604 ServerNetworkGameSocketHandler::CloseListeners();
605 ServerNetworkAdminSocketHandler::CloseListeners();
606
607 _network_coordinator_client.CloseConnection();
608 } else {
609 if (MyClient::my_client != nullptr) {
610 MyClient::SendQuit();
611 MyClient::my_client->CloseConnection(NETWORK_RECV_STATUS_CLIENT_QUIT);
612 }
613
614 _network_coordinator_client.CloseAllConnections();
615 }
616 NetworkGameSocketHandler::ProcessDeferredDeletions();
617
618 TCPConnecter::KillAll();
619
620 _networking = false;
621 _network_server = false;
622
623 NetworkFreeLocalCommandQueue();
624
625 InitializeNetworkPools(close_admins);
626}
627
628/* Initializes the network (cleans sockets and stuff) */
629static void NetworkInitialize(bool close_admins = true)
630{
631 InitializeNetworkPools(close_admins);
632
633 _sync_frame = 0;
634 _network_first_time = true;
635
636 _network_reconnect = 0;
637}
638
640 class TCPQueryConnecter : public TCPServerConnecter {
641private:
642 std::string connection_string;
643
644public:
645 TCPQueryConnecter(const std::string &connection_string) : TCPServerConnecter(connection_string, NETWORK_DEFAULT_PORT), connection_string(connection_string) {}
646
647 void OnFailure() override
648 {
649 Debug(net, 9, "Query::OnFailure(): connection_string={}", this->connection_string);
650
651 NetworkGameList *item = NetworkGameListAddItem(connection_string);
652 item->status = NGLS_OFFLINE;
653 item->refreshing = false;
654
655 UpdateNetworkGameWindow();
656 }
657
658 void OnConnect(SOCKET s) override
659 {
660 Debug(net, 9, "Query::OnConnect(): connection_string={}", this->connection_string);
661
662 QueryNetworkGameSocketHandler::QueryServer(s, this->connection_string);
663 }
664};
665
670 void NetworkQueryServer(const std::string &connection_string)
671{
672 if (!_network_available) return;
673
674 Debug(net, 9, "NetworkQueryServer(): connection_string={}", connection_string);
675
676 /* Mark the entry as refreshing, so the GUI can show the refresh is pending. */
677 NetworkGameList *item = NetworkGameListAddItem(connection_string);
678 item->refreshing = true;
679
680 TCPConnecter::Create<TCPQueryConnecter>(connection_string);
681}
682
692 NetworkGameList *NetworkAddServer(const std::string &connection_string, bool manually, bool never_expire)
693{
694 if (connection_string.empty()) return nullptr;
695
696 /* Ensure the item already exists in the list */
697 NetworkGameList *item = NetworkGameListAddItem(connection_string);
698 if (item->info.server_name.empty()) {
699 ClearGRFConfigList(&item->info.grfconfig);
700 item->info.server_name = connection_string;
701
702 UpdateNetworkGameWindow();
703
704 NetworkQueryServer(connection_string);
705 }
706
707 if (manually) item->manually = true;
708 if (never_expire) item->version = INT32_MAX;
709
710 return item;
711}
712
718 void GetBindAddresses(NetworkAddressList *addresses, uint16_t port)
719{
720 for (const auto &iter : _network_bind_list) {
721 addresses->emplace_back(iter.c_str(), port);
722 }
723
724 /* No address, so bind to everything. */
725 if (addresses->empty()) {
726 addresses->emplace_back("", port);
727 }
728}
729
730/* Generates the list of manually added hosts from NetworkGameList and
731 * dumps them into the array _network_host_list. This array is needed
732 * by the function that generates the config file. */
733void NetworkRebuildHostList()
734{
735 _network_host_list.clear();
736
737 for (NetworkGameList *item = _network_game_list; item != nullptr; item = item->next) {
738 if (item->manually) _network_host_list.emplace_back(item->connection_string);
739 }
740}
741
743 class TCPClientConnecter : public TCPServerConnecter {
744private:
745 std::string connection_string;
746
747public:
748 TCPClientConnecter(const std::string &connection_string) : TCPServerConnecter(connection_string, NETWORK_DEFAULT_PORT), connection_string(connection_string) {}
749
750 void OnFailure() override
751 {
752 Debug(net, 9, "Client::OnFailure(): connection_string={}", this->connection_string);
753
754 ShowNetworkError(STR_NETWORK_ERROR_NOCONNECTION);
755 }
756
757 void OnConnect(SOCKET s) override
758 {
759 Debug(net, 9, "Client::OnConnect(): connection_string={}", this->connection_string);
760
761 _networking = true;
762 _network_own_client_id = ClientID{};
763 new ClientNetworkGameSocketHandler(s, this->connection_string);
764 IConsoleCmdExec("exec scripts/on_client.scr 0");
765 NetworkClient_Connected();
766 }
767};
768
785 bool NetworkClientConnectGame(const std::string &connection_string, CompanyID default_company, const std::string &join_server_password)
786{
787 Debug(net, 9, "NetworkClientConnectGame(): connection_string={}", connection_string);
788
789 CompanyID join_as = default_company;
790 std::string resolved_connection_string = ServerAddress::Parse(connection_string, NETWORK_DEFAULT_PORT, &join_as).connection_string;
791
792 if (!_network_available) return false;
793 if (!NetworkValidateOurClientName()) return false;
794
795 _network_join.connection_string = resolved_connection_string;
796 _network_join.company = join_as;
797 _network_join.server_password = join_server_password;
798
799 if (_game_mode == GM_MENU) {
800 /* From the menu we can immediately continue with the actual join. */
801 NetworkClientJoinGame();
802 } else {
803 /* When already playing a game, first go back to the main menu. This
804 * disconnects the user from the current game, meaning we can safely
805 * load in the new. After all, there is little point in continueing to
806 * play on a server if we are connecting to another one.
807 */
808 _switch_mode = SM_JOIN_GAME;
809 }
810 return true;
811}
812
818 void NetworkClientJoinGame()
819{
820 NetworkDisconnect();
821 NetworkInitialize();
822
823 _settings_client.network.last_joined = _network_join.connection_string;
824 Debug(net, 9, "status = CONNECTING");
825 _network_join_status = NETWORK_JOIN_STATUS_CONNECTING;
826 ShowJoinStatusWindow();
827
828 TCPConnecter::Create<TCPClientConnecter>(_network_join.connection_string);
829}
830
831static void NetworkInitGameInfo()
832{
833 FillStaticNetworkServerGameInfo();
834 /* The server is a client too */
835 _network_game_info.clients_on = _network_dedicated ? 0 : 1;
836
837 /* There should be always space for the server. */
838 assert(NetworkClientInfo::CanAllocateItem());
839 NetworkClientInfo *ci = new NetworkClientInfo(CLIENT_ID_SERVER);
840 ci->client_playas = COMPANY_SPECTATOR;
841
842 ci->client_name = _settings_client.network.client_name;
843
844 NetworkAuthenticationClientHandler::EnsureValidSecretKeyAndUpdatePublicKey(_settings_client.network.client_secret_key, _settings_client.network.client_public_key);
845 ci->public_key = _settings_client.network.client_public_key;
846}
847
858 bool NetworkValidateServerName(std::string &server_name)
859{
860 StrTrimInPlace(server_name);
861 if (!server_name.empty()) return true;
862
863 ShowErrorMessage(STR_NETWORK_ERROR_BAD_SERVER_NAME, INVALID_STRING_ID, WL_ERROR);
864 return false;
865}
866
873 static void CheckClientAndServerName()
874{
875 static const std::string fallback_client_name = "Unnamed Client";
876 StrTrimInPlace(_settings_client.network.client_name);
877 if (_settings_client.network.client_name.empty() || _settings_client.network.client_name.compare(fallback_client_name) == 0) {
878 Debug(net, 1, "No \"client_name\" has been set, using \"{}\" instead. Please set this now using the \"name <new name>\" command", fallback_client_name);
879 _settings_client.network.client_name = fallback_client_name;
880 }
881
882 static const std::string fallback_server_name = "Unnamed Server";
883 StrTrimInPlace(_settings_client.network.server_name);
884 if (_settings_client.network.server_name.empty() || _settings_client.network.server_name.compare(fallback_server_name) == 0) {
885 Debug(net, 1, "No \"server_name\" has been set, using \"{}\" instead. Please set this now using the \"server_name <new name>\" command", fallback_server_name);
886 _settings_client.network.server_name = fallback_server_name;
887 }
888}
889
890bool NetworkServerStart()
891{
892 if (!_network_available) return false;
893
894 /* Call the pre-scripts */
895 IConsoleCmdExec("exec scripts/pre_server.scr 0");
896 if (_network_dedicated) IConsoleCmdExec("exec scripts/pre_dedicated.scr 0");
897
898 /* Check for the client and server names to be set, but only after the scripts had a chance to set them.*/
899 if (_network_dedicated) CheckClientAndServerName();
900
901 NetworkDisconnect(false);
902 NetworkInitialize(false);
903 NetworkUDPInitialize();
904 Debug(net, 5, "Starting listeners for clients");
905 if (!ServerNetworkGameSocketHandler::Listen(_settings_client.network.server_port)) return false;
906
907 /* Only listen for admins when the authentication is configured. */
908 if (_settings_client.network.AdminAuthenticationConfigured()) {
909 Debug(net, 5, "Starting listeners for admins");
910 if (!ServerNetworkAdminSocketHandler::Listen(_settings_client.network.server_admin_port)) return false;
911 }
912
913 /* Try to start UDP-server */
914 Debug(net, 5, "Starting listeners for incoming server queries");
915 NetworkUDPServerListen();
916
917 _network_server = true;
918 _networking = true;
919 _frame_counter = 0;
920 _frame_counter_server = 0;
921 _frame_counter_max = 0;
922 _last_sync_frame = 0;
923 _network_own_client_id = CLIENT_ID_SERVER;
924
925 _network_clients_connected = 0;
926
927 NetworkInitGameInfo();
928
929 if (_settings_client.network.server_game_type != SERVER_GAME_TYPE_LOCAL) {
930 _network_coordinator_client.Register();
931 }
932
933 /* execute server initialization script */
934 IConsoleCmdExec("exec scripts/on_server.scr 0");
935 /* if the server is dedicated ... add some other script */
936 if (_network_dedicated) IConsoleCmdExec("exec scripts/on_dedicated.scr 0");
937
938 return true;
939}
940
945 void NetworkOnGameStart()
946{
947 if (!_network_server) return;
948
949 /* Update the static game info to set the values from the new game. */
950 NetworkServerUpdateGameInfo();
951
952 ChangeNetworkRestartTime(true);
953
954 if (!_network_dedicated) {
955 Company *c = Company::GetIfValid(GetFirstPlayableCompanyID());
956 NetworkClientInfo *ci = NetworkClientInfo::GetByClientID(CLIENT_ID_SERVER);
957 if (c != nullptr && ci != nullptr) {
958 ci->client_playas = c->index;
959
960 /*
961 * If the company has not been named yet, the company was just started.
962 * Otherwise it would have gotten a name already, so announce it as a new company.
963 */
964 if (c->name_1 == STR_SV_UNNAMED && c->name.empty()) NetworkServerNewCompany(c, ci);
965 }
966
967 ShowClientList();
968 } else {
969 /* welcome possibly still connected admins - this can only happen on a dedicated server. */
970 ServerNetworkAdminSocketHandler::WelcomeAll();
971 }
972}
973
974/* The server is rebooting...
975 * The only difference with NetworkDisconnect, is the packets that is sent */
976void NetworkReboot()
977{
978 if (_network_server) {
979 for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
980 cs->SendNewGame();
981 cs->SendPackets();
982 }
983
984 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
985 as->SendNewGame();
986 as->SendPackets();
987 }
988 }
989
990 /* For non-dedicated servers we have to kick the admins as we are not
991 * certain that we will end up in a new network game. */
992 NetworkClose(!_network_dedicated);
993}
994
999 void NetworkDisconnect(bool close_admins)
1000{
1001 if (_network_server) {
1002 for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
1003 cs->SendShutdown();
1004 cs->SendPackets();
1005 }
1006
1007 if (close_admins) {
1008 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
1009 as->SendShutdown();
1010 as->SendPackets();
1011 }
1012 }
1013 }
1014
1015 CloseWindowById(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
1016
1017 NetworkClose(close_admins);
1018
1019 /* Reinitialize the UDP stack, i.e. close all existing connections. */
1020 NetworkUDPInitialize();
1021}
1022
1027 void NetworkUpdateServerGameType()
1028{
1029 if (!_networking) return;
1030
1031 switch (_settings_client.network.server_game_type) {
1032 case SERVER_GAME_TYPE_LOCAL:
1033 _network_coordinator_client.CloseConnection();
1034 break;
1035
1036 case SERVER_GAME_TYPE_INVITE_ONLY:
1037 case SERVER_GAME_TYPE_PUBLIC:
1038 _network_coordinator_client.Register();
1039 break;
1040
1041 default:
1042 NOT_REACHED();
1043 }
1044}
1045
1050 static bool NetworkReceive()
1051{
1052 bool result;
1053 if (_network_server) {
1054 ServerNetworkAdminSocketHandler::Receive();
1055 result = ServerNetworkGameSocketHandler::Receive();
1056 } else {
1057 result = ClientNetworkGameSocketHandler::Receive();
1058 }
1059 NetworkGameSocketHandler::ProcessDeferredDeletions();
1060 return result;
1061}
1062
1063/* This sends all buffered commands (if possible) */
1064static void NetworkSend()
1065{
1066 if (_network_server) {
1067 ServerNetworkAdminSocketHandler::Send();
1068 ServerNetworkGameSocketHandler::Send();
1069 } else {
1070 ClientNetworkGameSocketHandler::Send();
1071 }
1072 NetworkGameSocketHandler::ProcessDeferredDeletions();
1073}
1074
1080 void NetworkBackgroundLoop()
1081{
1082 _network_content_client.SendReceive();
1083 _network_coordinator_client.SendReceive();
1084 TCPConnecter::CheckCallbacks();
1085 NetworkHTTPSocketHandler::HTTPReceive();
1086 QueryNetworkGameSocketHandler::SendReceive();
1087 NetworkGameSocketHandler::ProcessDeferredDeletions();
1088
1089 NetworkBackgroundUDPLoop();
1090}
1091
1092/* The main loop called from ttd.c
1093 * Here we also have to do StateGameLoop if needed! */
1094void NetworkGameLoop()
1095{
1096 if (!_networking) return;
1097
1098 if (!NetworkReceive()) return;
1099
1100 if (_network_server) {
1101 /* Log the sync state to check for in-syncedness of replays. */
1102 if (TimerGameEconomy::date_fract == 0) {
1103 /* We don't want to log multiple times if paused. */
1104 static TimerGameEconomy::Date last_log;
1105 if (last_log != TimerGameEconomy::date) {
1106 Debug(desync, 1, "sync: {:08x}; {:02x}; {:08x}; {:08x}", TimerGameEconomy::date, TimerGameEconomy::date_fract, _random.state[0], _random.state[1]);
1107 last_log = TimerGameEconomy::date;
1108 }
1109 }
1110
1111#ifdef DEBUG_DUMP_COMMANDS
1112 /* Loading of the debug commands from -ddesync>=1 */
1113 static auto f = FioFOpenFile("commands.log", "rb", SAVE_DIR);
1114 static TimerGameEconomy::Date next_date(0);
1115 static uint32_t next_date_fract;
1116 static CommandPacket *cp = nullptr;
1117 static bool check_sync_state = false;
1118 static uint32_t sync_state[2];
1119 if (!f.has_value() && next_date == 0) {
1120 Debug(desync, 0, "Cannot open commands.log");
1121 next_date = TimerGameEconomy::Date(1);
1122 }
1123
1124 while (f.has_value() && !feof(*f)) {
1125 if (TimerGameEconomy::date == next_date && TimerGameEconomy::date_fract == next_date_fract) {
1126 if (cp != nullptr) {
1127 NetworkSendCommand(cp->cmd, cp->err_msg, nullptr, cp->company, cp->data);
1128 Debug(desync, 0, "Injecting: {:08x}; {:02x}; {:02x}; {:08x}; {} ({})", TimerGameEconomy::date, TimerGameEconomy::date_fract, (int)_current_company, cp->cmd, FormatArrayAsHex(cp->data), GetCommandName(cp->cmd));
1129 delete cp;
1130 cp = nullptr;
1131 }
1132 if (check_sync_state) {
1133 if (sync_state[0] == _random.state[0] && sync_state[1] == _random.state[1]) {
1134 Debug(desync, 0, "Sync check: {:08x}; {:02x}; match", TimerGameEconomy::date, TimerGameEconomy::date_fract);
1135 } else {
1136 Debug(desync, 0, "Sync check: {:08x}; {:02x}; mismatch expected {{{:08x}, {:08x}}}, got {{{:08x}, {:08x}}}",
1137 TimerGameEconomy::date, TimerGameEconomy::date_fract, sync_state[0], sync_state[1], _random.state[0], _random.state[1]);
1138 NOT_REACHED();
1139 }
1140 check_sync_state = false;
1141 }
1142 }
1143
1144 /* Skip all entries in the command-log till we caught up with the current game again. */
1145 if (TimerGameEconomy::date > next_date || (TimerGameEconomy::date == next_date && TimerGameEconomy::date_fract > next_date_fract)) {
1146 Debug(desync, 0, "Skipping to next command at {:08x}:{:02x}", next_date, next_date_fract);
1147 if (cp != nullptr) {
1148 delete cp;
1149 cp = nullptr;
1150 }
1151 check_sync_state = false;
1152 }
1153
1154 if (cp != nullptr || check_sync_state) break;
1155
1156 char buff[4096];
1157 if (fgets(buff, lengthof(buff), *f) == nullptr) break;
1158
1159 char *p = buff;
1160 /* Ignore the "[date time] " part of the message */
1161 if (*p == '[') {
1162 p = strchr(p, ']');
1163 if (p == nullptr) break;
1164 p += 2;
1165 }
1166
1167 if (strncmp(p, "cmd: ", 5) == 0
1168#ifdef DEBUG_FAILED_DUMP_COMMANDS
1169 || strncmp(p, "cmdf: ", 6) == 0
1170#endif
1171 ) {
1172 p += 5;
1173 if (*p == ' ') p++;
1174 cp = new CommandPacket();
1175 int company;
1176 uint cmd;
1177 char buffer[256];
1178 uint32_t next_date_raw;
1179 int ret = sscanf(p, "%x; %x; %x; %x; %x; %255s", &next_date_raw, &next_date_fract, &company, &cmd, &cp->err_msg, buffer);
1180 assert(ret == 6);
1181 next_date = TimerGameEconomy::Date((int32_t)next_date_raw);
1182 cp->company = (CompanyID)company;
1183 cp->cmd = (Commands)cmd;
1184
1185 /* Parse command data. */
1186 std::vector<uint8_t> args;
1187 size_t arg_len = strlen(buffer);
1188 for (size_t i = 0; i + 1 < arg_len; i += 2) {
1189 uint8_t e = 0;
1190 std::from_chars(buffer + i, buffer + i + 2, e, 16);
1191 args.emplace_back(e);
1192 }
1193 cp->data = args;
1194 } else if (strncmp(p, "join: ", 6) == 0) {
1195 /* Manually insert a pause when joining; this way the client can join at the exact right time. */
1196 uint32_t next_date_raw;
1197 int ret = sscanf(p + 6, "%x; %x", &next_date_raw, &next_date_fract);
1198 next_date = TimerGameEconomy::Date((int32_t)next_date_raw);
1199 assert(ret == 2);
1200 Debug(desync, 0, "Injecting pause for join at {:08x}:{:02x}; please join when paused", next_date, next_date_fract);
1201 cp = new CommandPacket();
1202 cp->company = COMPANY_SPECTATOR;
1203 cp->cmd = CMD_PAUSE;
1204 cp->data = EndianBufferWriter<>::FromValue(CommandTraits<CMD_PAUSE>::Args{ PM_PAUSED_NORMAL, true });
1205 _ddc_fastforward = false;
1206 } else if (strncmp(p, "sync: ", 6) == 0) {
1207 uint32_t next_date_raw;
1208 int ret = sscanf(p + 6, "%x; %x; %x; %x", &next_date_raw, &next_date_fract, &sync_state[0], &sync_state[1]);
1209 next_date = TimerGameEconomy::Date((int32_t)next_date_raw);
1210 assert(ret == 4);
1211 check_sync_state = true;
1212 } else if (strncmp(p, "msg: ", 5) == 0 || strncmp(p, "client: ", 8) == 0 ||
1213 strncmp(p, "load: ", 6) == 0 || strncmp(p, "save: ", 6) == 0 ||
1214 strncmp(p, "warning: ", 9) == 0) {
1215 /* A message that is not very important to the log playback, but part of the log. */
1216#ifndef DEBUG_FAILED_DUMP_COMMANDS
1217 } else if (strncmp(p, "cmdf: ", 6) == 0) {
1218 Debug(desync, 0, "Skipping replay of failed command: {}", p + 6);
1219#endif
1220 } else {
1221 /* Can't parse a line; what's wrong here? */
1222 Debug(desync, 0, "Trying to parse: {}", p);
1223 NOT_REACHED();
1224 }
1225 }
1226 if (f.has_value() && feof(*f)) {
1227 Debug(desync, 0, "End of commands.log");
1228 f.reset();
1229 }
1230#endif /* DEBUG_DUMP_COMMANDS */
1231 if (_frame_counter >= _frame_counter_max) {
1232 /* Only check for active clients just before we're going to send out
1233 * the commands so we don't send multiple pause/unpause commands when
1234 * the frame_freq is more than 1 tick. Same with distributing commands. */
1235 CheckPauseOnJoin();
1236 CheckMinActiveClients();
1237 NetworkDistributeCommands();
1238 }
1239
1240 bool send_frame = false;
1241
1242 /* We first increase the _frame_counter */
1243 _frame_counter++;
1244 /* Update max-frame-counter */
1245 if (_frame_counter > _frame_counter_max) {
1246 _frame_counter_max = _frame_counter + _settings_client.network.frame_freq;
1247 send_frame = true;
1248 }
1249
1250 NetworkExecuteLocalCommandQueue();
1251
1252 /* Then we make the frame */
1253 StateGameLoop();
1254
1255 _sync_seed_1 = _random.state[0];
1256#ifdef NETWORK_SEND_DOUBLE_SEED
1257 _sync_seed_2 = _random.state[1];
1258#endif
1259
1260 NetworkServer_Tick(send_frame);
1261 } else {
1262 /* Client */
1263
1264 /* Make sure we are at the frame were the server is (quick-frames) */
1265 if (_frame_counter_server > _frame_counter) {
1266 /* Run a number of frames; when things go bad, get out. */
1267 while (_frame_counter_server > _frame_counter) {
1268 if (!ClientNetworkGameSocketHandler::GameLoop()) return;
1269 }
1270 } else {
1271 /* Else, keep on going till _frame_counter_max */
1272 if (_frame_counter_max > _frame_counter) {
1273 /* Run one frame; if things went bad, get out. */
1274 if (!ClientNetworkGameSocketHandler::GameLoop()) return;
1275 }
1276 }
1277 }
1278
1279 NetworkSend();
1280}
1281
1283 void NetworkStartUp()
1284{
1285 Debug(net, 3, "Starting network");
1286
1287 /* Network is available */
1288 _network_available = NetworkCoreInitialize();
1289 _network_dedicated = false;
1290
1291 _network_game_info = {};
1292
1293 NetworkInitialize();
1294 NetworkUDPInitialize();
1295 Debug(net, 3, "Network online, multiplayer available");
1296 NetworkFindBroadcastIPs(&_broadcast_list);
1297 NetworkHTTPInitialize();
1298}
1299
1301 void NetworkShutDown()
1302{
1303 NetworkDisconnect();
1304 NetworkHTTPUninitialize();
1305 NetworkUDPClose();
1306
1307 Debug(net, 3, "Shutting down network");
1308
1309 _network_available = false;
1310
1311 NetworkCoreShutdown();
1312}
1313
1314#ifdef __EMSCRIPTEN__
1315extern "C" {
1316
1317void CDECL em_openttd_add_server(const char *connection_string)
1318{
1319 NetworkAddServer(connection_string, false, true);
1320}
1321
1322}
1323#endif
NetworkAddressList
std::vector< NetworkAddress > NetworkAddressList
Type for a list of addresses.
Definition address.h:20
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:814
ClientNetworkCoordinatorSocketHandler::Register
void Register()
Register our server to receive our invite code.
Definition network_coordinator.cpp:452
ClientNetworkCoordinatorSocketHandler::SendReceive
void SendReceive()
Check whether we received/can send some data from/to the Game Coordinator server and when that's the ...
Definition network_coordinator.cpp:717
ClientNetworkCoordinatorSocketHandler::CloseAllConnections
void CloseAllConnections()
Close all pending connection tokens.
Definition network_coordinator.cpp:685
ClientNetworkCoordinatorSocketHandler::CloseConnection
NetworkRecvStatus CloseConnection(bool error=true) override
This will put this socket handler in a close state.
Definition network_coordinator.cpp:432
ClientNetworkGameSocketHandler
Class for handling the client side of the game connection.
Definition network_client.h:16
ClientNetworkGameSocketHandler::my_client
static ClientNetworkGameSocketHandler * my_client
This is us!
Definition network_client.h:42
ClientNetworkGameSocketHandler::SendQuit
static NetworkRecvStatus SendQuit()
Tell the server we would like to quit.
Definition network_client.cpp:484
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:243
ClientNetworkGameSocketHandler::GameLoop
static bool GameLoop()
Actual game loop for the client.
Definition network_client.cpp:268
ClientNetworkGameSocketHandler::Send
static void Send()
Send the packets of this socket handler.
Definition network_client.cpp:258
ClientNetworkGameSocketHandler::CloseConnection
NetworkRecvStatus CloseConnection(NetworkRecvStatus status) override
Close the network connection due to the given status.
Definition network_client.cpp:161
EndianBufferWriter
Endian-aware buffer adapter that always writes values in little endian order.
Definition endian_buffer.hpp:26
NetworkAddress
Wrapper for (un)resolved network addresses; there's no reason to transform a numeric IP to a string a...
Definition address.h:28
NetworkAuthenticationClientHandler::EnsureValidSecretKeyAndUpdatePublicKey
static void EnsureValidSecretKeyAndUpdatePublicKey(std::string &secret_key, std::string &public_key)
Ensures that the given secret key is valid, and when not overwrite it with a valid secret key.
Definition network_crypto.cpp:451
NetworkAuthorizedKeys::Contains
bool Contains(std::string_view key) const
Check whether the given key is contains in these authorized keys.
Definition network.cpp:178
NetworkAuthorizedKeys::Add
bool Add(std::string_view key)
Add the given key to the authorized keys, when it is not already contained.
Definition network.cpp:188
NetworkAuthorizedKeys::Remove
bool Remove(std::string_view key)
Remove the given key from the authorized keys, when it is exists.
Definition network.cpp:204
NetworkGameSocketHandler::client_id
ClientID client_id
Client identifier.
Definition tcp_game.h:486
NetworkHTTPSocketHandler::HTTPReceive
static void HTTPReceive()
Do the receiving for all HTTP connections.
Definition http_curl.cpp:107
QueryNetworkGameSocketHandler::QueryServer
static void QueryServer(SOCKET s, const std::string &connection_string)
Start to query a server based on an open socket.
Definition network_query.h:46
QueryNetworkGameSocketHandler::SendReceive
static void SendReceive()
Check if any query needs to send or receive.
Definition network_query.cpp:164
ServerAddress::connection_string
std::string connection_string
The connection string for this ServerAddress.
Definition address.h:210
ServerAddress::Parse
static ServerAddress Parse(const std::string &connection_string, uint16_t default_port, CompanyID *company_id=nullptr)
Convert a string containing either "hostname", "hostname:port" or invite code to a ServerAddress,...
Definition address.cpp:450
ServerNetworkAdminSocketHandler
Class for handling the server side of the game connection.
Definition network_admin.h:25
ServerNetworkAdminSocketHandler::Send
static void Send()
Send the packets for the server sockets.
Definition network_admin.cpp:105
ServerNetworkAdminSocketHandler::WelcomeAll
static void WelcomeAll()
Send a Welcome packet to all connected admins.
Definition network_admin.cpp:1064
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:102
ServerNetworkGameSocketHandler
Class for handling the server side of the game connection.
Definition network_server.h:24
ServerNetworkGameSocketHandler::GetByClientID
static ServerNetworkGameSocketHandler * GetByClientID(ClientID client_id)
Return the client state given it's client-identifier.
Definition network.cpp:152
ServerNetworkGameSocketHandler::Send
static void Send()
Send the packets for the server sockets.
Definition network_server.cpp:304
ServerNetworkGameSocketHandler::AcceptConnection
static void AcceptConnection(SOCKET s, const NetworkAddress &address)
Handle the accepting of a connection to the server.
Definition network.cpp:568
ServerNetworkGameSocketHandler::client_address
NetworkAddress client_address
IP-address of the client (so they can be banned)
Definition network_server.h:75
TCPClientConnecter
Non blocking connection create to actually connect to servers.
Definition network.cpp:743
TCPClientConnecter::OnConnect
void OnConnect(SOCKET s) override
Callback when the connection succeeded.
Definition network.cpp:757
TCPClientConnecter::OnFailure
void OnFailure() override
Callback for when the connection attempt failed.
Definition network.cpp:750
TCPConnecter::CheckCallbacks
static void CheckCallbacks()
Check whether we need to call the callback, i.e.
Definition tcp_connect.cpp:463
TCPConnecter::KillAll
static void KillAll()
Kill all connection attempts.
Definition tcp_connect.cpp:472
TCPListenHandler< ServerNetworkAdminSocketHandler, ADMIN_PACKET_SERVER_FULL, ADMIN_PACKET_SERVER_BANNED >::Receive
static bool Receive()
Handle the receiving of packets.
Definition tcp_listen.h:101
TCPListenHandler< ServerNetworkGameSocketHandler, PACKET_SERVER_FULL, PACKET_SERVER_BANNED >::Listen
static bool Listen(uint16_t port)
Listen on a particular port.
Definition tcp_listen.h:143
TCPListenHandler< ServerNetworkGameSocketHandler, PACKET_SERVER_FULL, PACKET_SERVER_BANNED >::CloseListeners
static void CloseListeners()
Close the sockets we're listening on.
Definition tcp_listen.h:164
TCPQueryConnecter
Non blocking connection to query servers for their game info.
Definition network.cpp:640
TCPQueryConnecter::OnConnect
void OnConnect(SOCKET s) override
Callback when the connection succeeded.
Definition network.cpp:658
TCPQueryConnecter::OnFailure
void OnFailure() override
Callback for when the connection attempt failed.
Definition network.cpp:647
TCPServerConnecter
Definition tcp.h:151
Ticks::DAY_TICKS
static constexpr TimerGameTick::Ticks DAY_TICKS
1 day is 74 ticks; TimerGameCalendar::date_fract used to be uint16_t and incremented by 885.
Definition timer_game_tick.h:75
TimerGameEconomy::date
static Date date
Current date in days (day counter).
Definition timer_game_economy.h:38
TimerGameEconomy::date_fract
static DateFract date_fract
Fractional part of the day.
Definition timer_game_economy.h:39
GetCommandName
const char * GetCommandName(Commands cmd)
This function mask the parameter with CMD_ID_MASK and returns the name which belongs to the given com...
Definition command.cpp:132
NetworkSendCommand
void NetworkSendCommand(Commands cmd, StringID err_message, CommandCallback *callback, CompanyID company, const CommandDataBuffer &cmd_data)
Prepare a DoCommand to be send over the network.
Definition network_command.cpp:196
Commands
Commands
List of commands.
Definition command_type.h:187
CMD_PAUSE
@ CMD_PAUSE
pause the game
Definition command_type.h:276
GetFirstPlayableCompanyID
CompanyID GetFirstPlayableCompanyID()
Get the index of the first available company.
Definition company_cmd.cpp:1337
_current_company
CompanyID _current_company
Company currently doing an action.
Definition company_cmd.cpp:53
Owner
Owner
Enum for all companies/owners.
Definition company_type.h:18
COMPANY_SPECTATOR
@ COMPANY_SPECTATOR
The client is spectating.
Definition company_type.h:35
COMPANY_NEW_COMPANY
@ COMPANY_NEW_COMPANY
The client wants a new company.
Definition company_type.h:34
MAX_COMPANIES
@ MAX_COMPANIES
Maximum number of companies.
Definition company_type.h:23
NETWORK_DEFAULT_PORT
static const uint16_t NETWORK_DEFAULT_PORT
The default port of the game server (TCP & UDP)
Definition config.h:25
IConsoleCmdExec
void IConsoleCmdExec(const std::string &command_string, const uint recurse_count)
Execute a given command passed to us.
Definition console.cpp:291
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:89
CC_DEFAULT
static const TextColour CC_DEFAULT
Default colour of the console.
Definition console_type.h:23
NetworkCoreShutdown
void NetworkCoreShutdown()
Shuts down the network core (as that is needed for some platforms.
Definition core.cpp:44
NetworkCoreInitialize
bool NetworkCoreInitialize()
Initializes the network core (as that is needed for some platforms.
Definition core.cpp:24
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:28
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition debug.h:37
ShowErrorMessage
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
Definition error_gui.cpp:367
WL_ERROR
@ WL_ERROR
Errors (eg. saving/loading failed)
Definition error.h:26
WL_CRITICAL
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
Definition error.h:27
FioFOpenFile
std::optional< FileHandle > 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:242
SAVE_DIR
@ SAVE_DIR
Base directory for all savegames.
Definition fileio_type.h:117
_pause_mode
PauseMode _pause_mode
The current pause mode.
Definition gfx.cpp:50
_switch_mode
SwitchMode _switch_mode
The next mainloop command.
Definition gfx.cpp:49
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition gfx_type.h:260
NetworkFindBroadcastIPs
void NetworkFindBroadcastIPs(NetworkAddressList *broadcast)
Find the IPv4 broadcast addresses; IPv6 uses a completely different strategy for broadcasting.
Definition host.cpp:86
host.h
Resolving of hostnames/IPs.
NetworkHTTPInitialize
void NetworkHTTPInitialize()
Initialize the HTTP socket handler.
Definition http_curl.cpp:242
NetworkHTTPUninitialize
void NetworkHTTPUninitialize()
Uninitialize the HTTP socket handler.
Definition http_curl.cpp:277
_last_sync_frame
uint32_t _last_sync_frame
Used in the server to store the last time a sync packet was sent to clients.
Definition network.cpp:79
NetworkStartUp
void NetworkStartUp()
This tries to launch the network for a given OS.
Definition network.cpp:1283
_is_network_server
bool _is_network_server
Does this client wants to be a network-server?
Definition network.cpp:69
_networkclientinfo_pool
NetworkClientInfoPool _networkclientinfo_pool("NetworkClientInfo")
Make sure both pools have the same size.
NetworkCountActiveClients
static uint NetworkCountActiveClients()
Counts the number of active clients connected.
Definition network.cpp:420
_network_host_list
StringList _network_host_list
The servers we know.
Definition network.cpp:74
GetNetworkErrorMsg
StringID GetNetworkErrorMsg(NetworkErrorCode err)
Retrieve the string id of an internal error number.
Definition network.cpp:313
_frame_counter_server
uint32_t _frame_counter_server
The frame_counter of the server, if in network-mode.
Definition network.cpp:76
CheckPauseOnJoin
static void CheckPauseOnJoin()
Check whether we should pause on join.
Definition network.cpp:462
_broadcast_list
NetworkAddressList _broadcast_list
List of broadcast addresses.
Definition network.cpp:80
NetworkQueryServer
void NetworkQueryServer(const std::string &connection_string)
Query a server to fetch the game-info.
Definition network.cpp:670
NormalizeConnectionString
std::string NormalizeConnectionString(const std::string &connection_string, uint16_t default_port)
Normalize a connection string.
Definition network.cpp:541
NetworkClientJoinGame
void NetworkClientJoinGame()
Actually perform the joining to the server.
Definition network.cpp:818
NetworkHasJoiningClient
static bool NetworkHasJoiningClient()
Checks whether there is a joining client.
Definition network.cpp:450
FindKey
static auto FindKey(auto *authorized_keys, std::string_view authorized_key)
Simple helper to find the location of the given authorized key in the authorized keys.
Definition network.cpp:168
_redirect_console_to_client
ClientID _redirect_console_to_client
If not invalid, redirect the console output to a client.
Definition network.cpp:71
CheckClientAndServerName
static void CheckClientAndServerName()
Check whether the client and server name are set, for a dedicated server and if not set them to some ...
Definition network.cpp:873
NetworkOnGameStart
void NetworkOnGameStart()
Perform tasks when the server is started.
Definition network.cpp:945
ParseCompanyFromConnectionString
std::string_view ParseCompanyFromConnectionString(const std::string &connection_string, CompanyID *company_id)
Parse the company part ("#company" postfix) of a connecting string.
Definition network.cpp:477
_frame_counter
uint32_t _frame_counter
The current frame.
Definition network.cpp:78
_network_available
bool _network_available
is network mode available?
Definition network.cpp:67
_network_reconnect
uint8_t _network_reconnect
Reconnect timeout.
Definition network.cpp:72
_networking
bool _networking
are we in networking mode?
Definition network.cpp:65
InitializeNetworkPools
static void InitializeNetworkPools(bool close_admins=true)
Resets the pools used for network clients, and the admin pool if needed.
Definition network.cpp:583
_network_ban_list
StringList _network_ban_list
The banned clients.
Definition network.cpp:75
ParseFullConnectionString
std::string_view ParseFullConnectionString(const std::string &connection_string, uint16_t &port, CompanyID *company_id)
Converts a string to ip/port/company Format: IP:port::company.
Definition network.cpp:521
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition network.cpp:68
HasClients
bool HasClients()
Return whether there is any client connected or trying to connect at all.
Definition network.cpp:97
NetworkReceive
static bool NetworkReceive()
Receives something from the network.
Definition network.cpp:1050
NetworkAddServer
NetworkGameList * NetworkAddServer(const std::string &connection_string, bool manually, bool never_expire)
Validates an address entered as a string and adds the server to the list.
Definition network.cpp:692
NetworkDisconnect
void NetworkDisconnect(bool close_admins)
We want to disconnect from the host/clients.
Definition network.cpp:999
_network_server
bool _network_server
network-server is active
Definition network.cpp:66
GenerateUid
std::string GenerateUid(std::string_view subject)
Generate an unique ID.
Definition misc.cpp:66
_sync_seed_1
uint32_t _sync_seed_1
Seed to compare during sync checks.
Definition network.cpp:81
_sync_frame
uint32_t _sync_frame
The frame to perform the sync check.
Definition network.cpp:85
NetworkBackgroundLoop
void NetworkBackgroundLoop()
We have to do some (simple) background stuff that runs normally, even when we are not in multiplayer.
Definition network.cpp:1080
_network_bind_list
StringList _network_bind_list
The addresses to bind on.
Definition network.cpp:73
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:436
_network_own_client_id
ClientID _network_own_client_id
Our client identifier.
Definition network.cpp:70
CheckPauseHelper
static void CheckPauseHelper(bool pause, PauseMode pm)
Helper function for the pause checkers.
Definition network.cpp:408
NetworkClientConnectGame
bool NetworkClientConnectGame(const std::string &connection_string, CompanyID default_company, const std::string &join_server_password)
Join a client to the server at with the given connection string.
Definition network.cpp:785
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:354
_network_first_time
bool _network_first_time
Whether we have finished joining or not.
Definition network.cpp:86
NetworkShutDown
void NetworkShutDown()
This shuts the network down.
Definition network.cpp:1301
_network_clients_connected
uint8_t _network_clients_connected
The amount of clients connected.
Definition network.cpp:89
GetBindAddresses
void GetBindAddresses(NetworkAddressList *addresses, uint16_t port)
Get the addresses to bind to.
Definition network.cpp:718
ParseConnectionString
NetworkAddress ParseConnectionString(const std::string &connection_string, uint16_t default_port)
Convert a string containing either "hostname" or "hostname:ip" to a NetworkAddress.
Definition network.cpp:556
NetworkUpdateServerGameType
void NetworkUpdateServerGameType()
The setting server_game_type was updated; possibly we need to take some action.
Definition network.cpp:1027
NetworkCanJoinCompany
bool NetworkCanJoinCompany(CompanyID company_id)
Returns whether the given company can be joined by this client.
Definition network.cpp:141
NetworkClose
void NetworkClose(bool close_admins)
Close current connections.
Definition network.cpp:592
_frame_counter_max
uint32_t _frame_counter_max
To where we may go with our clients.
Definition network.cpp:77
NetworkValidateServerName
bool NetworkValidateServerName(std::string &server_name)
Trim the given server name in place, i.e.
Definition network.cpp:858
network_admin.h
Server part of the admin network protocol.
network_base.h
Base core network types and some helper functions to access them.
NetworkAddChatMessage
void CDECL NetworkAddChatMessage(TextColour colour, uint duration, const std::string &message)
Add a text message to the 'chat window' to be shown.
Definition network_chat_gui.cpp:86
_network_join
NetworkJoinInfo _network_join
Information about the game to join to.
Definition network_client.cpp:322
NetworkValidateOurClientName
bool NetworkValidateOurClientName()
Convenience method for NetworkValidateClientName on _settings_client.network.client_name.
Definition network_client.cpp:1325
NetworkClient_Connected
void NetworkClient_Connected()
Is called after a client is connected to the server.
Definition network_client.cpp:1229
network_client.h
Client part of the network protocol.
NetworkFreeLocalCommandQueue
void NetworkFreeLocalCommandQueue()
Free the local command queues.
Definition network_command.cpp:279
NetworkExecuteLocalCommandQueue
void NetworkExecuteLocalCommandQueue()
Execute all commands on the local command queue that ought to be executed this frame.
Definition network_command.cpp:245
NetworkDistributeCommands
void NetworkDistributeCommands()
Distribute the commands of ourself and the clients.
Definition network_command.cpp:346
_network_content_client
ClientNetworkContentSocketHandler _network_content_client
The client we use to connect to the server.
Definition network_content.cpp:36
network_content.h
Part of the network protocol handling content distribution.
_network_coordinator_client
ClientNetworkCoordinatorSocketHandler _network_coordinator_client
The connection to the Game Coordinator.
Definition network_coordinator.cpp:30
network_coordinator.h
Part of the network protocol handling Game Coordinator requests.
NetworkServerNewCompany
void NetworkServerNewCompany(const Company *company, NetworkClientInfo *ci)
Perform all the server specific administration of a new company.
Definition network_server.cpp:2151
NetworkServerUpdateGameInfo
void NetworkServerUpdateGameInfo()
Update the server's NetworkServerGameInfo due to changes in settings.
Definition network_server.cpp:1972
NetworkGameListAddItem
NetworkGameList * NetworkGameListAddItem(const std::string &connection_string)
Add a new item to the linked gamelist.
Definition network_gamelist.cpp:32
_network_game_list
NetworkGameList * _network_game_list
Game list of this client.
Definition network_gamelist.cpp:23
network_gamelist.h
Handling of the list of games.
NGLS_OFFLINE
@ NGLS_OFFLINE
Server is offline (or cannot be queried).
Definition network_gamelist.h:19
_network_join_status
NetworkJoinStatus _network_join_status
The status of joining.
Definition network_gui.cpp:2079
UpdateNetworkGameWindow
void UpdateNetworkGameWindow()
Update the network new window because a new server is found on the network.
Definition network_gui.cpp:66
network_gui.h
GUIs related to networking.
network_query.h
Query part of the network protocol.
ChangeNetworkRestartTime
void ChangeNetworkRestartTime(bool reset)
Reset the automatic network restart time interval.
Definition network_server.cpp:1853
NetworkServer_Tick
void NetworkServer_Tick(bool send_frame)
This is called every tick if this is a _network_server.
Definition network_server.cpp:1685
network_server.h
Server part of the network protocol.
DESTTYPE_CLIENT
@ DESTTYPE_CLIENT
Send message/notice to only a certain client (Private)
Definition network_type.h:82
NetworkAction
NetworkAction
Actions that can be used for NetworkTextMessage.
Definition network_type.h:90
ClientID
ClientID
'Unique' identifier to be given to clients
Definition network_type.h:49
CLIENT_ID_SERVER
@ CLIENT_ID_SERVER
Servers always have this ID.
Definition network_type.h:51
NetworkErrorCode
NetworkErrorCode
The error codes we send around in the protocols.
Definition network_type.h:110
NetworkUDPClose
void NetworkUDPClose()
Close all UDP related stuff.
Definition network_udp.cpp:150
NetworkUDPInitialize
void NetworkUDPInitialize()
Initialize the whole UDP bit.
Definition network_udp.cpp:125
NetworkUDPServerListen
void NetworkUDPServerListen()
Start the listening of the UDP server component.
Definition network_udp.cpp:144
NetworkBackgroundUDPLoop
void NetworkBackgroundUDPLoop()
Receive the UDP packets.
Definition network_udp.cpp:161
network_udp.h
Sending and receiving UDP messages.
ClearGRFConfigList
void ClearGRFConfigList(GRFConfig **config)
Clear a GRF Config list, freeing all nodes.
Definition newgrf_config.cpp:336
StateGameLoop
void StateGameLoop()
State controlling game loop.
Definition openttd.cpp:1212
SM_JOIN_GAME
@ SM_JOIN_GAME
Join a network game.
Definition openttd.h:41
SM_MENU
@ SM_MENU
Switch to game intro menu.
Definition openttd.h:33
PauseMode
PauseMode
Modes of pausing we've got.
Definition openttd.h:68
PM_UNPAUSED
@ PM_UNPAUSED
A normal unpaused game.
Definition openttd.h:69
PM_PAUSED_ACTIVE_CLIENTS
@ PM_PAUSED_ACTIVE_CLIENTS
A game paused for 'min_active_clients'.
Definition openttd.h:74
PM_PAUSED_ERROR
@ PM_PAUSED_ERROR
A game paused because a (critical) error.
Definition openttd.h:73
PM_PAUSED_GAME_SCRIPT
@ PM_PAUSED_GAME_SCRIPT
A game paused by a game script.
Definition openttd.h:75
PM_PAUSED_JOIN
@ PM_PAUSED_JOIN
A game paused for 'pause_on_join'.
Definition openttd.h:72
PM_PAUSED_LINK_GRAPH
@ PM_PAUSED_LINK_GRAPH
A game paused due to the link graph schedule lagging.
Definition openttd.h:76
PM_PAUSED_NORMAL
@ PM_PAUSED_NORMAL
A game normally paused.
Definition openttd.h:70
INSTANTIATE_POOL_METHODS
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
Definition pool_func.hpp:237
PT_NONE
@ PT_NONE
No pool is selected.
Definition pool_type.hpp:17
PT_NADMIN
@ PT_NADMIN
Network admin pool.
Definition pool_type.hpp:20
PT_NCLIENT
@ PT_NCLIENT
Network client pools.
Definition pool_type.hpp:19
_random
Randomizer _random
Random used in the game state calculations.
Definition random_func.cpp:37
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:56
lengthof
#define lengthof(array)
Return the length of an fixed size array.
Definition stdafx.h:280
StrEqualsIgnoreCase
bool StrEqualsIgnoreCase(const std::string_view str1, const std::string_view str2)
Compares two string( view)s for equality, while ignoring the case of the characters.
Definition string.cpp:347
FormatArrayAsHex
std::string FormatArrayAsHex(std::span< const uint8_t > data)
Format a byte array into a continuous hex string.
Definition string.cpp:81
StrTrimInPlace
void StrTrimInPlace(std::string &str)
Trim the spaces from given string in place, i.e.
Definition string.cpp:260
Utf8Encode
size_t Utf8Encode(T buf, char32_t c)
Encode a unicode character and place it in the buffer.
Definition string.cpp:460
CHAR_TD_LRM
static const char32_t CHAR_TD_LRM
The next character acts like a left-to-right character.
Definition string_type.h:35
CHAR_TD_RLM
static const char32_t CHAR_TD_RLM
The next character acts like a right-to-left character.
Definition string_type.h:36
StringList
std::vector< std::string > StringList
Type for a list of strings.
Definition string_type.h:60
SetDParam
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
Definition strings.cpp:104
GetString
std::string GetString(StringID string)
Resolve the given StringID into a std::string with all the associated DParam lookups and formatting.
Definition strings.cpp:333
_current_text_dir
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition strings.cpp:56
SetDParamStr
void SetDParamStr(size_t n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition strings.cpp:371
TD_LTR
@ TD_LTR
Text is written left-to-right by default.
Definition strings_type.h:23
StringID
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition strings_type.h:16
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::network
NetworkSettings network
settings related to the network
Definition settings_type.h:611
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition settings_type.h:610
CommandHelper
Definition command_func.h:83
CommandPacket
Everything we need to know about a command to be able to execute it.
Definition network_internal.h:94
CommandPacket::err_msg
StringID err_msg
string ID of error message to use.
Definition network_internal.h:101
CommandPacket::data
CommandDataBuffer data
command parameters.
Definition network_internal.h:103
CommandPacket::company
CompanyID company
company that is executing the command
Definition network_internal.h:96
CommandPacket::cmd
Commands cmd
command being executed.
Definition network_internal.h:100
CommandTraits
Defines the traits of a command.
Definition command_type.h:453
CompanyProperties::allow_list
NetworkAuthorizedKeys allow_list
Public keys of clients that are allowed to join this company.
Definition company_base.h:78
CompanyProperties::name_1
StringID name_1
Name of the company if the user did not change it.
Definition company_base.h:71
CompanyProperties::name
std::string name
Name of the company if the user changed it.
Definition company_base.h:72
Company
Definition company_base.h:133
GUISettings::network_chat_timeout
uint16_t network_chat_timeout
timeout of chat messages in seconds
Definition settings_type.h:220
NetworkClientInfo
Container for all information known about a client.
Definition network_base.h:24
NetworkClientInfo::GetByClientID
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it's client-identifier.
Definition network.cpp:116
NetworkClientInfo::~NetworkClientInfo
~NetworkClientInfo()
Basically a client is leaving us right now.
Definition network.cpp:105
NetworkClientInfo::CanJoinCompany
bool CanJoinCompany(CompanyID company_id) const
Returns whether the given company can be joined by this client.
Definition network.cpp:130
NetworkClientInfo::client_playas
CompanyID client_playas
As which company is this client playing (CompanyID)
Definition network_base.h:28
NetworkClientInfo::client_id
ClientID client_id
Client identifier (same as ClientState->client_id)
Definition network_base.h:25
NetworkClientInfo::client_name
std::string client_name
Name of the client.
Definition network_base.h:26
NetworkClientInfo::public_key
std::string public_key
The public key of the client.
Definition network_base.h:27
NetworkGameList
Structure with information shown in the game list (GUI)
Definition network_gamelist.h:27
NetworkGameList::version
int version
Used to see which servers are no longer available on the Game Coordinator and can be removed.
Definition network_gamelist.h:35
NetworkGameList::refreshing
bool refreshing
Whether this server is being queried.
Definition network_gamelist.h:34
NetworkGameList::manually
bool manually
True if the server was added manually.
Definition network_gamelist.h:33
NetworkGameList::next
NetworkGameList * next
Next pointer to make a linked game list.
Definition network_gamelist.h:36
NetworkGameList::status
NetworkGameListStatus status
Stats of the server.
Definition network_gamelist.h:32
NetworkGameList::info
NetworkGameInfo info
The game information of this server.
Definition network_gamelist.h:30
NetworkJoinInfo::connection_string
std::string connection_string
The address of the server to join.
Definition network_client.h:111
NetworkJoinInfo::server_password
std::string server_password
The password of the server to join.
Definition network_client.h:113
NetworkJoinInfo::company
CompanyID company
The company to join.
Definition network_client.h:112
NetworkServerGameInfo::server_name
std::string server_name
Server name.
Definition network_game_info.h:103
NetworkServerGameInfo::grfconfig
GRFConfig * grfconfig
List of NewGRF files used.
Definition network_game_info.h:97
NetworkServerGameInfo::clients_on
uint8_t clients_on
Current count of clients on server.
Definition network_game_info.h:107
NetworkSettings::client_secret_key
std::string client_secret_key
The secret key of the client for authorized key logins.
Definition settings_type.h:331
NetworkSettings::client_name
std::string client_name
name of the player (as client)
Definition settings_type.h:330
NetworkSettings::server_game_type
ServerGameType server_game_type
Server type: local / public / invite-only.
Definition settings_type.h:319
NetworkSettings::client_public_key
std::string client_public_key
The public key of the client for authorized key logins.
Definition settings_type.h:332
NetworkSettings::frame_freq
uint8_t frame_freq
how often do we send commands to the clients
Definition settings_type.h:304
NetworkSettings::min_active_clients
uint8_t min_active_clients
minimum amount of active clients to unpause the game
Definition settings_type.h:341
NetworkSettings::server_port
uint16_t server_port
port the server listens on
Definition settings_type.h:316
NetworkSettings::last_joined
std::string last_joined
Last joined server.
Definition settings_type.h:343
NetworkSettings::server_name
std::string server_name
name of the server
Definition settings_type.h:322
NetworkSettings::server_admin_port
uint16_t server_admin_port
port the server listens on for the admin network
Definition settings_type.h:317
NetworkSettings::pause_on_join
bool pause_on_join
pause the game when people join
Definition settings_type.h:315
PoolBase::Clean
static void Clean(PoolType)
Clean all pools of given type.
Definition pool_func.cpp:30
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition pool_type.hpp:238
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:328
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:388
Pool::PoolItem<&_company_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition pool_type.hpp:350
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:309
Pool
Base class for all pools.
Definition pool_type.hpp:80
Pool::MAX_SIZE
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
Definition pool_type.hpp:84
Randomizer::state
uint32_t state[2]
The state of the randomizer.
Definition random_func.hpp:29
udp.h
Basic functions to receive and send UDP packets.
CloseWindowById
void CloseWindowById(WindowClass cls, WindowNumber number, bool force, int data)
Close a window by its class and window number (if it is open).
Definition window.cpp:1140
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:3219
WN_NETWORK_STATUS_WINDOW_JOIN
@ WN_NETWORK_STATUS_WINDOW_JOIN
Network join status.
Definition window_type.h:39
WC_SEND_NETWORK_MSG
@ WC_SEND_NETWORK_MSG
Chatbox; Window numbers:
Definition window_type.h:509
WC_CLIENT_LIST
@ WC_CLIENT_LIST
Client list; Window numbers:
Definition window_type.h:484
WC_NETWORK_STATUS_WINDOW
@ WC_NETWORK_STATUS_WINDOW
Network status window; Window numbers:
Definition window_type.h:491