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:
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 */