OpenTTD: src/network/network.cpp Source File

OpenTTD

- Main Page
- Related Pages
- Modules
- Namespaces
- Data Structures
- Files

- File List
- Globals

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
50 assert_compile(NetworkClientInfoPool::MAX_SIZE == NetworkClientSocketPool::MAX_SIZE);
51
53 NetworkClientInfoPool _networkclientinfo_pool("NetworkClientInfo");
54 INSTANTIATE_POOL_METHODS(NetworkClientInfo)
55
56 bool _networking;
57 bool _network_server;
58 bool _network_available;
59 bool _network_dedicated;
60 bool _is_network_server;
61 NetworkServerGameInfo _network_game_info;
62 NetworkCompanyState *_network_company_states = NULL;
63 ClientID _network_own_client_id;
64 ClientID _redirect_console_to_client;
65 bool _network_need_advertise;
66 uint8 _network_reconnect;
67 StringList _network_bind_list;
68 StringList _network_host_list;
69 StringList _network_ban_list;
70 uint32 _frame_counter_server;
71 uint32 _frame_counter_max;
72 uint32 _frame_counter;
73 uint32 _last_sync_frame;
74 NetworkAddressList _broadcast_list;
75 uint32 _sync_seed_1;
76 #ifdef NETWORK_SEND_DOUBLE_SEED
77 uint32 _sync_seed_2;
78 #endif
79 uint32 _sync_frame;
80 bool _network_first_time;
81 bool _network_udp_server;
82 uint16 _network_udp_broadcast;
83 uint8 _network_advertise_retries;
84 CompanyMask _network_company_passworded;
85
86 /* Check whether NETWORK_NUM_LANDSCAPES is still in sync with NUM_LANDSCAPE */
87 assert_compile((int)NETWORK_NUM_LANDSCAPES == (int)NUM_LANDSCAPE);
88 assert_compile((int)NETWORK_COMPANY_NAME_LENGTH == MAX_LENGTH_COMPANY_NAME_CHARS * MAX_CHAR_LENGTH);
89
90 extern NetworkUDPSocketHandler *_udp_client_socket;
91 extern NetworkUDPSocketHandler *_udp_server_socket;
92 extern NetworkUDPSocketHandler *_udp_master_socket;
93
95 byte _network_clients_connected = 0;
96
97 /* Some externs / forwards */
98 extern void StateGameLoop();
99
104 bool HasClients()
105 {
106 NetworkClientSocket *cs;
107 FOR_ALL_CLIENT_SOCKETS(cs) return true;
108
109 return false;
110 }
111
115 NetworkClientInfo::~NetworkClientInfo()
116 {
117 /* Delete the chat window, if you were chatting with this client. */
118 InvalidateWindowData(WC_SEND_NETWORK_MSG, DESTTYPE_CLIENT, this->client_id);
119 }
120
126 /* static */ NetworkClientInfo *NetworkClientInfo::GetByClientID(ClientID client_id)
127 {
128 NetworkClientInfo *ci;
129
130 FOR_ALL_CLIENT_INFOS(ci) {
131 if (ci->client_id == client_id) return ci;
132 }
133
134 return NULL;
135 }
136
142 /* static */ ServerNetworkGameSocketHandler *ServerNetworkGameSocketHandler::GetByClientID(ClientID client_id)
143 {
144 NetworkClientSocket *cs;
145
146 FOR_ALL_CLIENT_SOCKETS(cs) {
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
158 FOR_ALL_CLIENT_INFOS(ci) {
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 {
181 NetworkClientSetCompanyPassword(password);
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
225 bool NetworkCompanyIsPassworded(CompanyID company_id)
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);
280 NetworkAddChatMessage((TextColour)colour, _settings_client.gui.network_chat_timeout, "%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 {
301 _switch_mode = SM_MENU;
302 ShowErrorMessage(error_string, INVALID_STRING_ID, WL_CRITICAL);
303 }
304
310 StringID GetNetworkErrorMsg(NetworkErrorCode err)
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:
355 case PM_PAUSED_GAME_SCRIPT:
356 case PM_PAUSED_ACTIVE_CLIENTS: {
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
413 static uint NetworkCountActiveClients()
414 {
415 const NetworkClientSocket *cs;
416 uint count = 0;
417
418 FOR_ALL_CLIENT_SOCKETS(cs) {
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
430 static void CheckMinActiveClients()
431 {
432 if ((_pause_mode & PM_PAUSED_ERROR) != PM_UNPAUSED ||
433 !_network_dedicated ||
434 (_settings_client.network.min_active_clients == 0 && (_pause_mode & PM_PAUSED_ACTIVE_CLIENTS) == PM_UNPAUSED)) {
435 return;
436 }
437 CheckPauseHelper(NetworkCountActiveClients() < _settings_client.network.min_active_clients, PM_PAUSED_ACTIVE_CLIENTS);
438 }
439
444 static bool NetworkHasJoiningClient()
445 {
446 const NetworkClientSocket *cs;
447 FOR_ALL_CLIENT_SOCKETS(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 {
459 if ((_pause_mode & PM_PAUSED_ERROR) != PM_UNPAUSED ||
460 (!_settings_client.network.pause_on_join && (_pause_mode & PM_PAUSED_JOIN) == PM_UNPAUSED)) {
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
512 SetWindowDirty(WC_CLIENT_LIST, 0);
513 ServerNetworkGameSocketHandler *cs = new ServerNetworkGameSocketHandler(s);
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) {
534 ServerNetworkAdminSocketHandler *as;
535 FOR_ALL_ADMIN_SOCKETS(as) {
536 as->CloseConnection(true);
537 }
538 }
539
540 NetworkClientSocket *cs;
541 FOR_ALL_CLIENT_SOCKETS(cs) {
542 cs->CloseConnection(NETWORK_RECV_STATUS_CONN_LOST);
543 }
544 ServerNetworkGameSocketHandler::CloseListeners();
545 ServerNetworkAdminSocketHandler::CloseListeners();
546 } else if (MyClient::my_client != NULL) {
547 MyClient::SendQuit();
548 MyClient::my_client->CloseConnection(NETWORK_RECV_STATUS_CONN_LOST);
549 }
550
551 TCPConnecter::KillAll();
552
553 _networking = false;
554 _network_server = false;
555
556 NetworkFreeLocalCommandQueue();
557
558 free(_network_company_states);
559 _network_company_states = NULL;
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);
568 NetworkUDPInitialize();
569
570 _sync_frame = 0;
571 _network_first_time = true;
572
573 _network_reconnect = 0;
574 }
575
577 class TCPQueryConnecter : TCPConnecter {
578 public:
579 TCPQueryConnecter(const NetworkAddress &address) : TCPConnecter(address) {}
580
581 virtual void OnFailure()
582 {
583 NetworkDisconnect();
584 }
585
586 virtual void OnConnect(SOCKET s)
587 {
588 _networking = true;
589 new ClientNetworkGameSocketHandler(s);
590 MyClient::SendCompanyInformationQuery();
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
601 NetworkDisconnect();
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
620 strecpy(_settings_client.network.connect_to_ip, b, lastof(_settings_client.network.connect_to_ip));
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
660 class TCPClientConnecter : TCPConnecter {
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;
672 new ClientNetworkGameSocketHandler(s);
673 IConsoleCmdExec("exec scripts/on_client.scr 0");
674 NetworkClient_Connected();
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
686 strecpy(_settings_client.network.last_host, address.GetHostname(), lastof(_settings_client.network.last_host));
687 _settings_client.network.last_port = address.GetPort();
688 _network_join_as = join_as;
689 _network_join_server_password = join_server_password;
690 _network_join_company_password = join_company_password;
691
692 NetworkDisconnect();
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 {
703 if (StrEmpty(_settings_client.network.server_name)) {
704 seprintf(_settings_client.network.server_name, lastof(_settings_client.network.server_name), "Unnamed Server");
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. */
711 assert(NetworkClientInfo::CanAllocateItem());
712 NetworkClientInfo *ci = new NetworkClientInfo(CLIENT_ID_SERVER);
713 ci->client_playas = _network_dedicated ? COMPANY_SPECTATOR : COMPANY_FIRST;
714
715 strecpy(ci->client_name, _settings_client.network.client_name, lastof(ci->client_name));
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");
729 if (!ServerNetworkGameSocketHandler::Listen(_settings_client.network.server_port)) return false;
730
731 /* Only listen for admins when the password isn't empty. */
732 if (!StrEmpty(_settings_client.network.admin_password)) {
733 DEBUG(net, 1, "starting listeners for admins");
734 if (!ServerNetworkAdminSocketHandler::Listen(_settings_client.network.server_admin_port)) return false;
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;
762 NetworkUDPAdvertise();
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;
776 FOR_ALL_CLIENT_SOCKETS(cs) {
777 cs->SendNewGame();
778 cs->SendPackets();
779 }
780
781 ServerNetworkAdminSocketHandler *as;
782 FOR_ALL_ACTIVE_ADMIN_SOCKETS(as) {
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;
802 FOR_ALL_CLIENT_SOCKETS(cs) {
803 cs->SendShutdown();
804 cs->SendPackets();
805 }
806
807 if (close_admins) {
808 ServerNetworkAdminSocketHandler *as;
809 FOR_ALL_ACTIVE_ADMIN_SOCKETS(as) {
810 as->SendShutdown();
811 as->SendPackets();
812 }
813 }
814 }
815
816 if (_settings_client.network.server_advertise) NetworkUDPRemoveAdvertise(blocking);
817
818 DeleteWindowById(WC_NETWORK_STATUS_WINDOW, WN_NETWORK_STATUS_WINDOW_JOIN);
819
820 NetworkClose(close_admins);
821
822 /* Reinitialize the UDP stack, i.e. close all existing connections. */
823 NetworkUDPInitialize();
824 }
825
830 static bool NetworkReceive()
831 {
832 if (_network_server) {
833 ServerNetworkAdminSocketHandler::Receive();
834 return ServerNetworkGameSocketHandler::Receive();
835 } else {
836 return ClientNetworkGameSocketHandler::Receive();
837 }
838 }
839
840 /* This sends all buffered commands (if possible) */
841 static void NetworkSend()
842 {
843 if (_network_server) {
844 ServerNetworkAdminSocketHandler::Send();
845 ServerNetworkGameSocketHandler::Send();
846 } else {
847 ClientNetworkGameSocketHandler::Send();
848 }
849 }
850
856 void NetworkBackgroundLoop()
857 {
858 _network_content_client.SendReceive();
859 TCPConnecter::CheckCallbacks();
860 NetworkHTTPSocketHandler::HTTPReceive();
861
862 NetworkBackgroundUDPLoop();
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);
951 cp->company = COMPANY_SPECTATOR;
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. */
983 CheckPauseOnJoin();
984 CheckMinActiveClients();
985 NetworkDistributeCommands();
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
998 NetworkExecuteLocalCommandQueue();
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) {
1016 if (!ClientNetworkGameSocketHandler::GameLoop()) return;
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. */
1022 if (!ClientNetworkGameSocketHandler::GameLoop()) return;
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 */
1049 seprintf(_settings_client.network.network_id, lastof(_settings_client.network.network_id), "%s", hex_output);
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
1070 void NetworkStartUp()
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
1091 void NetworkShutDown()
1092 {
1093 NetworkDisconnect(true);
1094 NetworkUDPClose();
1095
1096 DEBUG(net, 3, "[core] shutting down network");
1097
1098 _network_available = false;
1099
1100 NetworkCoreShutdown();
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 */