OpenTTD
network.cpp
Go to the documentation of this file.
1 /* $Id: network.cpp 27400 2015-09-19 16:49:46Z rubidium $ */
2 
3 /*
4  * This file is part of OpenTTD.
5  * 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.
6  * 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.
7  * 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/>.
8  */
9 
12 #include "../stdafx.h"
13 
14 #ifdef ENABLE_NETWORK
15 
16 #include "../strings_func.h"
17 #include "../command_func.h"
18 #include "../date_func.h"
19 #include "network_admin.h"
20 #include "network_client.h"
21 #include "network_server.h"
22 #include "network_content.h"
23 #include "network_udp.h"
24 #include "network_gamelist.h"
25 #include "network_base.h"
26 #include "core/udp.h"
27 #include "core/host.h"
28 #include "network_gui.h"
29 #include "../console_func.h"
30 #include "../3rdparty/md5/md5.h"
31 #include "../core/random_func.hpp"
32 #include "../window_func.h"
33 #include "../company_func.h"
34 #include "../company_base.h"
35 #include "../landscape_type.h"
36 #include "../rev.h"
37 #include "../core/pool_func.hpp"
38 #include "../gfx_func.h"
39 #include "../error.h"
40 
41 #include "../safeguards.h"
42 
43 #ifdef DEBUG_DUMP_COMMANDS
44 #include "../fileio_func.h"
46 bool _ddc_fastforward = true;
47 #endif /* DEBUG_DUMP_COMMANDS */
48 
51 
55 
75 uint32 _sync_seed_1;
76 #ifdef NETWORK_SEND_DOUBLE_SEED
77 uint32 _sync_seed_2;
78 #endif
79 uint32 _sync_frame;
85 
86 /* Check whether NETWORK_NUM_LANDSCAPES is still in sync with NUM_LANDSCAPE */
87 assert_compile((int)NETWORK_NUM_LANDSCAPES == (int)NUM_LANDSCAPE);
89 
93 
96 
97 /* Some externs / forwards */
98 extern void StateGameLoop();
99 
105 {
106  NetworkClientSocket *cs;
107  FOR_ALL_CLIENT_SOCKETS(cs) return true;
108 
109  return false;
110 }
111 
116 {
117  /* Delete the chat window, if you were chatting with this client. */
119 }
120 
127 {
128  NetworkClientInfo *ci;
129 
131  if (ci->client_id == client_id) return ci;
132  }
133 
134  return NULL;
135 }
136 
143 {
144  NetworkClientSocket *cs;
145 
147  if (cs->client_id == client_id) return cs;
148  }
149 
150  return NULL;
151 }
152 
153 byte NetworkSpectatorCount()
154 {
155  const NetworkClientInfo *ci;
156  byte count = 0;
157 
159  if (ci->client_playas == COMPANY_SPECTATOR) count++;
160  }
161 
162  /* Don't count a dedicated server as spectator */
163  if (_network_dedicated) count--;
164 
165  return count;
166 }
167 
174 const char *NetworkChangeCompanyPassword(CompanyID company_id, const char *password)
175 {
176  if (strcmp(password, "*") == 0) password = "";
177 
178  if (_network_server) {
179  NetworkServerSetCompanyPassword(company_id, password, false);
180  } else {
182  }
183 
184  return password;
185 }
186 
194 const char *GenerateCompanyPasswordHash(const char *password, const char *password_server_id, uint32 password_game_seed)
195 {
196  if (StrEmpty(password)) return password;
197 
198  char salted_password[NETWORK_SERVER_ID_LENGTH];
199 
200  memset(salted_password, 0, sizeof(salted_password));
201  seprintf(salted_password, lastof(salted_password), "%s", password);
202  /* Add the game seed and the server's ID as the salt. */
203  for (uint i = 0; i < NETWORK_SERVER_ID_LENGTH - 1; i++) {
204  salted_password[i] ^= password_server_id[i] ^ (password_game_seed >> (i % 32));
205  }
206 
207  Md5 checksum;
208  uint8 digest[16];
209  static char hashed_password[NETWORK_SERVER_ID_LENGTH];
210 
211  /* Generate the MD5 hash */
212  checksum.Append(salted_password, sizeof(salted_password) - 1);
213  checksum.Finish(digest);
214 
215  for (int di = 0; di < 16; di++) seprintf(hashed_password + di * 2, lastof(hashed_password), "%02x", digest[di]);
216 
217  return hashed_password;
218 }
219 
226 {
227  return HasBit(_network_company_passworded, company_id);
228 }
229 
230 /* This puts a text-message to the console, or in the future, the chat-box,
231  * (to keep it all a bit more general)
232  * If 'self_send' is true, this is the client who is sending the message */
233 void NetworkTextMessage(NetworkAction action, TextColour colour, bool self_send, const char *name, const char *str, int64 data)
234 {
235  StringID strid;
236  switch (action) {
237  case NETWORK_ACTION_SERVER_MESSAGE:
238  /* Ignore invalid messages */
239  strid = STR_NETWORK_SERVER_MESSAGE;
240  colour = CC_DEFAULT;
241  break;
242  case NETWORK_ACTION_COMPANY_SPECTATOR:
243  colour = CC_DEFAULT;
244  strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_SPECTATE;
245  break;
246  case NETWORK_ACTION_COMPANY_JOIN:
247  colour = CC_DEFAULT;
248  strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_JOIN;
249  break;
250  case NETWORK_ACTION_COMPANY_NEW:
251  colour = CC_DEFAULT;
252  strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_NEW;
253  break;
254  case NETWORK_ACTION_JOIN:
255  /* Show the Client ID for the server but not for the client. */
256  strid = _network_server ? STR_NETWORK_MESSAGE_CLIENT_JOINED_ID : STR_NETWORK_MESSAGE_CLIENT_JOINED;
257  break;
258  case NETWORK_ACTION_LEAVE: strid = STR_NETWORK_MESSAGE_CLIENT_LEFT; break;
259  case NETWORK_ACTION_NAME_CHANGE: strid = STR_NETWORK_MESSAGE_NAME_CHANGE; break;
260  case NETWORK_ACTION_GIVE_MONEY: strid = self_send ? STR_NETWORK_MESSAGE_GAVE_MONEY_AWAY : STR_NETWORK_MESSAGE_GIVE_MONEY; break;
261  case NETWORK_ACTION_CHAT_COMPANY: strid = self_send ? STR_NETWORK_CHAT_TO_COMPANY : STR_NETWORK_CHAT_COMPANY; break;
262  case NETWORK_ACTION_CHAT_CLIENT: strid = self_send ? STR_NETWORK_CHAT_TO_CLIENT : STR_NETWORK_CHAT_CLIENT; break;
263  default: strid = STR_NETWORK_CHAT_ALL; break;
264  }
265 
266  char message[1024];
267  SetDParamStr(0, name);
268  SetDParamStr(1, str);
269  SetDParam(2, data);
270 
271  /* All of these strings start with "***". These characters are interpreted as both left-to-right and
272  * right-to-left characters depending on the context. As the next text might be an user's name, the
273  * user name's characters will influence the direction of the "***" instead of the language setting
274  * of the game. Manually set the direction of the "***" by inserting a text-direction marker. */
275  char *msg_ptr = message + Utf8Encode(message, _current_text_dir == TD_LTR ? CHAR_TD_LRM : CHAR_TD_RLM);
276  GetString(msg_ptr, strid, lastof(message));
277 
278  DEBUG(desync, 1, "msg: %08x; %02x; %s", _date, _date_fract, message);
279  IConsolePrintF(colour, "%s", message);
281 }
282 
283 /* Calculate the frame-lag of a client */
284 uint NetworkCalculateLag(const NetworkClientSocket *cs)
285 {
286  int lag = cs->last_frame_server - cs->last_frame;
287  /* This client has missed his ACK packet after 1 DAY_TICKS..
288  * so we increase his lag for every frame that passes!
289  * The packet can be out by a max of _net_frame_freq */
290  if (cs->last_frame_server + DAY_TICKS + _settings_client.network.frame_freq < _frame_counter) {
291  lag += _frame_counter - (cs->last_frame_server + DAY_TICKS + _settings_client.network.frame_freq);
292  }
293  return lag;
294 }
295 
296 
297 /* There was a non-recoverable error, drop back to the main menu with a nice
298  * error */
299 void NetworkError(StringID error_string)
300 {
303 }
304 
311 {
312  /* List of possible network errors, used by
313  * PACKET_SERVER_ERROR and PACKET_CLIENT_ERROR */
314  static const StringID network_error_strings[] = {
315  STR_NETWORK_ERROR_CLIENT_GENERAL,
316  STR_NETWORK_ERROR_CLIENT_DESYNC,
317  STR_NETWORK_ERROR_CLIENT_SAVEGAME,
318  STR_NETWORK_ERROR_CLIENT_CONNECTION_LOST,
319  STR_NETWORK_ERROR_CLIENT_PROTOCOL_ERROR,
320  STR_NETWORK_ERROR_CLIENT_NEWGRF_MISMATCH,
321  STR_NETWORK_ERROR_CLIENT_NOT_AUTHORIZED,
322  STR_NETWORK_ERROR_CLIENT_NOT_EXPECTED,
323  STR_NETWORK_ERROR_CLIENT_WRONG_REVISION,
324  STR_NETWORK_ERROR_CLIENT_NAME_IN_USE,
325  STR_NETWORK_ERROR_CLIENT_WRONG_PASSWORD,
326  STR_NETWORK_ERROR_CLIENT_COMPANY_MISMATCH,
327  STR_NETWORK_ERROR_CLIENT_KICKED,
328  STR_NETWORK_ERROR_CLIENT_CHEATER,
329  STR_NETWORK_ERROR_CLIENT_SERVER_FULL,
330  STR_NETWORK_ERROR_CLIENT_TOO_MANY_COMMANDS,
331  STR_NETWORK_ERROR_CLIENT_TIMEOUT_PASSWORD,
332  STR_NETWORK_ERROR_CLIENT_TIMEOUT_COMPUTER,
333  STR_NETWORK_ERROR_CLIENT_TIMEOUT_MAP,
334  STR_NETWORK_ERROR_CLIENT_TIMEOUT_JOIN,
335  };
336  assert_compile(lengthof(network_error_strings) == NETWORK_ERROR_END);
337 
338  if (err >= (ptrdiff_t)lengthof(network_error_strings)) err = NETWORK_ERROR_GENERAL;
339 
340  return network_error_strings[err];
341 }
342 
348 void NetworkHandlePauseChange(PauseMode prev_mode, PauseMode changed_mode)
349 {
350  if (!_networking) return;
351 
352  switch (changed_mode) {
353  case PM_PAUSED_NORMAL:
354  case PM_PAUSED_JOIN:
357  bool changed = ((_pause_mode == PM_UNPAUSED) != (prev_mode == PM_UNPAUSED));
358  bool paused = (_pause_mode != PM_UNPAUSED);
359  if (!paused && !changed) return;
360 
361  StringID str;
362  if (!changed) {
363  int i = -1;
364 
365  if ((_pause_mode & PM_PAUSED_NORMAL) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL);
366  if ((_pause_mode & PM_PAUSED_JOIN) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS);
367  if ((_pause_mode & PM_PAUSED_GAME_SCRIPT) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_GAME_SCRIPT);
368  if ((_pause_mode & PM_PAUSED_ACTIVE_CLIENTS) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS);
369  str = STR_NETWORK_SERVER_MESSAGE_GAME_STILL_PAUSED_1 + i;
370  } else {
371  switch (changed_mode) {
372  case PM_PAUSED_NORMAL: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL); break;
373  case PM_PAUSED_JOIN: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS); break;
374  case PM_PAUSED_GAME_SCRIPT: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_GAME_SCRIPT); break;
375  case PM_PAUSED_ACTIVE_CLIENTS: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS); break;
376  default: NOT_REACHED();
377  }
378  str = paused ? STR_NETWORK_SERVER_MESSAGE_GAME_PAUSED : STR_NETWORK_SERVER_MESSAGE_GAME_UNPAUSED;
379  }
380 
381  char buffer[DRAW_STRING_BUFFER];
382  GetString(buffer, str, lastof(buffer));
383  NetworkTextMessage(NETWORK_ACTION_SERVER_MESSAGE, CC_DEFAULT, false, NULL, buffer);
384  break;
385  }
386 
387  default:
388  return;
389  }
390 }
391 
392 
401 static void CheckPauseHelper(bool pause, PauseMode pm)
402 {
403  if (pause == ((_pause_mode & pm) != PM_UNPAUSED)) return;
404 
405  DoCommandP(0, pm, pause ? 1 : 0, CMD_PAUSE);
406 }
407 
414 {
415  const NetworkClientSocket *cs;
416  uint count = 0;
417 
419  if (cs->status != NetworkClientSocket::STATUS_ACTIVE) continue;
420  if (!Company::IsValidID(cs->GetInfo()->client_playas)) continue;
421  count++;
422  }
423 
424  return count;
425 }
426 
431 {
433  !_network_dedicated ||
435  return;
436  }
438 }
439 
445 {
446  const NetworkClientSocket *cs;
448  if (cs->status >= NetworkClientSocket::STATUS_AUTHORIZED && cs->status < NetworkClientSocket::STATUS_ACTIVE) return true;
449  }
450 
451  return false;
452 }
453 
457 static void CheckPauseOnJoin()
458 {
461  return;
462  }
463  CheckPauseHelper(NetworkHasJoiningClient(), PM_PAUSED_JOIN);
464 }
465 
474 void ParseConnectionString(const char **company, const char **port, char *connection_string)
475 {
476  bool ipv6 = (strchr(connection_string, ':') != strrchr(connection_string, ':'));
477  char *p;
478  for (p = connection_string; *p != '\0'; p++) {
479  switch (*p) {
480  case '[':
481  ipv6 = true;
482  break;
483 
484  case ']':
485  ipv6 = false;
486  break;
487 
488  case '#':
489  *company = p + 1;
490  *p = '\0';
491  break;
492 
493  case ':':
494  if (ipv6) break;
495  *port = p + 1;
496  *p = '\0';
497  break;
498  }
499  }
500 }
501 
507 /* static */ void ServerNetworkGameSocketHandler::AcceptConnection(SOCKET s, const NetworkAddress &address)
508 {
509  /* Register the login */
510  _network_clients_connected++;
511 
514  cs->client_address = address; // Save the IP of the client
515 }
516 
521 static void InitializeNetworkPools(bool close_admins = true)
522 {
523  PoolBase::Clean(PT_NCLIENT | (close_admins ? PT_NADMIN : PT_NONE));
524 }
525 
530 void NetworkClose(bool close_admins)
531 {
532  if (_network_server) {
533  if (close_admins) {
536  as->CloseConnection(true);
537  }
538  }
539 
540  NetworkClientSocket *cs;
542  cs->CloseConnection(NETWORK_RECV_STATUS_CONN_LOST);
543  }
546  } else if (MyClient::my_client != NULL) {
549  }
550 
552 
553  _networking = false;
554  _network_server = false;
555 
557 
560 
561  InitializeNetworkPools(close_admins);
562 }
563 
564 /* Initializes the network (cleans sockets and stuff) */
565 static void NetworkInitialize(bool close_admins = true)
566 {
567  InitializeNetworkPools(close_admins);
569 
570  _sync_frame = 0;
571  _network_first_time = true;
572 
573  _network_reconnect = 0;
574 }
575 
578 public:
579  TCPQueryConnecter(const NetworkAddress &address) : TCPConnecter(address) {}
580 
581  virtual void OnFailure()
582  {
584  }
585 
586  virtual void OnConnect(SOCKET s)
587  {
588  _networking = true;
591  }
592 };
593 
594 /* Query a server to fetch his game-info
595  * If game_info is true, only the gameinfo is fetched,
596  * else only the client_info is fetched */
597 void NetworkTCPQueryServer(NetworkAddress address)
598 {
599  if (!_network_available) return;
600 
602  NetworkInitialize();
603 
604  new TCPQueryConnecter(address);
605 }
606 
607 /* Validates an address entered as a string and adds the server to
608  * the list. If you use this function, the games will be marked
609  * as manually added. */
610 void NetworkAddServer(const char *b)
611 {
612  if (*b != '\0') {
613  const char *port = NULL;
614  const char *company = NULL;
615  char host[NETWORK_HOSTNAME_LENGTH];
616  uint16 rport;
617 
618  strecpy(host, b, lastof(host));
619 
621  rport = NETWORK_DEFAULT_PORT;
622 
623  ParseConnectionString(&company, &port, host);
624  if (port != NULL) rport = atoi(port);
625 
626  NetworkUDPQueryServer(NetworkAddress(host, rport), true);
627  }
628 }
629 
635 void GetBindAddresses(NetworkAddressList *addresses, uint16 port)
636 {
637  for (char **iter = _network_bind_list.Begin(); iter != _network_bind_list.End(); iter++) {
638  *addresses->Append() = NetworkAddress(*iter, port);
639  }
640 
641  /* No address, so bind to everything. */
642  if (addresses->Length() == 0) {
643  *addresses->Append() = NetworkAddress("", port);
644  }
645 }
646 
647 /* Generates the list of manually added hosts from NetworkGameList and
648  * dumps them into the array _network_host_list. This array is needed
649  * by the function that generates the config file. */
650 void NetworkRebuildHostList()
651 {
652  _network_host_list.Clear();
653 
654  for (NetworkGameList *item = _network_game_list; item != NULL; item = item->next) {
655  if (item->manually) *_network_host_list.Append() = stredup(item->address.GetAddressAsString(false));
656  }
657 }
658 
661 public:
662  TCPClientConnecter(const NetworkAddress &address) : TCPConnecter(address) {}
663 
664  virtual void OnFailure()
665  {
666  NetworkError(STR_NETWORK_ERROR_NOCONNECTION);
667  }
668 
669  virtual void OnConnect(SOCKET s)
670  {
671  _networking = true;
673  IConsoleCmdExec("exec scripts/on_client.scr 0");
675  }
676 };
677 
678 
679 /* Used by clients, to connect to a server */
680 void NetworkClientConnectGame(NetworkAddress address, CompanyID join_as, const char *join_server_password, const char *join_company_password)
681 {
682  if (!_network_available) return;
683 
684  if (address.GetPort() == 0) return;
685 
688  _network_join_as = join_as;
689  _network_join_server_password = join_server_password;
690  _network_join_company_password = join_company_password;
691 
693  NetworkInitialize();
694 
695  _network_join_status = NETWORK_JOIN_STATUS_CONNECTING;
696  ShowJoinStatusWindow();
697 
698  new TCPClientConnecter(address);
699 }
700 
701 static void NetworkInitGameInfo()
702 {
705  }
706 
707  /* The server is a client too */
708  _network_game_info.clients_on = _network_dedicated ? 0 : 1;
709 
710  /* There should be always space for the server. */
713  ci->client_playas = _network_dedicated ? COMPANY_SPECTATOR : COMPANY_FIRST;
714 
716 }
717 
718 bool NetworkServerStart()
719 {
720  if (!_network_available) return false;
721 
722  /* Call the pre-scripts */
723  IConsoleCmdExec("exec scripts/pre_server.scr 0");
724  if (_network_dedicated) IConsoleCmdExec("exec scripts/pre_dedicated.scr 0");
725 
726  NetworkDisconnect(false, false);
727  NetworkInitialize(false);
728  DEBUG(net, 1, "starting listeners for clients");
730 
731  /* Only listen for admins when the password isn't empty. */
733  DEBUG(net, 1, "starting listeners for admins");
735  }
736 
737  /* Try to start UDP-server */
738  DEBUG(net, 1, "starting listeners for incoming server queries");
739  _network_udp_server = _udp_server_socket->Listen();
740 
741  _network_company_states = CallocT<NetworkCompanyState>(MAX_COMPANIES);
742  _network_server = true;
743  _networking = true;
744  _frame_counter = 0;
745  _frame_counter_server = 0;
746  _frame_counter_max = 0;
747  _last_sync_frame = 0;
748  _network_own_client_id = CLIENT_ID_SERVER;
749 
750  _network_clients_connected = 0;
751  _network_company_passworded = 0;
752 
753  NetworkInitGameInfo();
754 
755  /* execute server initialization script */
756  IConsoleCmdExec("exec scripts/on_server.scr 0");
757  /* if the server is dedicated ... add some other script */
758  if (_network_dedicated) IConsoleCmdExec("exec scripts/on_dedicated.scr 0");
759 
760  /* Try to register us to the master server */
761  _network_need_advertise = true;
763 
764  /* welcome possibly still connected admins - this can only happen on a dedicated server. */
765  if (_network_dedicated) ServerNetworkAdminSocketHandler::WelcomeAll();
766 
767  return true;
768 }
769 
770 /* The server is rebooting...
771  * The only difference with NetworkDisconnect, is the packets that is sent */
772 void NetworkReboot()
773 {
774  if (_network_server) {
775  NetworkClientSocket *cs;
777  cs->SendNewGame();
778  cs->SendPackets();
779  }
780 
783  as->SendNewGame();
784  as->SendPackets();
785  }
786  }
787 
788  /* For non-dedicated servers we have to kick the admins as we are not
789  * certain that we will end up in a new network game. */
790  NetworkClose(!_network_dedicated);
791 }
792 
798 void NetworkDisconnect(bool blocking, bool close_admins)
799 {
800  if (_network_server) {
801  NetworkClientSocket *cs;
803  cs->SendShutdown();
804  cs->SendPackets();
805  }
806 
807  if (close_admins) {
810  as->SendShutdown();
811  as->SendPackets();
812  }
813  }
814  }
815 
817 
819 
820  NetworkClose(close_admins);
821 
822  /* Reinitialize the UDP stack, i.e. close all existing connections. */
824 }
825 
830 static bool NetworkReceive()
831 {
832  if (_network_server) {
835  } else {
837  }
838 }
839 
840 /* This sends all buffered commands (if possible) */
841 static void NetworkSend()
842 {
843  if (_network_server) {
846  } else {
848  }
849 }
850 
857 {
861 
863 }
864 
865 /* The main loop called from ttd.c
866  * Here we also have to do StateGameLoop if needed! */
867 void NetworkGameLoop()
868 {
869  if (!_networking) return;
870 
871  if (!NetworkReceive()) return;
872 
873  if (_network_server) {
874  /* Log the sync state to check for in-syncedness of replays. */
875  if (_date_fract == 0) {
876  /* We don't want to log multiple times if paused. */
877  static Date last_log;
878  if (last_log != _date) {
879  DEBUG(desync, 1, "sync: %08x; %02x; %08x; %08x", _date, _date_fract, _random.state[0], _random.state[1]);
880  last_log = _date;
881  }
882  }
883 
884 #ifdef DEBUG_DUMP_COMMANDS
885  /* Loading of the debug commands from -ddesync>=1 */
886  static FILE *f = FioFOpenFile("commands.log", "rb", SAVE_DIR);
887  static Date next_date = 0;
888  static uint32 next_date_fract;
889  static CommandPacket *cp = NULL;
890  static bool check_sync_state = false;
891  static uint32 sync_state[2];
892  if (f == NULL && next_date == 0) {
893  DEBUG(net, 0, "Cannot open commands.log");
894  next_date = 1;
895  }
896 
897  while (f != NULL && !feof(f)) {
898  if (_date == next_date && _date_fract == next_date_fract) {
899  if (cp != NULL) {
900  NetworkSendCommand(cp->tile, cp->p1, cp->p2, cp->cmd & ~CMD_FLAGS_MASK, NULL, cp->text, cp->company);
901  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));
902  free(cp);
903  cp = NULL;
904  }
905  if (check_sync_state) {
906  if (sync_state[0] == _random.state[0] && sync_state[1] == _random.state[1]) {
907  DEBUG(net, 0, "sync check: %08x; %02x; match", _date, _date_fract);
908  } else {
909  DEBUG(net, 0, "sync check: %08x; %02x; mismatch expected {%08x, %08x}, got {%08x, %08x}",
910  _date, _date_fract, sync_state[0], sync_state[1], _random.state[0], _random.state[1]);
911  NOT_REACHED();
912  }
913  check_sync_state = false;
914  }
915  }
916 
917  if (cp != NULL || check_sync_state) break;
918 
919  char buff[4096];
920  if (fgets(buff, lengthof(buff), f) == NULL) break;
921 
922  char *p = buff;
923  /* Ignore the "[date time] " part of the message */
924  if (*p == '[') {
925  p = strchr(p, ']');
926  if (p == NULL) break;
927  p += 2;
928  }
929 
930  if (strncmp(p, "cmd: ", 5) == 0
931 #ifdef DEBUG_FAILED_DUMP_COMMANDS
932  || strncmp(p, "cmdf: ", 6) == 0
933 #endif
934  ) {
935  p += 5;
936  if (*p == ' ') p++;
937  cp = CallocT<CommandPacket>(1);
938  int company;
939  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);
940  /* There are 8 pieces of data to read, however the last is a
941  * string that might or might not exist. Ignore it if that
942  * string misses because in 99% of the time it's not used. */
943  assert(ret == 8 || ret == 7);
944  cp->company = (CompanyID)company;
945  } else if (strncmp(p, "join: ", 6) == 0) {
946  /* Manually insert a pause when joining; this way the client can join at the exact right time. */
947  int ret = sscanf(p + 6, "%x; %x", &next_date, &next_date_fract);
948  assert(ret == 2);
949  DEBUG(net, 0, "injecting pause for join at %08x:%02x; please join when paused", next_date, next_date_fract);
950  cp = CallocT<CommandPacket>(1);
952  cp->cmd = CMD_PAUSE;
953  cp->p1 = PM_PAUSED_NORMAL;
954  cp->p2 = 1;
955  _ddc_fastforward = false;
956  } else if (strncmp(p, "sync: ", 6) == 0) {
957  int ret = sscanf(p + 6, "%x; %x; %x; %x", &next_date, &next_date_fract, &sync_state[0], &sync_state[1]);
958  assert(ret == 4);
959  check_sync_state = true;
960  } else if (strncmp(p, "msg: ", 5) == 0 || strncmp(p, "client: ", 8) == 0 ||
961  strncmp(p, "load: ", 6) == 0 || strncmp(p, "save: ", 6) == 0) {
962  /* A message that is not very important to the log playback, but part of the log. */
963 #ifndef DEBUG_FAILED_DUMP_COMMANDS
964  } else if (strncmp(p, "cmdf: ", 6) == 0) {
965  DEBUG(net, 0, "Skipping replay of failed command: %s", p + 6);
966 #endif
967  } else {
968  /* Can't parse a line; what's wrong here? */
969  DEBUG(net, 0, "trying to parse: %s", p);
970  NOT_REACHED();
971  }
972  }
973  if (f != NULL && feof(f)) {
974  DEBUG(net, 0, "End of commands.log");
975  fclose(f);
976  f = NULL;
977  }
978 #endif /* DEBUG_DUMP_COMMANDS */
979  if (_frame_counter >= _frame_counter_max) {
980  /* Only check for active clients just before we're going to send out
981  * the commands so we don't send multiple pause/unpause commands when
982  * the frame_freq is more than 1 tick. Same with distributing commands. */
986  }
987 
988  bool send_frame = false;
989 
990  /* We first increase the _frame_counter */
991  _frame_counter++;
992  /* Update max-frame-counter */
993  if (_frame_counter > _frame_counter_max) {
994  _frame_counter_max = _frame_counter + _settings_client.network.frame_freq;
995  send_frame = true;
996  }
997 
999 
1000  /* Then we make the frame */
1001  StateGameLoop();
1002 
1003  _sync_seed_1 = _random.state[0];
1004 #ifdef NETWORK_SEND_DOUBLE_SEED
1005  _sync_seed_2 = _random.state[1];
1006 #endif
1007 
1008  NetworkServer_Tick(send_frame);
1009  } else {
1010  /* Client */
1011 
1012  /* Make sure we are at the frame were the server is (quick-frames) */
1013  if (_frame_counter_server > _frame_counter) {
1014  /* Run a number of frames; when things go bad, get out. */
1015  while (_frame_counter_server > _frame_counter) {
1017  }
1018  } else {
1019  /* Else, keep on going till _frame_counter_max */
1020  if (_frame_counter_max > _frame_counter) {
1021  /* Run one frame; if things went bad, get out. */
1023  }
1024  }
1025  }
1026 
1027  NetworkSend();
1028 }
1029 
1030 static void NetworkGenerateServerId()
1031 {
1032  Md5 checksum;
1033  uint8 digest[16];
1034  char hex_output[16 * 2 + 1];
1035  char coding_string[NETWORK_NAME_LENGTH];
1036  int di;
1037 
1038  seprintf(coding_string, lastof(coding_string), "%d%s", (uint)Random(), "OpenTTD Server ID");
1039 
1040  /* Generate the MD5 hash */
1041  checksum.Append((const uint8*)coding_string, strlen(coding_string));
1042  checksum.Finish(digest);
1043 
1044  for (di = 0; di < 16; ++di) {
1045  seprintf(hex_output + di * 2, lastof(hex_output), "%02x", digest[di]);
1046  }
1047 
1048  /* _settings_client.network.network_id is our id */
1050 }
1051 
1052 void NetworkStartDebugLog(NetworkAddress address)
1053 {
1054  extern SOCKET _debug_socket; // Comes from debug.c
1055 
1056  DEBUG(net, 0, "Redirecting DEBUG() to %s:%d", address.GetHostname(), address.GetPort());
1057 
1058  SOCKET s = address.Connect();
1059  if (s == INVALID_SOCKET) {
1060  DEBUG(net, 0, "Failed to open socket for redirection DEBUG()");
1061  return;
1062  }
1063 
1064  _debug_socket = s;
1065 
1066  DEBUG(net, 0, "DEBUG() is now redirected");
1067 }
1068 
1071 {
1072  DEBUG(net, 3, "[core] starting network...");
1073 
1074  /* Network is available */
1075  _network_available = NetworkCoreInitialize();
1076  _network_dedicated = false;
1077  _network_need_advertise = true;
1078  _network_advertise_retries = 0;
1079 
1080  /* Generate an server id when there is none yet */
1081  if (StrEmpty(_settings_client.network.network_id)) NetworkGenerateServerId();
1082 
1083  memset(&_network_game_info, 0, sizeof(_network_game_info));
1084 
1085  NetworkInitialize();
1086  DEBUG(net, 3, "[core] network online, multiplayer available");
1087  NetworkFindBroadcastIPs(&_broadcast_list);
1088 }
1089 
1092 {
1093  NetworkDisconnect(true);
1094  NetworkUDPClose();
1095 
1096  DEBUG(net, 3, "[core] shutting down network");
1097 
1098  _network_available = false;
1099 
1101 }
1102 
1107 bool IsNetworkCompatibleVersion(const char *other)
1108 {
1109  return strncmp(_openttd_revision, other, NETWORK_REVISION_LENGTH - 1) == 0;
1110 }
1111 
1112 #endif /* ENABLE_NETWORK */
void NetworkServer_Tick(bool send_frame)
This is called every tick if this is a _network_server.
static bool NetworkReceive()
Receives something from the network.
Definition: network.cpp:830
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:474
bool _networking
are we in networking mode?
Definition: network.cpp:56
virtual void OnFailure()
Callback for when the connection attempt failed.
Definition: network.cpp:581
A game paused for &#39;min_active_clients&#39;.
Definition: openttd.h:63
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:393
bool IsNetworkCompatibleVersion(const char *other)
Checks whether the given version string is compatible with our version.
Definition: network.cpp:1107
#define FOR_ALL_ACTIVE_ADMIN_SOCKETS(var)
Iterate over all the active sockets.
Container for all information known about a client.
Definition: network_base.h:27
uint32 _sync_seed_1
Seed to compare during sync checks.
Definition: network.cpp:75
bool server_advertise
advertise the server to the masterserver
A game normally paused.
Definition: openttd.h:59
A normal unpaused game.
Definition: openttd.h:58
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3120
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:635
static void KillAll()
Kill all connection attempts.
Definition: tcp_connect.cpp:96
uint16 last_port
port of the last joined server
Client list; Window numbers:
Definition: window_type.h:474
bool NetworkCoreInitialize()
Initializes the network core (as that is needed for some platforms.
Definition: core.cpp:33
"Helper" class for creating TCP connections in a non-blocking manner
Definition: tcp.h:66
char server_name[NETWORK_NAME_LENGTH]
name of the server
NetworkUDPSocketHandler * _udp_client_socket
udp client socket
Definition: network_udp.cpp:49
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:28
virtual void OnFailure()
Callback for when the connection attempt failed.
Definition: network.cpp:664
Switch to game intro menu.
Definition: openttd.h:32
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:115
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:398
void NetworkExecuteLocalCommandQueue()
Execute all commands on the local command queue that ought to be executed this frame.
A game paused by a game script.
Definition: openttd.h:64
NetworkErrorCode
The error codes we send around in the protocols.
Definition: network_type.h:104
ClientID client_id
Client identifier (same as ClientState->client_id)
Definition: network_base.h:28
NetworkJoinStatus _network_join_status
The status of joining.
uint16 _network_udp_broadcast
Timeout for the UDP broadcasts.
Definition: network.cpp:82
uint32 p2
parameter p2.
Definition: command_type.h:475
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:31
const T * Begin() const
Get the pointer to the first item (const)
ClientID _redirect_console_to_client
If not invalid, redirect the console output to a client.
Definition: network.cpp:64
static void Clean(PoolType)
Clean all pools of given type.
Definition: pool_func.cpp:32
void NetworkStartUp()
This tries to launch the network for a given OS.
Definition: network.cpp:1070
static const int DAY_TICKS
1 day is 74 ticks; _date_fract used to be uint16 and incremented by 885.
Definition: date_type.h:30
static const int DRAW_STRING_BUFFER
Size of the buffer used for drawing strings.
Definition: gfx_func.h:87
void NetworkFindBroadcastIPs(NetworkAddressList *broadcast)
Find the IPv4 broadcast addresses; IPv6 uses a completely different strategy for broadcasting.
Definition: host.cpp:203
Send message/notice to only a certain client (Private)
Definition: network_type.h:85
Base socket handler for all UDP sockets.
Definition: udp.h:50
#define lastof(x)
Get the last element of an fixed size array.
Definition: depend.cpp:50
The client is spectating.
Definition: company_type.h:37
static const TextColour CC_DEFAULT
Default colour of the console.
Definition: console_type.h:25
bool NetworkCompanyIsPassworded(CompanyID company_id)
Check if the company we want to join requires a password.
Definition: network.cpp:225
A game paused for &#39;pause_on_join&#39;.
Definition: openttd.h:61
A game paused because a (critical) error.
Definition: openttd.h:62
Base core network types and some helper functions to access them.
Structure with information shown in the game list (GUI)
Class for handling the client side of the game connection.
static void HTTPReceive()
Do the receiving for all HTTP connections.
Definition: tcp_http.cpp:299
NetworkClientInfoPool _networkclientinfo_pool("NetworkClientInfo")
The pool with client information.
uint32 _sync_frame
The frame to perform the sync check.
Definition: network.cpp:79
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:348
char text[32 *MAX_CHAR_LENGTH]
possible text sent for name changes etc, in bytes including &#39;\0&#39;.
Definition: command_type.h:478
const T * End() const
Get the pointer behind the last valid item (const)
SendPacketsState SendPackets(bool closing_down=false)
Sends all the buffered packets out for this client.
Definition: tcp.cpp:99
bool _network_udp_server
Is the UDP server started?
Definition: network.cpp:81
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:310
Servers always have this ID.
Definition: network_type.h:45
bool _network_available
is network mode available?
Definition: network.cpp:58
T * Append(uint to_add=1)
Append an item and return it.
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:59
Network client pools.
Definition: pool_type.hpp:22
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:87
Critical errors, the MessageBox is shown in all cases.
Definition: error.h:26
void ShowErrorMessage(StringID summary_msg, StringID detailed_msg, WarningLevel wl, int x=0, int y=0, const GRFFile *textref_stack_grffile=NULL, uint textref_stack_size=0, const uint32 *textref_stack=NULL)
Display an error message in a window.
Definition: error_gui.cpp:378
NetworkAddressList _broadcast_list
List of broadcast addresses.
Definition: network.cpp:74
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:1341
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:20
bool _is_network_server
Does this client wants to be a network-server?
Definition: network.cpp:60
CompanyID client_playas
As which company is this client playing (CompanyID)
Definition: network_base.h:31
mask for all command flags
Definition: command_type.h:375
uint Length() const
Get the number of items in the list.
DateFract _date_fract
Fractional part of the day.
Definition: date.cpp:29
NetworkAddress client_address
IP-address of the client (so he can be banned)
static uint NetworkCountActiveClients()
Counts the number of active clients connected.
Definition: network.cpp:413
char client_name[NETWORK_CLIENT_NAME_LENGTH]
Name of the client.
Definition: network_base.h:29
Chatbox; Window numbers:
Definition: window_type.h:493
Server part of the network protocol.
bool _network_need_advertise
Whether we need to advertise.
Definition: network.cpp:65
static ServerNetworkGameSocketHandler * GetByClientID(ClientID client_id)
Return the client state given it&#39;s client-identifier.
Definition: network.cpp:142
uint32 p1
parameter p1.
Definition: command_type.h:474
void IConsoleCmdExec(const char *cmdstr)
Execute a given command passed to us.
Definition: console.cpp:409
static void CheckCallbacks()
Check whether we need to call the callback, i.e.
Definition: tcp_connect.cpp:69
Non blocking connection create to query servers.
Definition: network.cpp:577
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:76
ClientID _network_own_client_id
Our client identifier.
Definition: network.cpp:63
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:474
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:132
void NetworkCoreShutdown()
Shuts down the network core (as that is needed for some platforms.
Definition: core.cpp:84
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:42
static void InitializeNetworkPools(bool close_admins=true)
Resets the pools used for network clients, and the admin pool if needed.
Definition: network.cpp:521
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:247
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:507
NetworkCompanyState * _network_company_states
Statistics about some companies.
Definition: network.cpp:62
uint16 server_admin_port
port the server listens on for the admin network
NetworkRecvStatus SendNewGame()
Tell the admin we started a new game.
First company, same as owner.
Definition: company_type.h:24
uint8 _network_reconnect
Reconnect timeout.
Definition: network.cpp:66
static void CheckPauseHelper(bool pause, PauseMode pm)
Helper function for the pause checkers.
Definition: network.cpp:401
static ClientNetworkGameSocketHandler * my_client
This is us!
Base directory for all savegames.
Definition: fileio_type.h:112
char * stredup(const char *s, const char *last)
Create a duplicate of the given string.
Definition: string.cpp:126
virtual void OnConnect(SOCKET s)
Callback when the connection succeeded.
Definition: network.cpp:586
#define FOR_ALL_CLIENT_INFOS(var)
Iterate over all the clients.
Definition: network_base.h:55
const char * GetHostname()
Get the hostname; in case it wasn&#39;t given the IPv4 dotted representation is given.
Definition: address.cpp:26
byte clients_on
Current count of clients on server.
Definition: game.h:30
NetworkGameList * _network_game_list
Game list of this client.
static void CheckPauseOnJoin()
Check whether we should pause on join.
Definition: network.cpp:457
Part of the network protocol handling content distribution.
void NetworkShutDown()
This shuts the network down.
Definition: network.cpp:1091
bool DoCommandP(const CommandContainer *container, bool my_cmd)
Shortcut for the long DoCommandP when having a container with the data.
Definition: command.cpp:527
CompanyID company
company that is executing the command
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:42
NetworkServerGameInfo _network_game_info
Information about our game.
Definition: network.cpp:61
PauseModeByte _pause_mode
The current pause mode.
Definition: gfx.cpp:48
#define FOR_ALL_CLIENT_SOCKETS(var)
Iterate over all the sockets.
static const uint NETWORK_HOSTNAME_LENGTH
The maximum length of the host name, in bytes including &#39;\0&#39;.
Definition: config.h:44
NetworkRecvStatus CloseConnection(NetworkRecvStatus status)
Close the network connection due to the given status.
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:18
Text is written left-to-right by default.
Definition: strings_type.h:25
bool Listen()
Start listening on the given host and port.
Definition: udp.cpp:47
Maximum number of companies.
Definition: company_type.h:25
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:444
Base class for all pools.
Definition: pool_type.hpp:83
The connection is &#39;just&#39; lost.
Definition: core.h:31
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:39
void NetworkUDPInitialize()
Initialize the whole UDP bit.
Network status window; Window numbers:
Definition: window_type.h:487
void NetworkFreeLocalCommandQueue()
Free the local command queues.
StringList _network_host_list
The servers we know.
Definition: network.cpp:68
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:1137
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:104
bool pause_on_join
pause the game when people join
SOCKET Connect()
Connect to the given address.
Definition: address.cpp:325
Network join status.
Definition: window_type.h:34
byte _network_clients_connected
The amount of clients connected.
Definition: network.cpp:95
static const uint16 NETWORK_DEFAULT_PORT
The default port of the game server (TCP & UDP)
Definition: config.h:31
char client_name[NETWORK_CLIENT_NAME_LENGTH]
name of the player (as client)
GUISettings gui
settings related to the GUI
uint32 _frame_counter
The current frame.
Definition: network.cpp:72
Non blocking connection create to actually connect to servers.
Definition: network.cpp:660
static bool StrEmpty(const char *s)
Check if a string buffer is empty.
Definition: string_func.h:59
CompanyByte _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
Randomizer _random
Random used in the game state calculations.
Definition: random_func.cpp:27
Handling of the list of games.
No pool is selected.
Definition: pool_type.hpp:20
char network_id[NETWORK_SERVER_ID_LENGTH]
network ID for servers
TextDirection _current_text_dir
Text direction of the currently selected language.
Definition: strings.cpp:52
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:84
void NetworkClientSetCompanyPassword(const char *password)
Set/Reset company password on the client side.
void NetworkBackgroundUDPLoop()
Receive the UDP packets.
ClientID
&#39;Unique&#39; identifier to be given to clients
Definition: network_type.h:43
uint8 frame_freq
how often do we send commands to the clients
static const uint NETWORK_COMPANY_NAME_LENGTH
The maximum length of the company name, in bytes including &#39;\0&#39;.
Definition: config.h:43
NetworkClientInfo(ClientID client_id=INVALID_CLIENT_ID)
Create a new client.
Definition: network_base.h:38
void NetworkClose(bool close_admins)
Close current connections.
Definition: network.cpp:530
uint32 _frame_counter_server
The frame_counter of the server, if in network-mode.
Definition: network.cpp:70
static const WChar CHAR_TD_RLM
The next character acts like a right-to-left character.
Definition: string_type.h:40
PauseMode
Modes of pausing we&#39;ve got.
Definition: openttd.h:57
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:45
Class for handling the server side of the game connection.
Definition: network_admin.h:29
char * strecpy(char *dst, const char *src, const char *last)
Copies characters from one buffer to another.
Definition: depend.cpp:68
StringList _network_ban_list
The banned clients.
Definition: network.cpp:69
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:47
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:194
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function() ...
Definition: pool_type.hpp:216
char admin_password[NETWORK_PASSWORD_LENGTH]
password for the admin network
virtual void OnConnect(SOCKET s)
Callback when the connection succeeded.
Definition: network.cpp:669
static void NetworkUDPQueryServer(NetworkAddress *address, bool needs_mutex, bool manually)
Helper function doing the actual work for querying the server.
Definition: network_udp.cpp:75
bool _network_server
network-server is active
Definition: network.cpp:57
static NetworkRecvStatus SendQuit()
Tell the server we would like to quit.
void Clear()
Remove all items from the list.
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-NULL) Titem.
Definition: pool_type.hpp:235
void NetworkBackgroundLoop()
We have to do some (simple) background stuff that runs normally, even when we are not in multiplayer...
Definition: network.cpp:856
TileIndex tile
tile command being executed on.
Definition: command_type.h:473
uint32 _last_sync_frame
Used in the server to store the last time a sync packet was sent to clients.
Definition: network.cpp:73
uint16 GetPort() const
Get the port.
Definition: address.cpp:39
void NetworkDisconnect(bool blocking, bool close_admins)
We want to disconnect from the host/clients.
Definition: network.cpp:798
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:19
size_t Utf8Encode(char *buf, WChar c)
Encode a unicode character and place it in the buffer.
Definition: string.cpp:477
int32 Date
The type to store our dates in.
Definition: date_type.h:16
NetworkRecvStatus SendShutdown()
Tell the admin we&#39;re shutting down.
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: depend.cpp:114
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:42
uint8 _network_advertise_retries
The number of advertisement retries we did.
Definition: network.cpp:83
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Some state information of a company, especially for servers.
Definition: network_type.h:68
StringList _network_bind_list
The addresses to bind on.
Definition: network.cpp:67
#define FOR_ALL_ADMIN_SOCKETS(var)
Iterate over all the sockets.
static const uint NETWORK_NUM_LANDSCAPES
The number of landscapes in OpenTTD.
Definition: config.h:72
Owner
Enum for all companies/owners.
Definition: company_type.h:20
NetworkUDPSocketHandler * _udp_master_socket
udp master socket
Definition: network_udp.cpp:51
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it&#39;s client-identifier.
Definition: network.cpp:126
uint32 state[2]
The state of the randomizer.
Definition: random_func.hpp:25
Network admin pool.
Definition: pool_type.hpp:23
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:430
const char * NetworkChangeCompanyPassword(CompanyID company_id, const char *password)
Change the company password of a given company.
Definition: network.cpp:174
static const uint NETWORK_REVISION_LENGTH
The maximum length of the revision, in bytes including &#39;\0&#39;.
Definition: config.h:46
NetworkUDPSocketHandler * _udp_server_socket
udp server socket
Definition: network_udp.cpp:50
void NetworkUDPClose()
Close all UDP related stuff.
Date _date
Current date in days (day counter)
Definition: date.cpp:28
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:71
static bool GameLoop()
Actual game loop for the client.
bool _network_first_time
Whether we have finished joining or not.
Definition: network.cpp:80
static void Send()
Send the packets for the server sockets.
uint32 cmd
command being executed.
Definition: command_type.h:476
Basic functions to receive and send UDP packets.
NetworkRecvStatus CloseConnection(bool error=true)
Close the current connection; for TCP this will be mostly equivalent to Close(), but for UDP it just ...
Definition: tcp_admin.cpp:45
NetworkAction
Actions that can be used for NetworkTextMessage.
Definition: network_type.h:89
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:3220
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:201
uint8 min_active_clients
minimum amount of active clients to unpause the game
pause the game
Definition: command_type.h:255