00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "../stdafx.h"
00013
00014 #ifdef ENABLE_NETWORK
00015
00016 #include "../strings_func.h"
00017 #include "../command_func.h"
00018 #include "../date_func.h"
00019 #include "network_admin.h"
00020 #include "network_client.h"
00021 #include "network_server.h"
00022 #include "network_content.h"
00023 #include "network_udp.h"
00024 #include "network_gamelist.h"
00025 #include "network_base.h"
00026 #include "core/udp.h"
00027 #include "core/host.h"
00028 #include "network_gui.h"
00029 #include "../console_func.h"
00030 #include "../3rdparty/md5/md5.h"
00031 #include "../core/random_func.hpp"
00032 #include "../window_func.h"
00033 #include "../company_func.h"
00034 #include "../company_base.h"
00035 #include "../landscape_type.h"
00036 #include "../rev.h"
00037 #include "../core/pool_func.hpp"
00038 #include "../gfx_func.h"
00039 #include "table/strings.h"
00040
00041 #ifdef DEBUG_DUMP_COMMANDS
00042 #include "../fileio_func.h"
00044 bool _ddc_fastforward = true;
00045 #endif
00046
00047 assert_compile(NetworkClientInfoPool::MAX_SIZE == NetworkClientSocketPool::MAX_SIZE);
00048
00049 NetworkClientInfoPool _networkclientinfo_pool("NetworkClientInfo");
00050 INSTANTIATE_POOL_METHODS(NetworkClientInfo)
00051
00052 bool _networking;
00053 bool _network_server;
00054 bool _network_available;
00055 bool _network_dedicated;
00056 bool _is_network_server;
00057 NetworkServerGameInfo _network_game_info;
00058 NetworkCompanyState *_network_company_states = NULL;
00059 ClientID _network_own_client_id;
00060 ClientID _redirect_console_to_client;
00061 bool _network_need_advertise;
00062 uint32 _network_last_advertise_frame;
00063 uint8 _network_reconnect;
00064 StringList _network_bind_list;
00065 StringList _network_host_list;
00066 StringList _network_ban_list;
00067 uint32 _frame_counter_server;
00068 uint32 _frame_counter_max;
00069 uint32 _frame_counter;
00070 uint32 _last_sync_frame;
00071 NetworkAddressList _broadcast_list;
00072 uint32 _sync_seed_1;
00073 #ifdef NETWORK_SEND_DOUBLE_SEED
00074 uint32 _sync_seed_2;
00075 #endif
00076 uint32 _sync_frame;
00077 bool _network_first_time;
00078 bool _network_udp_server;
00079 uint16 _network_udp_broadcast;
00080 uint8 _network_advertise_retries;
00081 CompanyMask _network_company_passworded;
00082
00083
00084 assert_compile((int)NETWORK_NUM_LANDSCAPES == (int)NUM_LANDSCAPE);
00085 assert_compile((int)NETWORK_COMPANY_NAME_LENGTH == MAX_LENGTH_COMPANY_NAME_CHARS * MAX_CHAR_LENGTH);
00086
00087 extern NetworkUDPSocketHandler *_udp_client_socket;
00088 extern NetworkUDPSocketHandler *_udp_server_socket;
00089 extern NetworkUDPSocketHandler *_udp_master_socket;
00090
00091
00092 byte _network_clients_connected = 0;
00093
00094
00095 extern void StateGameLoop();
00096
00100 NetworkClientInfo::~NetworkClientInfo()
00101 {
00102
00103 InvalidateWindowData(WC_SEND_NETWORK_MSG, DESTTYPE_CLIENT, this->client_id);
00104 }
00105
00111 NetworkClientInfo *NetworkClientInfo::GetByClientID(ClientID client_id)
00112 {
00113 NetworkClientInfo *ci;
00114
00115 FOR_ALL_CLIENT_INFOS(ci) {
00116 if (ci->client_id == client_id) return ci;
00117 }
00118
00119 return NULL;
00120 }
00121
00127 NetworkClientSocket *NetworkClientSocket::GetByClientID(ClientID client_id)
00128 {
00129 NetworkClientSocket *cs;
00130
00131 FOR_ALL_CLIENT_SOCKETS(cs) {
00132 if (cs->client_id == client_id) return cs;
00133 }
00134
00135 return NULL;
00136 }
00137
00138 byte NetworkSpectatorCount()
00139 {
00140 const NetworkClientInfo *ci;
00141 byte count = 0;
00142
00143 FOR_ALL_CLIENT_INFOS(ci) {
00144 if (ci->client_playas == COMPANY_SPECTATOR) count++;
00145 }
00146
00147
00148 if (_network_dedicated) count--;
00149
00150 return count;
00151 }
00152
00159 const char *NetworkChangeCompanyPassword(CompanyID company_id, const char *password, bool already_hashed)
00160 {
00161 if (strcmp(password, "*") == 0) password = "";
00162
00163 if (_network_server) {
00164 NetworkServerSetCompanyPassword(company_id, password, already_hashed);
00165 } else {
00166 NetworkClientSetCompanyPassword(password);
00167 }
00168
00169 return password;
00170 }
00171
00179 const char *GenerateCompanyPasswordHash(const char *password, const char *password_server_id, uint32 password_game_seed)
00180 {
00181 if (StrEmpty(password)) return password;
00182
00183 char salted_password[NETWORK_SERVER_ID_LENGTH];
00184
00185 memset(salted_password, 0, sizeof(salted_password));
00186 snprintf(salted_password, sizeof(salted_password), "%s", password);
00187
00188 for (uint i = 0; i < NETWORK_SERVER_ID_LENGTH - 1; i++) {
00189 salted_password[i] ^= password_server_id[i] ^ (password_game_seed >> (i % 32));
00190 }
00191
00192 Md5 checksum;
00193 uint8 digest[16];
00194 static char hashed_password[NETWORK_SERVER_ID_LENGTH];
00195
00196
00197 checksum.Append(salted_password, sizeof(salted_password) - 1);
00198 checksum.Finish(digest);
00199
00200 for (int di = 0; di < 16; di++) sprintf(hashed_password + di * 2, "%02x", digest[di]);
00201 hashed_password[lengthof(hashed_password) - 1] = '\0';
00202
00203 return hashed_password;
00204 }
00205
00211 bool NetworkCompanyIsPassworded(CompanyID company_id)
00212 {
00213 return HasBit(_network_company_passworded, company_id);
00214 }
00215
00216
00217
00218
00219 void NetworkTextMessage(NetworkAction action, TextColour colour, bool self_send, const char *name, const char *str, int64 data)
00220 {
00221 StringID strid;
00222 switch (action) {
00223 case NETWORK_ACTION_SERVER_MESSAGE:
00224
00225 strid = STR_NETWORK_SERVER_MESSAGE;
00226 colour = CC_DEFAULT;
00227 break;
00228 case NETWORK_ACTION_COMPANY_SPECTATOR:
00229 colour = CC_DEFAULT;
00230 strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_SPECTATE;
00231 break;
00232 case NETWORK_ACTION_COMPANY_JOIN:
00233 colour = CC_DEFAULT;
00234 strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_JOIN;
00235 break;
00236 case NETWORK_ACTION_COMPANY_NEW:
00237 colour = CC_DEFAULT;
00238 strid = STR_NETWORK_MESSAGE_CLIENT_COMPANY_NEW;
00239 break;
00240 case NETWORK_ACTION_JOIN:
00241
00242 strid = _network_server ? STR_NETWORK_MESSAGE_CLIENT_JOINED_ID : STR_NETWORK_MESSAGE_CLIENT_JOINED;
00243 break;
00244 case NETWORK_ACTION_LEAVE: strid = STR_NETWORK_MESSAGE_CLIENT_LEFT; break;
00245 case NETWORK_ACTION_NAME_CHANGE: strid = STR_NETWORK_MESSAGE_NAME_CHANGE; break;
00246 case NETWORK_ACTION_GIVE_MONEY: strid = self_send ? STR_NETWORK_MESSAGE_GAVE_MONEY_AWAY : STR_NETWORK_MESSAGE_GIVE_MONEY; break;
00247 case NETWORK_ACTION_CHAT_COMPANY: strid = self_send ? STR_NETWORK_CHAT_TO_COMPANY : STR_NETWORK_CHAT_COMPANY; break;
00248 case NETWORK_ACTION_CHAT_CLIENT: strid = self_send ? STR_NETWORK_CHAT_TO_CLIENT : STR_NETWORK_CHAT_CLIENT; break;
00249 default: strid = STR_NETWORK_CHAT_ALL; break;
00250 }
00251
00252 char message[1024];
00253 SetDParamStr(0, name);
00254 SetDParamStr(1, str);
00255 SetDParam(2, data);
00256
00257
00258
00259
00260
00261 char *msg_ptr = message + Utf8Encode(message, _current_text_dir == TD_LTR ? CHAR_TD_LRM : CHAR_TD_RLM);
00262 GetString(msg_ptr, strid, lastof(message));
00263
00264 DEBUG(desync, 1, "msg: %08x; %02x; %s", _date, _date_fract, message);
00265 IConsolePrintF(colour, "%s", message);
00266 NetworkAddChatMessage((TextColour)colour, _settings_client.gui.network_chat_timeout, "%s", message);
00267 }
00268
00269
00270 uint NetworkCalculateLag(const NetworkClientSocket *cs)
00271 {
00272 int lag = cs->last_frame_server - cs->last_frame;
00273
00274
00275
00276 if (cs->last_frame_server + DAY_TICKS + _settings_client.network.frame_freq < _frame_counter) {
00277 lag += _frame_counter - (cs->last_frame_server + DAY_TICKS + _settings_client.network.frame_freq);
00278 }
00279 return lag;
00280 }
00281
00282
00283
00284
00285 void NetworkError(StringID error_string)
00286 {
00287 _switch_mode = SM_MENU;
00288 extern StringID _switch_mode_errorstr;
00289 _switch_mode_errorstr = error_string;
00290 }
00291
00297 StringID GetNetworkErrorMsg(NetworkErrorCode err)
00298 {
00299
00300
00301 static const StringID network_error_strings[] = {
00302 STR_NETWORK_ERROR_CLIENT_GENERAL,
00303 STR_NETWORK_ERROR_CLIENT_DESYNC,
00304 STR_NETWORK_ERROR_CLIENT_SAVEGAME,
00305 STR_NETWORK_ERROR_CLIENT_CONNECTION_LOST,
00306 STR_NETWORK_ERROR_CLIENT_PROTOCOL_ERROR,
00307 STR_NETWORK_ERROR_CLIENT_NEWGRF_MISMATCH,
00308 STR_NETWORK_ERROR_CLIENT_NOT_AUTHORIZED,
00309 STR_NETWORK_ERROR_CLIENT_NOT_EXPECTED,
00310 STR_NETWORK_ERROR_CLIENT_WRONG_REVISION,
00311 STR_NETWORK_ERROR_CLIENT_NAME_IN_USE,
00312 STR_NETWORK_ERROR_CLIENT_WRONG_PASSWORD,
00313 STR_NETWORK_ERROR_CLIENT_COMPANY_MISMATCH,
00314 STR_NETWORK_ERROR_CLIENT_KICKED,
00315 STR_NETWORK_ERROR_CLIENT_CHEATER,
00316 STR_NETWORK_ERROR_CLIENT_SERVER_FULL,
00317 STR_NETWORK_ERROR_CLIENT_TOO_MANY_COMMANDS
00318 };
00319
00320 if (err >= (ptrdiff_t)lengthof(network_error_strings)) err = NETWORK_ERROR_GENERAL;
00321
00322 return network_error_strings[err];
00323 }
00324
00330 void NetworkHandlePauseChange(PauseMode prev_mode, PauseMode changed_mode)
00331 {
00332 if (!_networking) return;
00333
00334 switch (changed_mode) {
00335 case PM_PAUSED_NORMAL:
00336 case PM_PAUSED_JOIN:
00337 case PM_PAUSED_ACTIVE_CLIENTS: {
00338 bool changed = ((_pause_mode == PM_UNPAUSED) != (prev_mode == PM_UNPAUSED));
00339 bool paused = (_pause_mode != PM_UNPAUSED);
00340 if (!paused && !changed) return;
00341
00342 StringID str;
00343 if (!changed) {
00344 int i = -1;
00345 if ((_pause_mode & PM_PAUSED_NORMAL) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL);
00346 if ((_pause_mode & PM_PAUSED_JOIN) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS);
00347 if ((_pause_mode & PM_PAUSED_ACTIVE_CLIENTS) != PM_UNPAUSED) SetDParam(++i, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS);
00348 str = STR_NETWORK_SERVER_MESSAGE_GAME_STILL_PAUSED_1 + i;
00349 } else {
00350 switch (changed_mode) {
00351 case PM_PAUSED_NORMAL: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL); break;
00352 case PM_PAUSED_JOIN: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS); break;
00353 case PM_PAUSED_ACTIVE_CLIENTS: SetDParam(0, STR_NETWORK_SERVER_MESSAGE_GAME_REASON_NOT_ENOUGH_PLAYERS); break;
00354 default: NOT_REACHED();
00355 }
00356 str = paused ? STR_NETWORK_SERVER_MESSAGE_GAME_PAUSED : STR_NETWORK_SERVER_MESSAGE_GAME_UNPAUSED;
00357 }
00358
00359 char buffer[DRAW_STRING_BUFFER];
00360 GetString(buffer, str, lastof(buffer));
00361 NetworkTextMessage(NETWORK_ACTION_SERVER_MESSAGE, CC_DEFAULT, false, NULL, buffer);
00362 break;
00363 }
00364
00365 default:
00366 return;
00367 }
00368 }
00369
00370
00379 static void CheckPauseHelper(bool pause, PauseMode pm)
00380 {
00381 if (pause == ((_pause_mode & pm) != PM_UNPAUSED)) return;
00382
00383 DoCommandP(0, pm, pause ? 1 : 0, CMD_PAUSE);
00384 }
00385
00391 static uint NetworkCountActiveClients()
00392 {
00393 const NetworkClientSocket *cs;
00394 uint count = 0;
00395
00396 FOR_ALL_CLIENT_SOCKETS(cs) {
00397 if (cs->status != NetworkClientSocket::STATUS_ACTIVE) continue;
00398 if (!Company::IsValidID(cs->GetInfo()->client_playas)) continue;
00399 count++;
00400 }
00401
00402 return count;
00403 }
00404
00408 static void CheckMinActiveClients()
00409 {
00410 if ((_pause_mode & PM_PAUSED_ERROR) != PM_UNPAUSED ||
00411 !_network_dedicated ||
00412 (_settings_client.network.min_active_clients == 0 && (_pause_mode & PM_PAUSED_ACTIVE_CLIENTS) == PM_UNPAUSED)) {
00413 return;
00414 }
00415 CheckPauseHelper(NetworkCountActiveClients() < _settings_client.network.min_active_clients, PM_PAUSED_ACTIVE_CLIENTS);
00416 }
00417
00422 static bool NetworkHasJoiningClient()
00423 {
00424 const NetworkClientSocket *cs;
00425 FOR_ALL_CLIENT_SOCKETS(cs) {
00426 if (cs->status >= NetworkClientSocket::STATUS_AUTHORIZED && cs->status < NetworkClientSocket::STATUS_ACTIVE) return true;
00427 }
00428
00429 return false;
00430 }
00431
00435 static void CheckPauseOnJoin()
00436 {
00437 if ((_pause_mode & PM_PAUSED_ERROR) != PM_UNPAUSED ||
00438 (!_settings_client.network.pause_on_join && (_pause_mode & PM_PAUSED_JOIN) == PM_UNPAUSED)) {
00439 return;
00440 }
00441 CheckPauseHelper(NetworkHasJoiningClient(), PM_PAUSED_JOIN);
00442 }
00443
00452 void ParseConnectionString(const char **company, const char **port, char *connection_string)
00453 {
00454 bool ipv6 = (strchr(connection_string, ':') != strrchr(connection_string, ':'));
00455 char *p;
00456 for (p = connection_string; *p != '\0'; p++) {
00457 switch (*p) {
00458 case '[':
00459 ipv6 = true;
00460 break;
00461
00462 case ']':
00463 ipv6 = false;
00464 break;
00465
00466 case '#':
00467 *company = p + 1;
00468 *p = '\0';
00469 break;
00470
00471 case ':':
00472 if (ipv6) break;
00473 *port = p + 1;
00474 *p = '\0';
00475 break;
00476 }
00477 }
00478 }
00479
00480 void ServerNetworkGameSocketHandler::AcceptConnection(SOCKET s, const NetworkAddress &address)
00481 {
00482
00483 _network_clients_connected++;
00484
00485 SetWindowDirty(WC_CLIENT_LIST, 0);
00486 ServerNetworkGameSocketHandler *cs = new ServerNetworkGameSocketHandler(s);
00487 cs->client_address = address;
00488 }
00489
00494 static void InitializeNetworkPools(bool close_admins = true)
00495 {
00496 _networkclientsocket_pool.CleanPool();
00497 _networkclientinfo_pool.CleanPool();
00498 if (close_admins) _networkadminsocket_pool.CleanPool();
00499 }
00500
00505 void NetworkClose(bool close_admins)
00506 {
00507 if (_network_server) {
00508 if (close_admins) {
00509 ServerNetworkAdminSocketHandler *as;
00510 FOR_ALL_ADMIN_SOCKETS(as) {
00511 as->CloseConnection(true);
00512 }
00513 }
00514
00515 NetworkClientSocket *cs;
00516 FOR_ALL_CLIENT_SOCKETS(cs) {
00517 cs->CloseConnection(NETWORK_RECV_STATUS_CONN_LOST);
00518 }
00519 ServerNetworkGameSocketHandler::CloseListeners();
00520 ServerNetworkAdminSocketHandler::CloseListeners();
00521 } else if (MyClient::my_client != NULL) {
00522 MyClient::SendQuit();
00523 MyClient::my_client->CloseConnection(NETWORK_RECV_STATUS_CONN_LOST);
00524 }
00525
00526 TCPConnecter::KillAll();
00527
00528 _networking = false;
00529 _network_server = false;
00530
00531 NetworkFreeLocalCommandQueue();
00532
00533 free(_network_company_states);
00534 _network_company_states = NULL;
00535
00536 InitializeNetworkPools(close_admins);
00537 }
00538
00539
00540 static void NetworkInitialize(bool close_admins = true)
00541 {
00542 InitializeNetworkPools(close_admins);
00543 NetworkUDPInitialize();
00544
00545 _sync_frame = 0;
00546 _network_first_time = true;
00547
00548 _network_reconnect = 0;
00549 }
00550
00552 class TCPQueryConnecter : TCPConnecter {
00553 public:
00554 TCPQueryConnecter(const NetworkAddress &address) : TCPConnecter(address) {}
00555
00556 virtual void OnFailure()
00557 {
00558 NetworkDisconnect();
00559 }
00560
00561 virtual void OnConnect(SOCKET s)
00562 {
00563 _networking = true;
00564 new ClientNetworkGameSocketHandler(s);
00565 MyClient::SendCompanyInformationQuery();
00566 }
00567 };
00568
00569
00570
00571
00572 void NetworkTCPQueryServer(NetworkAddress address)
00573 {
00574 if (!_network_available) return;
00575
00576 NetworkDisconnect();
00577 NetworkInitialize();
00578
00579 new TCPQueryConnecter(address);
00580 }
00581
00582
00583
00584
00585 void NetworkAddServer(const char *b)
00586 {
00587 if (*b != '\0') {
00588 const char *port = NULL;
00589 const char *company = NULL;
00590 char host[NETWORK_HOSTNAME_LENGTH];
00591 uint16 rport;
00592
00593 strecpy(host, b, lastof(host));
00594
00595 strecpy(_settings_client.network.connect_to_ip, b, lastof(_settings_client.network.connect_to_ip));
00596 rport = NETWORK_DEFAULT_PORT;
00597
00598 ParseConnectionString(&company, &port, host);
00599 if (port != NULL) rport = atoi(port);
00600
00601 NetworkUDPQueryServer(NetworkAddress(host, rport), true);
00602 }
00603 }
00604
00610 void GetBindAddresses(NetworkAddressList *addresses, uint16 port)
00611 {
00612 for (char **iter = _network_bind_list.Begin(); iter != _network_bind_list.End(); iter++) {
00613 *addresses->Append() = NetworkAddress(*iter, port);
00614 }
00615
00616
00617 if (addresses->Length() == 0) {
00618 *addresses->Append() = NetworkAddress("", port);
00619 }
00620 }
00621
00622
00623
00624
00625 void NetworkRebuildHostList()
00626 {
00627 _network_host_list.Clear();
00628
00629 for (NetworkGameList *item = _network_game_list; item != NULL; item = item->next) {
00630 if (item->manually) *_network_host_list.Append() = strdup(item->address.GetAddressAsString(false));
00631 }
00632 }
00633
00635 class TCPClientConnecter : TCPConnecter {
00636 public:
00637 TCPClientConnecter(const NetworkAddress &address) : TCPConnecter(address) {}
00638
00639 virtual void OnFailure()
00640 {
00641 NetworkError(STR_NETWORK_ERROR_NOCONNECTION);
00642 }
00643
00644 virtual void OnConnect(SOCKET s)
00645 {
00646 _networking = true;
00647 new ClientNetworkGameSocketHandler(s);
00648 IConsoleCmdExec("exec scripts/on_client.scr 0");
00649 NetworkClient_Connected();
00650 }
00651 };
00652
00653
00654
00655 void NetworkClientConnectGame(NetworkAddress address, CompanyID join_as, const char *join_server_password, const char *join_company_password)
00656 {
00657 if (!_network_available) return;
00658
00659 if (address.GetPort() == 0) return;
00660
00661 strecpy(_settings_client.network.last_host, address.GetHostname(), lastof(_settings_client.network.last_host));
00662 _settings_client.network.last_port = address.GetPort();
00663 _network_join_as = join_as;
00664 _network_join_server_password = join_server_password;
00665 _network_join_company_password = join_company_password;
00666
00667 NetworkDisconnect();
00668 NetworkInitialize();
00669
00670 _network_join_status = NETWORK_JOIN_STATUS_CONNECTING;
00671 ShowJoinStatusWindow();
00672
00673 new TCPClientConnecter(address);
00674 }
00675
00676 static void NetworkInitGameInfo()
00677 {
00678 if (StrEmpty(_settings_client.network.server_name)) {
00679 snprintf(_settings_client.network.server_name, sizeof(_settings_client.network.server_name), "Unnamed Server");
00680 }
00681
00682
00683 _network_game_info.clients_on = _network_dedicated ? 0 : 1;
00684
00685
00686 assert(NetworkClientInfo::CanAllocateItem());
00687 NetworkClientInfo *ci = new NetworkClientInfo(CLIENT_ID_SERVER);
00688 ci->client_playas = _network_dedicated ? COMPANY_SPECTATOR : _local_company;
00689
00690 strecpy(ci->client_name, _settings_client.network.client_name, lastof(ci->client_name));
00691 }
00692
00693 bool NetworkServerStart()
00694 {
00695 if (!_network_available) return false;
00696
00697
00698 IConsoleCmdExec("exec scripts/pre_server.scr 0");
00699 if (_network_dedicated) IConsoleCmdExec("exec scripts/pre_dedicated.scr 0");
00700
00701 NetworkDisconnect(false, false);
00702 NetworkInitialize(false);
00703 if (!ServerNetworkGameSocketHandler::Listen(_settings_client.network.server_port)) return false;
00704
00705
00706 if (!StrEmpty(_settings_client.network.admin_password) && !ServerNetworkAdminSocketHandler::Listen(_settings_client.network.server_admin_port)) return false;
00707
00708
00709 _network_udp_server = _udp_server_socket->Listen();
00710
00711 _network_company_states = CallocT<NetworkCompanyState>(MAX_COMPANIES);
00712 _network_server = true;
00713 _networking = true;
00714 _frame_counter = 0;
00715 _frame_counter_server = 0;
00716 _frame_counter_max = 0;
00717 _last_sync_frame = 0;
00718 _network_own_client_id = CLIENT_ID_SERVER;
00719
00720 _network_clients_connected = 0;
00721 _network_company_passworded = 0;
00722
00723 NetworkInitGameInfo();
00724
00725
00726 IConsoleCmdExec("exec scripts/on_server.scr 0");
00727
00728 if (_network_dedicated) IConsoleCmdExec("exec scripts/on_dedicated.scr 0");
00729
00730
00731 _network_last_advertise_frame = 0;
00732 _network_need_advertise = true;
00733 NetworkUDPAdvertise();
00734
00735
00736 if (_network_dedicated) ServerNetworkAdminSocketHandler::WelcomeAll();
00737
00738 return true;
00739 }
00740
00741
00742
00743 void NetworkReboot()
00744 {
00745 if (_network_server) {
00746 NetworkClientSocket *cs;
00747 FOR_ALL_CLIENT_SOCKETS(cs) {
00748 cs->SendNewGame();
00749 cs->SendPackets();
00750 }
00751
00752 ServerNetworkAdminSocketHandler *as;
00753 FOR_ALL_ADMIN_SOCKETS(as) {
00754 as->SendNewGame();
00755 as->SendPackets();
00756 }
00757 }
00758
00759
00760
00761 NetworkClose(!_network_dedicated);
00762 }
00763
00769 void NetworkDisconnect(bool blocking, bool close_admins)
00770 {
00771 if (_network_server) {
00772 NetworkClientSocket *cs;
00773 FOR_ALL_CLIENT_SOCKETS(cs) {
00774 cs->SendShutdown();
00775 cs->SendPackets();
00776 }
00777
00778 if (close_admins) {
00779 ServerNetworkAdminSocketHandler *as;
00780 FOR_ALL_ADMIN_SOCKETS(as) {
00781 as->SendShutdown();
00782 as->SendPackets();
00783 }
00784 }
00785 }
00786
00787 if (_settings_client.network.server_advertise) NetworkUDPRemoveAdvertise(blocking);
00788
00789 DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);
00790
00791 NetworkClose(close_admins);
00792
00793
00794 NetworkUDPInitialize();
00795 }
00796
00801 static bool NetworkReceive()
00802 {
00803 if (_network_server) {
00804 ServerNetworkAdminSocketHandler::Receive();
00805 return ServerNetworkGameSocketHandler::Receive();
00806 } else {
00807 return ClientNetworkGameSocketHandler::Receive();
00808 }
00809 }
00810
00811
00812 static void NetworkSend()
00813 {
00814 if (_network_server) {
00815 ServerNetworkAdminSocketHandler::Send();
00816 ServerNetworkGameSocketHandler::Send();
00817 } else {
00818 ClientNetworkGameSocketHandler::Send();
00819 }
00820 }
00821
00822
00823 void NetworkUDPGameLoop()
00824 {
00825 _network_content_client.SendReceive();
00826 TCPConnecter::CheckCallbacks();
00827 NetworkHTTPSocketHandler::HTTPReceive();
00828
00829 if (_network_udp_server) {
00830 _udp_server_socket->ReceivePackets();
00831 _udp_master_socket->ReceivePackets();
00832 } else {
00833 _udp_client_socket->ReceivePackets();
00834 if (_network_udp_broadcast > 0) _network_udp_broadcast--;
00835 NetworkGameListRequery();
00836 }
00837 }
00838
00839
00840
00841 void NetworkGameLoop()
00842 {
00843 if (!_networking) return;
00844
00845 if (!NetworkReceive()) return;
00846
00847 if (_network_server) {
00848
00849 if (_date_fract == 0) {
00850
00851 static Date last_log;
00852 if (last_log != _date) {
00853 DEBUG(desync, 1, "sync: %08x; %02x; %08x; %08x", _date, _date_fract, _random.state[0], _random.state[1]);
00854 last_log = _date;
00855 }
00856 }
00857
00858 #ifdef DEBUG_DUMP_COMMANDS
00859
00860 static FILE *f = FioFOpenFile("commands.log", "rb", SAVE_DIR);
00861 static Date next_date = 0;
00862 static uint32 next_date_fract;
00863 static CommandPacket *cp = NULL;
00864 static bool check_sync_state = false;
00865 static uint32 sync_state[2];
00866 if (f == NULL && next_date == 0) {
00867 DEBUG(net, 0, "Cannot open commands.log");
00868 next_date = 1;
00869 }
00870
00871 while (f != NULL && !feof(f)) {
00872 if (_date == next_date && _date_fract == next_date_fract) {
00873 if (cp != NULL) {
00874 NetworkSendCommand(cp->tile, cp->p1, cp->p2, cp->cmd & ~CMD_FLAGS_MASK, NULL, cp->text, cp->company);
00875 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));
00876 free(cp);
00877 cp = NULL;
00878 }
00879 if (check_sync_state) {
00880 if (sync_state[0] == _random.state[0] && sync_state[1] == _random.state[1]) {
00881 DEBUG(net, 0, "sync check: %08x; %02x; match", _date, _date_fract);
00882 } else {
00883 DEBUG(net, 0, "sync check: %08x; %02x; mismatch expected {%08x, %08x}, got {%08x, %08x}",
00884 _date, _date_fract, sync_state[0], sync_state[1], _random.state[0], _random.state[1]);
00885 NOT_REACHED();
00886 }
00887 check_sync_state = false;
00888 }
00889 }
00890
00891 if (cp != NULL || check_sync_state) break;
00892
00893 char buff[4096];
00894 if (fgets(buff, lengthof(buff), f) == NULL) break;
00895
00896 char *p = buff;
00897
00898 if (*p == '[') {
00899 p = strchr(p, ']');
00900 if (p == NULL) break;
00901 p += 2;
00902 }
00903
00904 if (strncmp(p, "cmd: ", 5) == 0) {
00905 cp = CallocT<CommandPacket>(1);
00906 int company;
00907 int ret = sscanf(p + 5, "%x; %x; %x; %x; %x; %x; %x; \"%[^\"]\"", &next_date, &next_date_fract, &company, &cp->tile, &cp->p1, &cp->p2, &cp->cmd, cp->text);
00908
00909
00910
00911 assert(ret == 8 || ret == 7);
00912 cp->company = (CompanyID)company;
00913 } else if (strncmp(p, "join: ", 6) == 0) {
00914
00915 int ret = sscanf(p + 6, "%x; %x", &next_date, &next_date_fract);
00916 assert(ret == 2);
00917 DEBUG(net, 0, "injecting pause for join at %08x:%02x; please join when paused", next_date, next_date_fract);
00918 cp = CallocT<CommandPacket>(1);
00919 cp->company = COMPANY_SPECTATOR;
00920 cp->cmd = CMD_PAUSE;
00921 cp->p1 = PM_PAUSED_NORMAL;
00922 cp->p2 = 1;
00923 _ddc_fastforward = false;
00924 } else if (strncmp(p, "sync: ", 6) == 0) {
00925 int ret = sscanf(p + 6, "%x; %x; %x; %x", &next_date, &next_date_fract, &sync_state[0], &sync_state[1]);
00926 assert(ret == 4);
00927 check_sync_state = true;
00928 } else if (strncmp(p, "msg: ", 5) == 0 || strncmp(p, "client: ", 8) == 0 ||
00929 strncmp(p, "load: ", 6) == 0 || strncmp(p, "save: ", 6) == 0) {
00930
00931 } else {
00932
00933 DEBUG(net, 0, "trying to parse: %s", p);
00934 NOT_REACHED();
00935 }
00936 }
00937 if (f != NULL && feof(f)) {
00938 DEBUG(net, 0, "End of commands.log");
00939 fclose(f);
00940 f = NULL;
00941 }
00942 #endif
00943 if (_frame_counter >= _frame_counter_max) {
00944
00945
00946
00947 CheckPauseOnJoin();
00948 CheckMinActiveClients();
00949 NetworkDistributeCommands();
00950 }
00951
00952 bool send_frame = false;
00953
00954
00955 _frame_counter++;
00956
00957 if (_frame_counter > _frame_counter_max) {
00958 _frame_counter_max = _frame_counter + _settings_client.network.frame_freq;
00959 send_frame = true;
00960 }
00961
00962 NetworkExecuteLocalCommandQueue();
00963
00964
00965 StateGameLoop();
00966
00967 _sync_seed_1 = _random.state[0];
00968 #ifdef NETWORK_SEND_DOUBLE_SEED
00969 _sync_seed_2 = _random.state[1];
00970 #endif
00971
00972 NetworkServer_Tick(send_frame);
00973 } else {
00974
00975
00976
00977 if (_frame_counter_server > _frame_counter) {
00978
00979 while (_frame_counter_server > _frame_counter) {
00980 if (!ClientNetworkGameSocketHandler::GameLoop()) return;
00981 }
00982 } else {
00983
00984 if (_frame_counter_max > _frame_counter) {
00985
00986 if (!ClientNetworkGameSocketHandler::GameLoop()) return;
00987 }
00988 }
00989 }
00990
00991 NetworkSend();
00992 }
00993
00994 static void NetworkGenerateServerId()
00995 {
00996 Md5 checksum;
00997 uint8 digest[16];
00998 char hex_output[16 * 2 + 1];
00999 char coding_string[NETWORK_NAME_LENGTH];
01000 int di;
01001
01002 snprintf(coding_string, sizeof(coding_string), "%d%s", (uint)Random(), "OpenTTD Server ID");
01003
01004
01005 checksum.Append((const uint8*)coding_string, strlen(coding_string));
01006 checksum.Finish(digest);
01007
01008 for (di = 0; di < 16; ++di) {
01009 sprintf(hex_output + di * 2, "%02x", digest[di]);
01010 }
01011
01012
01013 snprintf(_settings_client.network.network_id, sizeof(_settings_client.network.network_id), "%s", hex_output);
01014 }
01015
01016 void NetworkStartDebugLog(NetworkAddress address)
01017 {
01018 extern SOCKET _debug_socket;
01019
01020 DEBUG(net, 0, "Redirecting DEBUG() to %s:%d", address.GetHostname(), address.GetPort());
01021
01022 SOCKET s = address.Connect();
01023 if (s == INVALID_SOCKET) {
01024 DEBUG(net, 0, "Failed to open socket for redirection DEBUG()");
01025 return;
01026 }
01027
01028 _debug_socket = s;
01029
01030 DEBUG(net, 0, "DEBUG() is now redirected");
01031 }
01032
01034 void NetworkStartUp()
01035 {
01036 DEBUG(net, 3, "[core] starting network...");
01037
01038
01039 _network_available = NetworkCoreInitialize();
01040 _network_dedicated = false;
01041 _network_last_advertise_frame = 0;
01042 _network_need_advertise = true;
01043 _network_advertise_retries = 0;
01044
01045
01046 if (StrEmpty(_settings_client.network.network_id)) NetworkGenerateServerId();
01047
01048 memset(&_network_game_info, 0, sizeof(_network_game_info));
01049
01050 NetworkInitialize();
01051 DEBUG(net, 3, "[core] network online, multiplayer available");
01052 NetworkFindBroadcastIPs(&_broadcast_list);
01053 }
01054
01056 void NetworkShutDown()
01057 {
01058 NetworkDisconnect(true);
01059 NetworkUDPClose();
01060
01061 DEBUG(net, 3, "[core] shutting down network");
01062
01063 _network_available = false;
01064
01065 NetworkCoreShutdown();
01066 }
01067
01072 bool IsNetworkCompatibleVersion(const char *other)
01073 {
01074 return strncmp(_openttd_revision, other, NETWORK_REVISION_LENGTH - 1) == 0;
01075 }
01076
01077 #endif