OpenTTD Source  1.10.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 
47 
51 
71 uint32 _sync_seed_1;
72 #ifdef NETWORK_SEND_DOUBLE_SEED
73 uint32 _sync_seed_2;
74 #endif
75 uint32 _sync_frame;
81 
82 /* Check whether NETWORK_NUM_LANDSCAPES is still in sync with NUM_LANDSCAPE */
83 assert_compile((int)NETWORK_NUM_LANDSCAPES == (int)NUM_LANDSCAPE);
85 
89 
92 
93 /* Some externs / forwards */
94 extern void StateGameLoop();
95 
101 {
102  return !NetworkClientSocket::Iterate().empty();
103 }
104 
109 {
110  /* Delete the chat window, if you were chatting with this client. */
112 }
113 
120 {
122  if (ci->client_id == client_id) return ci;
123  }
124 
125  return nullptr;
126 }
127 
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 {
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 
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 = self_send ? STR_NETWORK_MESSAGE_GAVE_MONEY_AWAY : 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);
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 {
292 }
293 
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  assert_compile(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:
346  bool changed = ((_pause_mode == PM_UNPAUSED) != (prev_mode == PM_UNPAUSED));
347  bool paused = (_pause_mode != PM_UNPAUSED);
348  if (!paused && !changed) return;
349 
350  StringID str;
351  if (!changed) {
352  int i = -1;
353 
354  if ((_pause_mode & PM_PAUSED_NORMAL) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL);
355  if ((_pause_mode & PM_PAUSED_JOIN) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS);
356  if ((_pause_mode & PM_PAUSED_GAME_SCRIPT) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_GAME_SCRIPT);
357  if ((_pause_mode & PM_PAUSED_ACTIVE_CLIENTS) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS);
358  str = STR_NETWORK_SERVER_MESSAGE_GAME_STILL_PAUSED_1 + i;
359  } else {
360  switch (changed_mode) {
361  case PM_PAUSED_NORMAL: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL); break;
362  case PM_PAUSED_JOIN: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS); break;
363  case PM_PAUSED_GAME_SCRIPT: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_GAME_SCRIPT); break;
364  case PM_PAUSED_ACTIVE_CLIENTS: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS); break;
365  default: NOT_REACHED();
366  }
367  str = paused ? STR_NETWORK_SERVER_MESSAGE_GAME_PAUSED : STR_NETWORK_SERVER_MESSAGE_GAME_UNPAUSED;
368  }
369 
370  char buffer[DRAW_STRING_BUFFER];
371  GetString(buffer, str, lastof(buffer));
372  NetworkTextMessage(NETWORK_ACTION_SERVER_MESSAGE, CC_DEFAULT, false, nullptr, buffer);
373  break;
374  }
375 
376  default:
377  return;
378  }
379 }
380 
381 
390 static void CheckPauseHelper(bool pause, PauseMode pm)
391 {
392  if (pause == ((_pause_mode & pm) != PM_UNPAUSED)) return;
393 
394  DoCommandP(0, pm, pause ? 1 : 0, CMD_PAUSE);
395 }
396 
403 {
404  uint count = 0;
405 
406  for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
407  if (cs->status != NetworkClientSocket::STATUS_ACTIVE) continue;
408  if (!Company::IsValidID(cs->GetInfo()->client_playas)) continue;
409  count++;
410  }
411 
412  return count;
413 }
414 
419 {
421  !_network_dedicated ||
423  return;
424  }
426 }
427 
433 {
434  for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
435  if (cs->status >= NetworkClientSocket::STATUS_AUTHORIZED && cs->status < NetworkClientSocket::STATUS_ACTIVE) return true;
436  }
437 
438  return false;
439 }
440 
444 static void CheckPauseOnJoin()
445 {
448  return;
449  }
450  CheckPauseHelper(NetworkHasJoiningClient(), PM_PAUSED_JOIN);
451 }
452 
461 void ParseConnectionString(const char **company, const char **port, char *connection_string)
462 {
463  bool ipv6 = (strchr(connection_string, ':') != strrchr(connection_string, ':'));
464  char *p;
465  for (p = connection_string; *p != '\0'; p++) {
466  switch (*p) {
467  case '[':
468  ipv6 = true;
469  break;
470 
471  case ']':
472  ipv6 = false;
473  break;
474 
475  case '#':
476  *company = p + 1;
477  *p = '\0';
478  break;
479 
480  case ':':
481  if (ipv6) break;
482  *port = p + 1;
483  *p = '\0';
484  break;
485  }
486  }
487 }
488 
494 /* static */ void ServerNetworkGameSocketHandler::AcceptConnection(SOCKET s, const NetworkAddress &address)
495 {
496  /* Register the login */
497  _network_clients_connected++;
498 
501  cs->client_address = address; // Save the IP of the client
502 }
503 
508 static void InitializeNetworkPools(bool close_admins = true)
509 {
510  PoolBase::Clean(PT_NCLIENT | (close_admins ? PT_NADMIN : PT_NONE));
511 }
512 
517 void NetworkClose(bool close_admins)
518 {
519  if (_network_server) {
520  if (close_admins) {
522  as->CloseConnection(true);
523  }
524  }
525 
526  for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
527  cs->CloseConnection(NETWORK_RECV_STATUS_CONN_LOST);
528  }
531  } else if (MyClient::my_client != nullptr) {
534  }
535 
537 
538  _networking = false;
539  _network_server = false;
540 
542 
544  _network_company_states = nullptr;
545 
546  InitializeNetworkPools(close_admins);
547 }
548 
549 /* Initializes the network (cleans sockets and stuff) */
550 static void NetworkInitialize(bool close_admins = true)
551 {
552  InitializeNetworkPools(close_admins);
554 
555  _sync_frame = 0;
556  _network_first_time = true;
557 
558  _network_reconnect = 0;
559 }
560 
563 public:
564  TCPQueryConnecter(const NetworkAddress &address) : TCPConnecter(address) {}
565 
566  void OnFailure() override
567  {
569  }
570 
571  void OnConnect(SOCKET s) override
572  {
573  _networking = true;
576  }
577 };
578 
579 /* Query a server to fetch his game-info
580  * If game_info is true, only the gameinfo is fetched,
581  * else only the client_info is fetched */
582 void NetworkTCPQueryServer(NetworkAddress address)
583 {
584  if (!_network_available) return;
585 
587  NetworkInitialize();
588 
589  new TCPQueryConnecter(address);
590 }
591 
592 /* Validates an address entered as a string and adds the server to
593  * the list. If you use this function, the games will be marked
594  * as manually added. */
595 void NetworkAddServer(const char *b)
596 {
597  if (*b != '\0') {
598  const char *port = nullptr;
599  const char *company = nullptr;
600  char host[NETWORK_HOSTNAME_LENGTH];
601  uint16 rport;
602 
603  strecpy(host, b, lastof(host));
604 
606  rport = NETWORK_DEFAULT_PORT;
607 
608  ParseConnectionString(&company, &port, host);
609  if (port != nullptr) rport = atoi(port);
610 
611  NetworkUDPQueryServer(NetworkAddress(host, rport), true);
612  }
613 }
614 
620 void GetBindAddresses(NetworkAddressList *addresses, uint16 port)
621 {
622  for (const auto &iter : _network_bind_list) {
623  addresses->emplace_back(iter.c_str(), port);
624  }
625 
626  /* No address, so bind to everything. */
627  if (addresses->size() == 0) {
628  addresses->emplace_back("", port);
629  }
630 }
631 
632 /* Generates the list of manually added hosts from NetworkGameList and
633  * dumps them into the array _network_host_list. This array is needed
634  * by the function that generates the config file. */
635 void NetworkRebuildHostList()
636 {
637  _network_host_list.clear();
638 
639  for (NetworkGameList *item = _network_game_list; item != nullptr; item = item->next) {
640  if (item->manually) _network_host_list.emplace_back(item->address.GetAddressAsString(false));
641  }
642 }
643 
646 public:
647  TCPClientConnecter(const NetworkAddress &address) : TCPConnecter(address) {}
648 
649  void OnFailure() override
650  {
651  NetworkError(STR_NETWORK_ERROR_NOCONNECTION);
652  }
653 
654  void OnConnect(SOCKET s) override
655  {
656  _networking = true;
658  IConsoleCmdExec("exec scripts/on_client.scr 0");
660  }
661 };
662 
663 
664 /* Used by clients, to connect to a server */
665 void NetworkClientConnectGame(NetworkAddress address, CompanyID join_as, const char *join_server_password, const char *join_company_password)
666 {
667  if (!_network_available) return;
668 
669  if (address.GetPort() == 0) return;
670 
673  _network_join_as = join_as;
674  _network_join_server_password = join_server_password;
675  _network_join_company_password = join_company_password;
676 
678  NetworkInitialize();
679 
680  _network_join_status = NETWORK_JOIN_STATUS_CONNECTING;
681  ShowJoinStatusWindow();
682 
683  new TCPClientConnecter(address);
684 }
685 
686 static void NetworkInitGameInfo()
687 {
690  }
691 
692  /* The server is a client too */
693  _network_game_info.clients_on = _network_dedicated ? 0 : 1;
694 
695  /* There should be always space for the server. */
698  ci->client_playas = _network_dedicated ? COMPANY_SPECTATOR : COMPANY_FIRST;
699 
701 }
702 
703 bool NetworkServerStart()
704 {
705  if (!_network_available) return false;
706 
707  /* Call the pre-scripts */
708  IConsoleCmdExec("exec scripts/pre_server.scr 0");
709  if (_network_dedicated) IConsoleCmdExec("exec scripts/pre_dedicated.scr 0");
710 
711  NetworkDisconnect(false, false);
712  NetworkInitialize(false);
713  DEBUG(net, 1, "starting listeners for clients");
715 
716  /* Only listen for admins when the password isn't empty. */
718  DEBUG(net, 1, "starting listeners for admins");
720  }
721 
722  /* Try to start UDP-server */
723  DEBUG(net, 1, "starting listeners for incoming server queries");
724  _network_udp_server = _udp_server_socket->Listen();
725 
726  _network_company_states = CallocT<NetworkCompanyState>(MAX_COMPANIES);
727  _network_server = true;
728  _networking = true;
729  _frame_counter = 0;
730  _frame_counter_server = 0;
731  _frame_counter_max = 0;
732  _last_sync_frame = 0;
733  _network_own_client_id = CLIENT_ID_SERVER;
734 
735  _network_clients_connected = 0;
736  _network_company_passworded = 0;
737 
738  NetworkInitGameInfo();
739 
740  /* execute server initialization script */
741  IConsoleCmdExec("exec scripts/on_server.scr 0");
742  /* if the server is dedicated ... add some other script */
743  if (_network_dedicated) IConsoleCmdExec("exec scripts/on_dedicated.scr 0");
744 
745  /* Try to register us to the master server */
746  _network_need_advertise = true;
748 
749  /* welcome possibly still connected admins - this can only happen on a dedicated server. */
750  if (_network_dedicated) ServerNetworkAdminSocketHandler::WelcomeAll();
751 
752  return true;
753 }
754 
755 /* The server is rebooting...
756  * The only difference with NetworkDisconnect, is the packets that is sent */
757 void NetworkReboot()
758 {
759  if (_network_server) {
760  for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
761  cs->SendNewGame();
762  cs->SendPackets();
763  }
764 
766  as->SendNewGame();
767  as->SendPackets();
768  }
769  }
770 
771  /* For non-dedicated servers we have to kick the admins as we are not
772  * certain that we will end up in a new network game. */
773  NetworkClose(!_network_dedicated);
774 }
775 
781 void NetworkDisconnect(bool blocking, bool close_admins)
782 {
783  if (_network_server) {
784  for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
785  cs->SendShutdown();
786  cs->SendPackets();
787  }
788 
789  if (close_admins) {
791  as->SendShutdown();
792  as->SendPackets();
793  }
794  }
795  }
796 
798 
800 
801  NetworkClose(close_admins);
802 
803  /* Reinitialize the UDP stack, i.e. close all existing connections. */
805 }
806 
811 static bool NetworkReceive()
812 {
813  if (_network_server) {
816  } else {
818  }
819 }
820 
821 /* This sends all buffered commands (if possible) */
822 static void NetworkSend()
823 {
824  if (_network_server) {
827  } else {
829  }
830 }
831 
838 {
842 
844 }
845 
846 /* The main loop called from ttd.c
847  * Here we also have to do StateGameLoop if needed! */
848 void NetworkGameLoop()
849 {
850  if (!_networking) return;
851 
852  if (!NetworkReceive()) return;
853 
854  if (_network_server) {
855  /* Log the sync state to check for in-syncedness of replays. */
856  if (_date_fract == 0) {
857  /* We don't want to log multiple times if paused. */
858  static Date last_log;
859  if (last_log != _date) {
860  DEBUG(desync, 1, "sync: %08x; %02x; %08x; %08x", _date, _date_fract, _random.state[0], _random.state[1]);
861  last_log = _date;
862  }
863  }
864 
865 #ifdef DEBUG_DUMP_COMMANDS
866  /* Loading of the debug commands from -ddesync>=1 */
867  static FILE *f = FioFOpenFile("commands.log", "rb", SAVE_DIR);
868  static Date next_date = 0;
869  static uint32 next_date_fract;
870  static CommandPacket *cp = nullptr;
871  static bool check_sync_state = false;
872  static uint32 sync_state[2];
873  if (f == nullptr && next_date == 0) {
874  DEBUG(net, 0, "Cannot open commands.log");
875  next_date = 1;
876  }
877 
878  while (f != nullptr && !feof(f)) {
879  if (_date == next_date && _date_fract == next_date_fract) {
880  if (cp != nullptr) {
881  NetworkSendCommand(cp->tile, cp->p1, cp->p2, cp->cmd & ~CMD_FLAGS_MASK, nullptr, cp->text, cp->company);
882  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));
883  free(cp);
884  cp = nullptr;
885  }
886  if (check_sync_state) {
887  if (sync_state[0] == _random.state[0] && sync_state[1] == _random.state[1]) {
888  DEBUG(net, 0, "sync check: %08x; %02x; match", _date, _date_fract);
889  } else {
890  DEBUG(net, 0, "sync check: %08x; %02x; mismatch expected {%08x, %08x}, got {%08x, %08x}",
891  _date, _date_fract, sync_state[0], sync_state[1], _random.state[0], _random.state[1]);
892  NOT_REACHED();
893  }
894  check_sync_state = false;
895  }
896  }
897 
898  if (cp != nullptr || check_sync_state) break;
899 
900  char buff[4096];
901  if (fgets(buff, lengthof(buff), f) == nullptr) break;
902 
903  char *p = buff;
904  /* Ignore the "[date time] " part of the message */
905  if (*p == '[') {
906  p = strchr(p, ']');
907  if (p == nullptr) break;
908  p += 2;
909  }
910 
911  if (strncmp(p, "cmd: ", 5) == 0
912 #ifdef DEBUG_FAILED_DUMP_COMMANDS
913  || strncmp(p, "cmdf: ", 6) == 0
914 #endif
915  ) {
916  p += 5;
917  if (*p == ' ') p++;
918  cp = CallocT<CommandPacket>(1);
919  int company;
920  int ret = sscanf(p, "%x; %x; %x; %x; %x; %x; %x; \"%[^\"]\"", &next_date, &next_date_fract, &company, &cp->tile, &cp->p1, &cp->p2, &cp->cmd, cp->text);
921  /* There are 8 pieces of data to read, however the last is a
922  * string that might or might not exist. Ignore it if that
923  * string misses because in 99% of the time it's not used. */
924  assert(ret == 8 || ret == 7);
925  cp->company = (CompanyID)company;
926  } else if (strncmp(p, "join: ", 6) == 0) {
927  /* Manually insert a pause when joining; this way the client can join at the exact right time. */
928  int ret = sscanf(p + 6, "%x; %x", &next_date, &next_date_fract);
929  assert(ret == 2);
930  DEBUG(net, 0, "injecting pause for join at %08x:%02x; please join when paused", next_date, next_date_fract);
931  cp = CallocT<CommandPacket>(1);
933  cp->cmd = CMD_PAUSE;
934  cp->p1 = PM_PAUSED_NORMAL;
935  cp->p2 = 1;
936  _ddc_fastforward = false;
937  } else if (strncmp(p, "sync: ", 6) == 0) {
938  int ret = sscanf(p + 6, "%x; %x; %x; %x", &next_date, &next_date_fract, &sync_state[0], &sync_state[1]);
939  assert(ret == 4);
940  check_sync_state = true;
941  } else if (strncmp(p, "msg: ", 5) == 0 || strncmp(p, "client: ", 8) == 0 ||
942  strncmp(p, "load: ", 6) == 0 || strncmp(p, "save: ", 6) == 0) {
943  /* A message that is not very important to the log playback, but part of the log. */
944 #ifndef DEBUG_FAILED_DUMP_COMMANDS
945  } else if (strncmp(p, "cmdf: ", 6) == 0) {
946  DEBUG(net, 0, "Skipping replay of failed command: %s", p + 6);
947 #endif
948  } else {
949  /* Can't parse a line; what's wrong here? */
950  DEBUG(net, 0, "trying to parse: %s", p);
951  NOT_REACHED();
952  }
953  }
954  if (f != nullptr && feof(f)) {
955  DEBUG(net, 0, "End of commands.log");
956  fclose(f);
957  f = nullptr;
958  }
959 #endif /* DEBUG_DUMP_COMMANDS */
960  if (_frame_counter >= _frame_counter_max) {
961  /* Only check for active clients just before we're going to send out
962  * the commands so we don't send multiple pause/unpause commands when
963  * the frame_freq is more than 1 tick. Same with distributing commands. */
967  }
968 
969  bool send_frame = false;
970 
971  /* We first increase the _frame_counter */
972  _frame_counter++;
973  /* Update max-frame-counter */
974  if (_frame_counter > _frame_counter_max) {
975  _frame_counter_max = _frame_counter + _settings_client.network.frame_freq;
976  send_frame = true;
977  }
978 
980 
981  /* Then we make the frame */
982  StateGameLoop();
983 
984  _sync_seed_1 = _random.state[0];
985 #ifdef NETWORK_SEND_DOUBLE_SEED
986  _sync_seed_2 = _random.state[1];
987 #endif
988 
989  NetworkServer_Tick(send_frame);
990  } else {
991  /* Client */
992 
993  /* Make sure we are at the frame were the server is (quick-frames) */
994  if (_frame_counter_server > _frame_counter) {
995  /* Run a number of frames; when things go bad, get out. */
996  while (_frame_counter_server > _frame_counter) {
998  }
999  } else {
1000  /* Else, keep on going till _frame_counter_max */
1001  if (_frame_counter_max > _frame_counter) {
1002  /* Run one frame; if things went bad, get out. */
1004  }
1005  }
1006  }
1007 
1008  NetworkSend();
1009 }
1010 
1011 static void NetworkGenerateServerId()
1012 {
1013  Md5 checksum;
1014  uint8 digest[16];
1015  char hex_output[16 * 2 + 1];
1016  char coding_string[NETWORK_NAME_LENGTH];
1017  int di;
1018 
1019  seprintf(coding_string, lastof(coding_string), "%d%s", (uint)Random(), "OpenTTD Server ID");
1020 
1021  /* Generate the MD5 hash */
1022  checksum.Append((const uint8*)coding_string, strlen(coding_string));
1023  checksum.Finish(digest);
1024 
1025  for (di = 0; di < 16; ++di) {
1026  seprintf(hex_output + di * 2, lastof(hex_output), "%02x", digest[di]);
1027  }
1028 
1029  /* _settings_client.network.network_id is our id */
1031 }
1032 
1033 void NetworkStartDebugLog(NetworkAddress address)
1034 {
1035  extern SOCKET _debug_socket; // Comes from debug.c
1036 
1037  DEBUG(net, 0, "Redirecting DEBUG() to %s:%d", address.GetHostname(), address.GetPort());
1038 
1039  SOCKET s = address.Connect();
1040  if (s == INVALID_SOCKET) {
1041  DEBUG(net, 0, "Failed to open socket for redirection DEBUG()");
1042  return;
1043  }
1044 
1045  _debug_socket = s;
1046 
1047  DEBUG(net, 0, "DEBUG() is now redirected");
1048 }
1049 
1052 {
1053  DEBUG(net, 3, "[core] starting network...");
1054 
1055  /* Network is available */
1056  _network_available = NetworkCoreInitialize();
1057  _network_dedicated = false;
1058  _network_need_advertise = true;
1059  _network_advertise_retries = 0;
1060 
1061  /* Generate an server id when there is none yet */
1062  if (StrEmpty(_settings_client.network.network_id)) NetworkGenerateServerId();
1063 
1064  memset(&_network_game_info, 0, sizeof(_network_game_info));
1065 
1066  NetworkInitialize();
1067  DEBUG(net, 3, "[core] network online, multiplayer available");
1068  NetworkFindBroadcastIPs(&_broadcast_list);
1069 }
1070 
1073 {
1074  NetworkDisconnect(true);
1075  NetworkUDPClose();
1076 
1077  DEBUG(net, 3, "[core] shutting down network");
1078 
1079  _network_available = false;
1080 
1082 }
1083 
1088 static const uint GITHASH_SUFFIX_LEN = 12;
1089 
1095 {
1096  /* This will be allocated on heap and never free'd, but only once so not a "real" leak. */
1097  static char *network_revision = nullptr;
1098 
1099  if (!network_revision) {
1100  /* Start by taking a chance on the full revision string. */
1101  network_revision = stredup(_openttd_revision);
1102  /* Ensure it's not longer than the packet buffer length. */
1103  if (strlen(network_revision) >= NETWORK_REVISION_LENGTH) network_revision[NETWORK_REVISION_LENGTH - 1] = '\0';
1104 
1105  /* Tag names are not mangled further. */
1106  if (_openttd_revision_tagged) {
1107  DEBUG(net, 1, "Network revision name is '%s'", network_revision);
1108  return network_revision;
1109  }
1110 
1111  /* Prepare a prefix of the git hash.
1112  * Size is length + 1 for terminator, +2 for -g prefix. */
1113  assert(_openttd_revision_modified < 3);
1114  char githash_suffix[GITHASH_SUFFIX_LEN + 1] = "-";
1115  githash_suffix[1] = "gum"[_openttd_revision_modified];
1116  for (uint i = 2; i < GITHASH_SUFFIX_LEN; i++) {
1117  githash_suffix[i] = _openttd_revision_hash[i-2];
1118  }
1119 
1120  /* Where did the hash start in the original string?
1121  * Overwrite from that position, unless that would go past end of packet buffer length. */
1122  ptrdiff_t hashofs = strrchr(_openttd_revision, '-') - _openttd_revision;
1123  if (hashofs + strlen(githash_suffix) + 1 > NETWORK_REVISION_LENGTH) hashofs = strlen(network_revision) - strlen(githash_suffix);
1124  /* Replace the git hash in revision string. */
1125  strecpy(network_revision + hashofs, githash_suffix, network_revision + NETWORK_REVISION_LENGTH);
1126  assert(strlen(network_revision) < NETWORK_REVISION_LENGTH); // strlen does not include terminator, constant does, hence strictly less than
1127  DEBUG(net, 1, "Network revision name is '%s'", network_revision);
1128  }
1129 
1130  return network_revision;
1131 }
1132 
1133 static const char *ExtractNetworkRevisionHash(const char *revstr)
1134 {
1135  return strrchr(revstr, '-');
1136 }
1137 
1143 bool IsNetworkCompatibleVersion(const char *other)
1144 {
1145  if (strncmp(GetNetworkRevisionString(), other, NETWORK_REVISION_LENGTH - 1) == 0) return true;
1146 
1147  /* If this version is tagged, then the revision string must be a complete match,
1148  * since there is no git hash suffix in it.
1149  * This is needed to avoid situations like "1.9.0-beta1" comparing equal to "2.0.0-beta1". */
1150  if (_openttd_revision_tagged) return false;
1151 
1152  const char *hash1 = ExtractNetworkRevisionHash(GetNetworkRevisionString());
1153  const char *hash2 = ExtractNetworkRevisionHash(other);
1154  return hash1 && hash2 && (strncmp(hash1, hash2, GITHASH_SUFFIX_LEN) == 0);
1155 }
Owner
Enum for all companies/owners.
Definition: company_type.h:18
void NetworkServer_Tick(bool send_frame)
This is called every tick if this is a _network_server.
A game paused for &#39;min_active_clients&#39;.
Definition: openttd.h:61
void OnFailure() override
Callback for when the connection attempt failed.
Definition: network.cpp:566
static bool NetworkReceive()
Receives something from the network.
Definition: network.cpp:811
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:461
bool _networking
are we in networking mode?
Definition: network.cpp:52
static const WChar CHAR_TD_LRM
The next character acts like a left-to-right character.
Definition: string_type.h:39
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.
const char * GetCommandName(uint32 cmd)
Definition: command.cpp:402
bool IsNetworkCompatibleVersion(const char *other)
Checks whether the given version string is compatible with our version.
Definition: network.cpp:1143
Container for all information known about a client.
Definition: network_base.h:23
uint32 _sync_seed_1
Seed to compare during sync checks.
Definition: network.cpp:71
bool server_advertise
advertise the server to the masterserver
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3218
static void WelcomeAll()
Send a Welcome packet to all connected admins.
static bool Receive()
Check whether we received/can send some data from/to the server and when that&#39;s the case handle it ap...
void GetBindAddresses(NetworkAddressList *addresses, uint16 port)
Get the addresses to bind to.
Definition: network.cpp:620
static void KillAll()
Kill all connection attempts.
Definition: tcp_connect.cpp:92
uint16 last_port
port of the last joined server
Client list; Window numbers:
Definition: window_type.h:472
bool NetworkCoreInitialize()
Initializes the network core (as that is needed for some platforms.
Definition: core.cpp:24
"Helper" class for creating TCP connections in a non-blocking manner
Definition: tcp.h:62
char server_name[NETWORK_NAME_LENGTH]
name of the server
NetworkUDPSocketHandler * _udp_client_socket
udp client socket
Definition: network_udp.cpp:46
const char * _network_join_server_password
Login password from -p argument.
The game information that is not generated on-the-fly and has to be sent to the clients.
Definition: game.h:24
Switch to game intro menu.
Definition: openttd.h:30
const char * _network_join_company_password
Company password from -P argument.
NetworkGameList * next
Next pointer to make a linked game list.
~NetworkClientInfo()
Basically a client is leaving us right now.
Definition: network.cpp:108
GUIs related to networking.
int CDECL seprintf(char *str, const char *last, const char *format,...)
Safer implementation of snprintf; same as snprintf except:
Definition: string.cpp:407
void NetworkExecuteLocalCommandQueue()
Execute all commands on the local command queue that ought to be executed this frame.
NetworkErrorCode
The error codes we send around in the protocols.
Definition: network_type.h:101
NetworkRecvStatus CloseConnection(NetworkRecvStatus status) override
Close the network connection due to the given status.
ClientID client_id
Client identifier (same as ClientState->client_id)
Definition: network_base.h:24
NetworkJoinStatus _network_join_status
The status of joining.
uint16 _network_udp_broadcast
Timeout for the UDP broadcasts.
Definition: network.cpp:78
uint32 p2
parameter p2.
Definition: command_type.h:480
Sending and receiving UDP messages.
Client part of the network protocol.
static void Send()
Send the packets for the server sockets.
void SendReceive()
Check whether we received/can send some data from/to the content server and when that&#39;s the case hand...
#define _ddc_fastforward
Helper variable to make the dedicated server go fast until the (first) join.
Wrapper for (un)resolved network addresses; there&#39;s no reason to transform a numeric IP to a string a...
Definition: address.h:27
ClientID _redirect_console_to_client
If not invalid, redirect the console output to a client.
Definition: network.cpp:60
static void Clean(PoolType)
Clean all pools of given type.
Definition: pool_func.cpp:30
void NetworkStartUp()
This tries to launch the network for a given OS.
Definition: network.cpp:1051
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:380
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
static const int DRAW_STRING_BUFFER
Size of the buffer used for drawing strings.
Definition: gfx_func.h:83
void NetworkFindBroadcastIPs(NetworkAddressList *broadcast)
Find the IPv4 broadcast addresses; IPv6 uses a completely different strategy for broadcasting.
Definition: host.cpp:194
Send message/notice to only a certain client (Private)
Definition: network_type.h:81
Base socket handler for all UDP sockets.
Definition: udp.h:46
#define lastof(x)
Get the last element of an fixed size array.
Definition: depend.cpp:48
static const TextColour CC_DEFAULT
Default colour of the console.
Definition: console_type.h:23
bool NetworkCompanyIsPassworded(CompanyID company_id)
Check if the company we want to join requires a password.
Definition: network.cpp:213
Base core network types and some helper functions to access them.
Structure with information shown in the game list (GUI)
void NetworkUDPQueryServer(NetworkAddress address, bool manually)
Query a specific server.
Definition: network_udp.cpp:78
Class for handling the client side of the game connection.
ClientID
&#39;Unique&#39; identifier to be given to clients
Definition: network_type.h:39
static void HTTPReceive()
Do the receiving for all HTTP connections.
Definition: tcp_http.cpp:295
NetworkClientInfoPool _networkclientinfo_pool("NetworkClientInfo")
The pool with client information.
uint32 _sync_frame
The frame to perform the sync check.
Definition: network.cpp:75
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
char text[32 *MAX_CHAR_LENGTH]
possible text sent for name changes etc, in bytes including &#39;\0&#39;.
Definition: command_type.h:483
bool _network_udp_server
Is the UDP server started?
Definition: network.cpp:77
void OnConnect(SOCKET s) override
Callback when the connection succeeded.
Definition: network.cpp:571
Class for handling the server side of the game connection.
void NetworkUDPAdvertise()
Register us to the master server This function checks if it needs to send an advertise.
StringID GetNetworkErrorMsg(NetworkErrorCode err)
Retrieve the string id of an internal error number.
Definition: network.cpp:299
bool _network_available
is network mode available?
Definition: network.cpp:54
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:55
Network client pools.
Definition: pool_type.hpp:20
assert_compile(NetworkClientInfoPool::MAX_SIZE==NetworkClientSocketPool::MAX_SIZE)
Make sure both pools have the same size.
static const size_t MAX_SIZE
Make template parameter accessible from outside.
Definition: pool_type.hpp:85
std::vector< NetworkAddress > NetworkAddressList
Type for a list of addresses.
Definition: address.h:18
Critical errors, the MessageBox is shown in all cases.
Definition: error.h:24
NetworkAddressList _broadcast_list
List of broadcast addresses.
Definition: network.cpp:70
void SetDParamStr(uint n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition: strings.cpp:279
void StateGameLoop()
State controlling game loop.
Definition: openttd.cpp:1328
NetworkSettings network
settings related to the network
static const int MAX_CHAR_LENGTH
Max. length of UTF-8 encoded unicode character.
Definition: strings_type.h:18
bool _is_network_server
Does this client wants to be a network-server?
Definition: network.cpp:56
CompanyID client_playas
As which company is this client playing (CompanyID)
Definition: network_base.h:27
mask for all command flags
Definition: command_type.h:379
DateFract _date_fract
Fractional part of the day.
Definition: date.cpp:28
NetworkAddress client_address
IP-address of the client (so he can be banned)
A normal unpaused game.
Definition: openttd.h:56
The client is spectating.
Definition: company_type.h:35
static uint NetworkCountActiveClients()
Counts the number of active clients connected.
Definition: network.cpp:402
char client_name[NETWORK_CLIENT_NAME_LENGTH]
Name of the client.
Definition: network_base.h:25
Chatbox; Window numbers:
Definition: window_type.h:491
Server part of the network protocol.
bool _network_need_advertise
Whether we need to advertise.
Definition: network.cpp:61
static ServerNetworkGameSocketHandler * GetByClientID(ClientID client_id)
Return the client state given it&#39;s client-identifier.
Definition: network.cpp:133
uint32 p1
parameter p1.
Definition: command_type.h:479
static void CheckCallbacks()
Check whether we need to call the callback, i.e.
Definition: tcp_connect.cpp:65
Non blocking connection create to query servers.
Definition: network.cpp:562
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:79
ClientID _network_own_client_id
Our client identifier.
Definition: network.cpp:59
FILE * FioFOpenFile(const char *filename, const char *mode, Subdirectory subdir, size_t *filesize)
Opens a OpenTTD file somewhere in a personal or global directory.
Definition: fileio.cpp:463
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
void NetworkCoreShutdown()
Shuts down the network core (as that is needed for some platforms.
Definition: core.cpp:44
void NetworkServerSetCompanyPassword(CompanyID company_id, const char *password, bool already_hashed)
Set/Reset a company password on the server end.
Resolving of hostnames/IPs.
static const uint MAX_LENGTH_COMPANY_NAME_CHARS
The maximum length of a company name in characters including &#39;\0&#39;.
Definition: company_type.h:40
static void InitializeNetworkPools(bool close_admins=true)
Resets the pools used for network clients, and the admin pool if needed.
Definition: network.cpp:508
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:245
char connect_to_ip[NETWORK_HOSTNAME_LENGTH]
default for the "Add server" query
static void AcceptConnection(SOCKET s, const NetworkAddress &address)
Handle the accepting of a connection to the server.
Definition: network.cpp:494
NetworkCompanyState * _network_company_states
Statistics about some companies.
Definition: network.cpp:58
uint16 server_admin_port
port the server listens on for the admin network
const char * GetNetworkRevisionString()
Get the network version string used by this build.
Definition: network.cpp:1094
uint8 _network_reconnect
Reconnect timeout.
Definition: network.cpp:62
static void CheckPauseHelper(bool pause, PauseMode pm)
Helper function for the pause checkers.
Definition: network.cpp:390
static ClientNetworkGameSocketHandler * my_client
This is us!
Base directory for all savegames.
Definition: fileio_type.h:110
void OnConnect(SOCKET s) override
Callback when the connection succeeded.
Definition: network.cpp:654
char * stredup(const char *s, const char *last)
Create a duplicate of the given string.
Definition: string.cpp:136
const char * GetHostname()
Get the hostname; in case it wasn&#39;t given the IPv4 dotted representation is given.
Definition: address.cpp:22
byte clients_on
Current count of clients on server.
Definition: game.h:26
NetworkGameList * _network_game_list
Game list of this client.
A game normally paused.
Definition: openttd.h:57
static void CheckPauseOnJoin()
Check whether we should pause on join.
Definition: network.cpp:444
Part of the network protocol handling content distribution.
void NetworkShutDown()
This shuts the network down.
Definition: network.cpp:1072
bool DoCommandP(const CommandContainer *container, bool my_cmd)
Shortcut for the long DoCommandP when having a container with the data.
Definition: command.cpp:536
CompanyID company
company that is executing the command
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:40
NetworkServerGameInfo _network_game_info
Information about our game.
Definition: network.cpp:57
PauseMode _pause_mode
The current pause mode.
Definition: gfx.cpp:47
static const uint NETWORK_HOSTNAME_LENGTH
The maximum length of the host name, in bytes including &#39;\0&#39;.
Definition: config.h:42
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
Text is written left-to-right by default.
Definition: strings_type.h:23
PauseMode
Modes of pausing we&#39;ve got.
Definition: openttd.h:55
bool Listen()
Start listening on the given host and port.
Definition: udp.cpp:43
void NetworkClient_Connected()
Is called after a client is connected to the server.
static bool NetworkHasJoiningClient()
Checks whether there is a joining client.
Definition: network.cpp:432
void OnFailure() override
Callback for when the connection attempt failed.
Definition: network.cpp:649
Base class for all pools.
Definition: pool_type.hpp:81
The connection is &#39;just&#39; lost.
Definition: core.h:27
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:35
void NetworkUDPInitialize()
Initialize the whole UDP bit.
Network status window; Window numbers:
Definition: window_type.h:485
void NetworkFreeLocalCommandQueue()
Free the local command queues.
StringList _network_host_list
The servers we know.
Definition: network.cpp:64
uint16 server_port
port the server listens on
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don&#39;t get linker errors.
Definition: pool_func.hpp:224
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
uint16 network_chat_timeout
timeout of chat messages in seconds
static NetworkRecvStatus SendCompanyInformationQuery()
Query the server for company information.
bool HasClients()
Return whether there is any client connected or trying to connect at all.
Definition: network.cpp:100
bool pause_on_join
pause the game when people join
SOCKET Connect()
Connect to the given address.
Definition: address.cpp:320
Network join status.
Definition: window_type.h:32
byte _network_clients_connected
The amount of clients connected.
Definition: network.cpp:91
static const uint16 NETWORK_DEFAULT_PORT
The default port of the game server (TCP & UDP)
Definition: config.h:29
char client_name[NETWORK_CLIENT_NAME_LENGTH]
name of the player (as client)
GUISettings gui
settings related to the GUI
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:378
uint32 _frame_counter
The current frame.
Definition: network.cpp:68
Non blocking connection create to actually connect to servers.
Definition: network.cpp:645
static bool StrEmpty(const char *s)
Check if a string buffer is empty.
Definition: string_func.h:57
void IConsoleCmdExec(const char *cmdstr, const uint recurse_count)
Execute a given command passed to us.
Definition: console.cpp:407
Randomizer _random
Random used in the game state calculations.
Definition: random_func.cpp:25
Handling of the list of games.
No pool is selected.
Definition: pool_type.hpp:18
char network_id[NETWORK_SERVER_ID_LENGTH]
network ID for servers
First company, same as owner.
Definition: company_type.h:22
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:48
CompanyID _network_join_as
Who would we like to join as.
CompanyMask _network_company_passworded
Bitmask of the password status of all companies.
Definition: network.cpp:80
void NetworkClientSetCompanyPassword(const char *password)
Set/Reset company password on the client side.
void NetworkBackgroundUDPLoop()
Receive the UDP packets.
uint8 frame_freq
how often do we send commands to the clients
std::vector< std::string > StringList
Type for a list of strings.
Definition: string_type.h:58
static const uint NETWORK_COMPANY_NAME_LENGTH
The maximum length of the company name, in bytes including &#39;\0&#39;.
Definition: config.h:41
NetworkClientInfo(ClientID client_id=INVALID_CLIENT_ID)
Create a new client.
Definition: network_base.h:34
void NetworkClose(bool close_admins)
Close current connections.
Definition: network.cpp:517
uint32 _frame_counter_server
The frame_counter of the server, if in network-mode.
Definition: network.cpp:66
static const WChar CHAR_TD_RLM
The next character acts like a right-to-left character.
Definition: string_type.h:40
static const uint NETWORK_SERVER_ID_LENGTH
The maximum length of the network id of the servers, in bytes including &#39;\0&#39;.
Definition: config.h:43
Class for handling the server side of the game connection.
Definition: network_admin.h:25
char * strecpy(char *dst, const char *src, const char *last)
Copies characters from one buffer to another.
Definition: depend.cpp:66
Maximum number of companies.
Definition: company_type.h:23
StringList _network_ban_list
The banned clients.
Definition: network.cpp:65
void CDECL NetworkAddChatMessage(TextColour colour, uint duration, const char *message,...)
Add a text message to the &#39;chat window&#39; to be shown.
SwitchMode _switch_mode
The next mainloop command.
Definition: gfx.cpp:46
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
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
char admin_password[NETWORK_PASSWORD_LENGTH]
password for the admin network
bool _network_server
network-server is active
Definition: network.cpp:53
static NetworkRecvStatus SendQuit()
Tell the server we would like to quit.
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:45
void NetworkUDPRemoveAdvertise(bool blocking)
Remove our advertise from the master-server.
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:318
void NetworkBackgroundLoop()
We have to do some (simple) background stuff that runs normally, even when we are not in multiplayer...
Definition: network.cpp:837
TileIndex tile
tile command being executed on.
Definition: command_type.h:478
uint32 _last_sync_frame
Used in the server to store the last time a sync packet was sent to clients.
Definition: network.cpp:69
uint16 GetPort() const
Get the port.
Definition: address.cpp:35
void NetworkDisconnect(bool blocking, bool close_admins)
We want to disconnect from the host/clients.
Definition: network.cpp:781
Everything we need to know about a command to be able to execute it.
static void Send()
Send the packets of this socket handler.
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
size_t Utf8Encode(char *buf, WChar c)
Encode a unicode character and place it in the buffer.
Definition: string.cpp:486
int32 Date
The type to store our dates in.
Definition: date_type.h:14
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: depend.cpp:129
char last_host[NETWORK_HOSTNAME_LENGTH]
IP address of the last joined server.
static const uint NETWORK_NAME_LENGTH
The maximum length of the server name and map name, in bytes including &#39;\0&#39;.
Definition: config.h:40
uint8 _network_advertise_retries
The number of advertisement retries we did.
Definition: network.cpp:79
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Servers always have this ID.
Definition: network_type.h:41
A game paused by a game script.
Definition: openttd.h:62
Some state information of a company, especially for servers.
Definition: network_type.h:64
StringList _network_bind_list
The addresses to bind on.
Definition: network.cpp:63
static const uint NETWORK_NUM_LANDSCAPES
The number of landscapes in OpenTTD.
Definition: config.h:70
NetworkUDPSocketHandler * _udp_master_socket
udp master socket
Definition: network_udp.cpp:48
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it&#39;s client-identifier.
Definition: network.cpp:119
uint32 state[2]
The state of the randomizer.
Definition: random_func.hpp:23
Network admin pool.
Definition: pool_type.hpp:21
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:418
const char * NetworkChangeCompanyPassword(CompanyID company_id, const char *password)
Change the company password of a given company.
Definition: network.cpp:162
static const uint NETWORK_REVISION_LENGTH
The maximum length of the revision, in bytes including &#39;\0&#39;.
Definition: config.h:44
NetworkUDPSocketHandler * _udp_server_socket
udp server socket
Definition: network_udp.cpp:47
void NetworkUDPClose()
Close all UDP related stuff.
Date _date
Current date in days (day counter)
Definition: date.cpp:27
static Pool::IterateWrapperFiltered< ServerNetworkAdminSocketHandler, ServerNetworkAdminSocketHandlerFilter > IterateActive(size_t from=0)
Returns an iterable ensemble of all active admin sockets.
Definition: network_admin.h:95
A game paused for &#39;pause_on_join&#39;.
Definition: openttd.h:59
void NetworkDistributeCommands()
Distribute the commands of ourself and the clients.
uint32 _frame_counter_max
To where we may go with our clients.
Definition: network.cpp:67
static bool GameLoop()
Actual game loop for the client.
bool _network_first_time
Whether we have finished joining or not.
Definition: network.cpp:76
static void Send()
Send the packets for the server sockets.
uint32 cmd
command being executed.
Definition: command_type.h:481
Basic functions to receive and send UDP packets.
A game paused because a (critical) error.
Definition: openttd.h:60
NetworkAction
Actions that can be used for NetworkTextMessage.
Definition: network_type.h:85
static const uint GITHASH_SUFFIX_LEN
How many hex digits of the git hash to include in network revision string.
Definition: network.cpp:1088
ClientNetworkContentSocketHandler _network_content_client
The client we use to connect to the server.
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:3319
Server part of the admin network protocol.
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
uint8 min_active_clients
minimum amount of active clients to unpause the game
pause the game
Definition: command_type.h:255