OpenTTD Source: src/network/network_admin.cpp Source File

OpenTTD Source 14.0-beta1

network_admin.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
10 #include "../stdafx.h"
11 #include "../strings_func.h"
12 #include "../timer/timer_game_calendar.h"
13 #include "../timer/timer_game_calendar.h"
14 #include "core/network_game_info.h"
15 #include "network_admin.h"
16 #include "network_base.h"
17 #include "network_server.h"
18 #include "../command_func.h"
19 #include "../company_base.h"
20 #include "../console_func.h"
21 #include "../core/pool_func.hpp"
22 #include "../map_func.h"
23 #include "../rev.h"
24 #include "../game/game.hpp"
25
26 #include "../safeguards.h"
27
28
29 /* This file handles all the admin network commands. */
30
32 AdminIndex _redirect_console_to_admin = INVALID_ADMIN_ID;
33
35 byte _network_admins_connected = 0;
36
38 NetworkAdminSocketPool _networkadminsocket_pool("NetworkAdminSocket");
39 INSTANTIATE_POOL_METHODS(NetworkAdminSocket)
40
41
42 static const std::chrono::seconds ADMIN_AUTHORISATION_TIMEOUT(10);
43
44
46 static const AdminUpdateFrequency _admin_update_type_frequencies[] = {
47 ADMIN_FREQUENCY_POLL | ADMIN_FREQUENCY_DAILY | ADMIN_FREQUENCY_WEEKLY | ADMIN_FREQUENCY_MONTHLY | ADMIN_FREQUENCY_QUARTERLY | ADMIN_FREQUENCY_ANUALLY,
48 ADMIN_FREQUENCY_POLL | ADMIN_FREQUENCY_AUTOMATIC,
49 ADMIN_FREQUENCY_POLL | ADMIN_FREQUENCY_AUTOMATIC,
50 ADMIN_FREQUENCY_POLL | ADMIN_FREQUENCY_WEEKLY | ADMIN_FREQUENCY_MONTHLY | ADMIN_FREQUENCY_QUARTERLY | ADMIN_FREQUENCY_ANUALLY,
51 ADMIN_FREQUENCY_POLL | ADMIN_FREQUENCY_WEEKLY | ADMIN_FREQUENCY_MONTHLY | ADMIN_FREQUENCY_QUARTERLY | ADMIN_FREQUENCY_ANUALLY,
52 ADMIN_FREQUENCY_AUTOMATIC,
53 ADMIN_FREQUENCY_AUTOMATIC,
54 ADMIN_FREQUENCY_POLL,
55 ADMIN_FREQUENCY_AUTOMATIC,
56 ADMIN_FREQUENCY_AUTOMATIC,
57 };
59 static_assert(lengthof(_admin_update_type_frequencies) == ADMIN_UPDATE_END);
60
65 ServerNetworkAdminSocketHandler::ServerNetworkAdminSocketHandler(SOCKET s) : NetworkAdminSocketHandler(s)
66 {
67 _network_admins_connected++;
68 this->status = ADMIN_STATUS_INACTIVE;
69 this->connect_time = std::chrono::steady_clock::now();
70 }
71
75 ServerNetworkAdminSocketHandler::~ServerNetworkAdminSocketHandler()
76 {
77 _network_admins_connected--;
78 Debug(net, 3, "[admin] '{}' ({}) has disconnected", this->admin_name, this->admin_version);
79 if (_redirect_console_to_admin == this->index) _redirect_console_to_admin = INVALID_ADMIN_ID;
80
81 if (this->update_frequency[ADMIN_UPDATE_CONSOLE] & ADMIN_FREQUENCY_AUTOMATIC) {
82 this->update_frequency[ADMIN_UPDATE_CONSOLE] = (AdminUpdateFrequency)0;
83 DebugReconsiderSendRemoteMessages();
84 }
85 }
86
91 /* static */ bool ServerNetworkAdminSocketHandler::AllowConnection()
92 {
93 bool accept = !_settings_client.network.admin_password.empty() && _network_admins_connected < MAX_ADMINS;
94 /* We can't go over the MAX_ADMINS limit here. However, if we accept
95 * the connection, there has to be space in the pool. */
96 static_assert(NetworkAdminSocketPool::MAX_SIZE == MAX_ADMINS);
97 assert(!accept || ServerNetworkAdminSocketHandler::CanAllocateItem());
98 return accept;
99 }
100
102 /* static */ void ServerNetworkAdminSocketHandler::Send()
103 {
104 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::Iterate()) {
105 if (as->status == ADMIN_STATUS_INACTIVE && std::chrono::steady_clock::now() > as->connect_time + ADMIN_AUTHORISATION_TIMEOUT) {
106 Debug(net, 2, "[admin] Admin did not send its authorisation within {} seconds", std::chrono::duration_cast<std::chrono::seconds>(ADMIN_AUTHORISATION_TIMEOUT).count());
107 as->CloseConnection(true);
108 continue;
109 }
110 if (as->writable) {
111 as->SendPackets();
112 }
113 }
114 }
115
121 /* static */ void ServerNetworkAdminSocketHandler::AcceptConnection(SOCKET s, const NetworkAddress &address)
122 {
123 ServerNetworkAdminSocketHandler *as = new ServerNetworkAdminSocketHandler(s);
124 as->address = address; // Save the IP of the client
125 }
126
127 /***********
128 * Sending functions for admin network
129 ************/
130
135 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendError(NetworkErrorCode error)
136 {
137 Packet *p = new Packet(ADMIN_PACKET_SERVER_ERROR);
138
139 p->Send_uint8(error);
140 this->SendPacket(p);
141
142 std::string error_message = GetString(GetNetworkErrorMsg(error));
143
144 Debug(net, 1, "[admin] The admin '{}' ({}) made an error and has been disconnected: '{}'", this->admin_name, this->admin_version, error_message);
145
146 return this->CloseConnection(true);
147 }
148
150 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendProtocol()
151 {
152 Packet *p = new Packet(ADMIN_PACKET_SERVER_PROTOCOL);
153
154 /* announce the protocol version */
155 p->Send_uint8(NETWORK_GAME_ADMIN_VERSION);
156
157 for (int i = 0; i < ADMIN_UPDATE_END; i++) {
158 p->Send_bool (true);
159 p->Send_uint16(i);
160 p->Send_uint16(_admin_update_type_frequencies[i]);
161 }
162
163 p->Send_bool(false);
164 this->SendPacket(p);
165
166 return this->SendWelcome();
167 }
168
170 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendWelcome()
171 {
172 Packet *p = new Packet(ADMIN_PACKET_SERVER_WELCOME);
173
174 p->Send_string(_settings_client.network.server_name);
175 p->Send_string(GetNetworkRevisionString());
176 p->Send_bool (_network_dedicated);
177
178 p->Send_string(""); // Used to be map-name.
179 p->Send_uint32(_settings_game.game_creation.generation_seed);
180 p->Send_uint8 (_settings_game.game_creation.landscape);
181 p->Send_uint32(TimerGameCalendar::ConvertYMDToDate(_settings_game.game_creation.starting_year, 0, 1).base());
182 p->Send_uint16(Map::SizeX());
183 p->Send_uint16(Map::SizeY());
184
185 this->SendPacket(p);
186
187 return NETWORK_RECV_STATUS_OKAY;
188 }
189
191 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendNewGame()
192 {
193 Packet *p = new Packet(ADMIN_PACKET_SERVER_NEWGAME);
194 this->SendPacket(p);
195 return NETWORK_RECV_STATUS_OKAY;
196 }
197
199 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendShutdown()
200 {
201 Packet *p = new Packet(ADMIN_PACKET_SERVER_SHUTDOWN);
202 this->SendPacket(p);
203 return NETWORK_RECV_STATUS_OKAY;
204 }
205
207 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendDate()
208 {
209 Packet *p = new Packet(ADMIN_PACKET_SERVER_DATE);
210
211 p->Send_uint32(TimerGameCalendar::date.base());
212 this->SendPacket(p);
213
214 return NETWORK_RECV_STATUS_OKAY;
215 }
216
221 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendClientJoin(ClientID client_id)
222 {
223 Packet *p = new Packet(ADMIN_PACKET_SERVER_CLIENT_JOIN);
224
225 p->Send_uint32(client_id);
226 this->SendPacket(p);
227
228 return NETWORK_RECV_STATUS_OKAY;
229 }
230
236 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendClientInfo(const NetworkClientSocket *cs, const NetworkClientInfo *ci)
237 {
238 /* Only send data when we're a proper client, not just someone trying to query the server. */
239 if (ci == nullptr) return NETWORK_RECV_STATUS_OKAY;
240
241 Packet *p = new Packet(ADMIN_PACKET_SERVER_CLIENT_INFO);
242
243 p->Send_uint32(ci->client_id);
244 p->Send_string(cs == nullptr ? "" : const_cast<NetworkAddress &>(cs->client_address).GetHostname());
245 p->Send_string(ci->client_name);
246 p->Send_uint8 (0); // Used to be language
247 p->Send_uint32(ci->join_date.base());
248 p->Send_uint8 (ci->client_playas);
249
250 this->SendPacket(p);
251
252 return NETWORK_RECV_STATUS_OKAY;
253 }
254
255
260 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendClientUpdate(const NetworkClientInfo *ci)
261 {
262 Packet *p = new Packet(ADMIN_PACKET_SERVER_CLIENT_UPDATE);
263
264 p->Send_uint32(ci->client_id);
265 p->Send_string(ci->client_name);
266 p->Send_uint8 (ci->client_playas);
267
268 this->SendPacket(p);
269
270 return NETWORK_RECV_STATUS_OKAY;
271 }
272
277 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendClientQuit(ClientID client_id)
278 {
279 Packet *p = new Packet(ADMIN_PACKET_SERVER_CLIENT_QUIT);
280
281 p->Send_uint32(client_id);
282 this->SendPacket(p);
283
284 return NETWORK_RECV_STATUS_OKAY;
285 }
286
292 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendClientError(ClientID client_id, NetworkErrorCode error)
293 {
294 Packet *p = new Packet(ADMIN_PACKET_SERVER_CLIENT_ERROR);
295
296 p->Send_uint32(client_id);
297 p->Send_uint8 (error);
298 this->SendPacket(p);
299
300 return NETWORK_RECV_STATUS_OKAY;
301 }
302
307 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyNew(CompanyID company_id)
308 {
309 Packet *p = new Packet(ADMIN_PACKET_SERVER_COMPANY_NEW);
310 p->Send_uint8(company_id);
311
312 this->SendPacket(p);
313
314 return NETWORK_RECV_STATUS_OKAY;
315 }
316
321 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyInfo(const Company *c)
322 {
323 Packet *p = new Packet(ADMIN_PACKET_SERVER_COMPANY_INFO);
324
325 p->Send_uint8 (c->index);
326 SetDParam(0, c->index);
327 p->Send_string(GetString(STR_COMPANY_NAME));
328 SetDParam(0, c->index);
329 p->Send_string(GetString(STR_PRESIDENT_NAME));
330 p->Send_uint8 (c->colour);
331 p->Send_bool (NetworkCompanyIsPassworded(c->index));
332 p->Send_uint32(c->inaugurated_year.base());
333 p->Send_bool (c->is_ai);
334 p->Send_uint8 (CeilDiv(c->months_of_bankruptcy, 3)); // send as quarters_of_bankruptcy
335
336 this->SendPacket(p);
337
338 return NETWORK_RECV_STATUS_OKAY;
339 }
340
341
346 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyUpdate(const Company *c)
347 {
348 Packet *p = new Packet(ADMIN_PACKET_SERVER_COMPANY_UPDATE);
349
350 p->Send_uint8 (c->index);
351 SetDParam(0, c->index);
352 p->Send_string(GetString(STR_COMPANY_NAME));
353 SetDParam(0, c->index);
354 p->Send_string(GetString(STR_PRESIDENT_NAME));
355 p->Send_uint8 (c->colour);
356 p->Send_bool (NetworkCompanyIsPassworded(c->index));
357 p->Send_uint8 (CeilDiv(c->months_of_bankruptcy, 3)); // send as quarters_of_bankruptcy
358
359 this->SendPacket(p);
360
361 return NETWORK_RECV_STATUS_OKAY;
362 }
363
369 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyRemove(CompanyID company_id, AdminCompanyRemoveReason acrr)
370 {
371 Packet *p = new Packet(ADMIN_PACKET_SERVER_COMPANY_REMOVE);
372
373 p->Send_uint8(company_id);
374 p->Send_uint8(acrr);
375
376 this->SendPacket(p);
377
378 return NETWORK_RECV_STATUS_OKAY;
379 }
380
382 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyEconomy()
383 {
384 for (const Company *company : Company::Iterate()) {
385 /* Get the income. */
386 Money income = -std::reduce(std::begin(company->yearly_expenses[0]), std::end(company->yearly_expenses[0]));
387
388 Packet *p = new Packet(ADMIN_PACKET_SERVER_COMPANY_ECONOMY);
389
390 p->Send_uint8(company->index);
391
392 /* Current information. */
393 p->Send_uint64(company->money);
394 p->Send_uint64(company->current_loan);
395 p->Send_uint64(income);
396 p->Send_uint16(static_cast<uint16_t>(std::min<uint64_t>(UINT16_MAX, company->cur_economy.delivered_cargo.GetSum<OverflowSafeInt64>())));
397
398 /* Send stats for the last 2 quarters. */
399 for (uint i = 0; i < 2; i++) {
400 p->Send_uint64(company->old_economy[i].company_value);
401 p->Send_uint16(company->old_economy[i].performance_history);
402 p->Send_uint16(static_cast<uint16_t>(std::min<uint64_t>(UINT16_MAX, company->old_economy[i].delivered_cargo.GetSum<OverflowSafeInt64>())));
403 }
404
405 this->SendPacket(p);
406 }
407
408
409 return NETWORK_RECV_STATUS_OKAY;
410 }
411
413 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCompanyStats()
414 {
415 /* Fetch the latest version of the stats. */
416 NetworkCompanyStats company_stats[MAX_COMPANIES];
417 NetworkPopulateCompanyStats(company_stats);
418
419 /* Go through all the companies. */
420 for (const Company *company : Company::Iterate()) {
421 Packet *p = new Packet(ADMIN_PACKET_SERVER_COMPANY_STATS);
422
423 /* Send the information. */
424 p->Send_uint8(company->index);
425
426 for (uint i = 0; i < NETWORK_VEH_END; i++) {
427 p->Send_uint16(company_stats[company->index].num_vehicle[i]);
428 }
429
430 for (uint i = 0; i < NETWORK_VEH_END; i++) {
431 p->Send_uint16(company_stats[company->index].num_station[i]);
432 }
433
434 this->SendPacket(p);
435 }
436
437 return NETWORK_RECV_STATUS_OKAY;
438 }
439
448 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendChat(NetworkAction action, DestType desttype, ClientID client_id, const std::string &msg, int64_t data)
449 {
450 Packet *p = new Packet(ADMIN_PACKET_SERVER_CHAT);
451
452 p->Send_uint8 (action);
453 p->Send_uint8 (desttype);
454 p->Send_uint32(client_id);
455 p->Send_string(msg);
456 p->Send_uint64(data);
457
458 this->SendPacket(p);
459 return NETWORK_RECV_STATUS_OKAY;
460 }
461
466 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendRconEnd(const std::string_view command)
467 {
468 Packet *p = new Packet(ADMIN_PACKET_SERVER_RCON_END);
469
470 p->Send_string(command);
471 this->SendPacket(p);
472
473 return NETWORK_RECV_STATUS_OKAY;
474 }
475
481 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendRcon(uint16_t colour, const std::string_view result)
482 {
483 Packet *p = new Packet(ADMIN_PACKET_SERVER_RCON);
484
485 p->Send_uint16(colour);
486 p->Send_string(result);
487 this->SendPacket(p);
488
489 return NETWORK_RECV_STATUS_OKAY;
490 }
491
492 NetworkRecvStatus ServerNetworkAdminSocketHandler::Receive_ADMIN_RCON(Packet *p)
493 {
494 if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
495
496 std::string command = p->Recv_string(NETWORK_RCONCOMMAND_LENGTH);
497
498 Debug(net, 3, "[admin] Rcon command from '{}' ({}): {}", this->admin_name, this->admin_version, command);
499
500 _redirect_console_to_admin = this->index;
501 IConsoleCmdExec(command);
502 _redirect_console_to_admin = INVALID_ADMIN_ID;
503 return this->SendRconEnd(command);
504 }
505
506 NetworkRecvStatus ServerNetworkAdminSocketHandler::Receive_ADMIN_GAMESCRIPT(Packet *p)
507 {
508 if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
509
510 std::string json = p->Recv_string(NETWORK_GAMESCRIPT_JSON_LENGTH);
511
512 Debug(net, 6, "[admin] GameScript JSON from '{}' ({}): {}", this->admin_name, this->admin_version, json);
513
514 Game::NewEvent(new ScriptEventAdminPort(json));
515 return NETWORK_RECV_STATUS_OKAY;
516 }
517
518 NetworkRecvStatus ServerNetworkAdminSocketHandler::Receive_ADMIN_PING(Packet *p)
519 {
520 if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
521
522 uint32_t d1 = p->Recv_uint32();
523
524 Debug(net, 6, "[admin] Ping from '{}' ({}): {}", this->admin_name, this->admin_version, d1);
525
526 return this->SendPong(d1);
527 }
528
534 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendConsole(const std::string_view origin, const std::string_view string)
535 {
536 /* If the length of both strings, plus the 2 '\0' terminations and 3 bytes of the packet
537 * are bigger than the MTU, just ignore the message. Better safe than sorry. It should
538 * never occur though as the longest strings are chat messages, which are still 30%
539 * smaller than COMPAT_MTU. */
540 if (origin.size() + string.size() + 2 + 3 >= COMPAT_MTU) return NETWORK_RECV_STATUS_OKAY;
541
542 Packet *p = new Packet(ADMIN_PACKET_SERVER_CONSOLE);
543
544 p->Send_string(origin);
545 p->Send_string(string);
546 this->SendPacket(p);
547
548 return NETWORK_RECV_STATUS_OKAY;
549 }
550
555 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendGameScript(const std::string_view json)
556 {
557 Packet *p = new Packet(ADMIN_PACKET_SERVER_GAMESCRIPT);
558
559 p->Send_string(json);
560 this->SendPacket(p);
561
562 return NETWORK_RECV_STATUS_OKAY;
563 }
564
566 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendPong(uint32_t d1)
567 {
568 Packet *p = new Packet(ADMIN_PACKET_SERVER_PONG);
569
570 p->Send_uint32(d1);
571 this->SendPacket(p);
572
573 return NETWORK_RECV_STATUS_OKAY;
574 }
575
577 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCmdNames()
578 {
579 Packet *p = new Packet(ADMIN_PACKET_SERVER_CMD_NAMES);
580
581 for (uint16_t i = 0; i < CMD_END; i++) {
582 const char *cmdname = GetCommandName(static_cast<Commands>(i));
583
584 /* Should COMPAT_MTU be exceeded, start a new packet
585 * (magic 5: 1 bool "more data" and one uint16_t "command id", one
586 * byte for string '\0' termination and 1 bool "no more data" */
587 if (!p->CanWriteToPacket(strlen(cmdname) + 5)) {
588 p->Send_bool(false);
589 this->SendPacket(p);
590
591 p = new Packet(ADMIN_PACKET_SERVER_CMD_NAMES);
592 }
593
594 p->Send_bool(true);
595 p->Send_uint16(i);
596 p->Send_string(cmdname);
597 }
598
599 /* Marker to notify the end of the packet has been reached. */
600 p->Send_bool(false);
601 this->SendPacket(p);
602
603 return NETWORK_RECV_STATUS_OKAY;
604 }
605
611 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendCmdLogging(ClientID client_id, const CommandPacket *cp)
612 {
613 Packet *p = new Packet(ADMIN_PACKET_SERVER_CMD_LOGGING);
614
615 p->Send_uint32(client_id);
616 p->Send_uint8 (cp->company);
617 p->Send_uint16(cp->cmd);
618 p->Send_buffer(cp->data);
619 p->Send_uint32(cp->frame);
620
621 this->SendPacket(p);
622
623 return NETWORK_RECV_STATUS_OKAY;
624 }
625
626 /***********
627 * Receiving functions
628 ************/
629
630 NetworkRecvStatus ServerNetworkAdminSocketHandler::Receive_ADMIN_JOIN(Packet *p)
631 {
632 if (this->status != ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
633
634 std::string password = p->Recv_string(NETWORK_PASSWORD_LENGTH);
635
636 if (_settings_client.network.admin_password.empty() ||
637 _settings_client.network.admin_password.compare(password) != 0) {
638 /* Password is invalid */
639 return this->SendError(NETWORK_ERROR_WRONG_PASSWORD);
640 }
641
642 this->admin_name = p->Recv_string(NETWORK_CLIENT_NAME_LENGTH);
643 this->admin_version = p->Recv_string(NETWORK_REVISION_LENGTH);
644
645 if (this->admin_name.empty() || this->admin_version.empty()) {
646 /* no name or version supplied */
647 return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
648 }
649
650 this->status = ADMIN_STATUS_ACTIVE;
651
652 Debug(net, 3, "[admin] '{}' ({}) has connected", this->admin_name, this->admin_version);
653
654 return this->SendProtocol();
655 }
656
657 NetworkRecvStatus ServerNetworkAdminSocketHandler::Receive_ADMIN_QUIT(Packet *)
658 {
659 /* The admin is leaving nothing else to do */
660 return this->CloseConnection();
661 }
662
663 NetworkRecvStatus ServerNetworkAdminSocketHandler::Receive_ADMIN_UPDATE_FREQUENCY(Packet *p)
664 {
665 if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
666
667 AdminUpdateType type = (AdminUpdateType)p->Recv_uint16();
668 AdminUpdateFrequency freq = (AdminUpdateFrequency)p->Recv_uint16();
669
670 if (type >= ADMIN_UPDATE_END || (_admin_update_type_frequencies[type] & freq) != freq) {
671 /* The server does not know of this UpdateType. */
672 Debug(net, 1, "[admin] Not supported update frequency {} ({}) from '{}' ({})", type, freq, this->admin_name, this->admin_version);
673 return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
674 }
675
676 this->update_frequency[type] = freq;
677
678 if (type == ADMIN_UPDATE_CONSOLE) DebugReconsiderSendRemoteMessages();
679
680 return NETWORK_RECV_STATUS_OKAY;
681 }
682
683 NetworkRecvStatus ServerNetworkAdminSocketHandler::Receive_ADMIN_POLL(Packet *p)
684 {
685 if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
686
687 AdminUpdateType type = (AdminUpdateType)p->Recv_uint8();
688 uint32_t d1 = p->Recv_uint32();
689
690 switch (type) {
691 case ADMIN_UPDATE_DATE:
692 /* The admin is requesting the current date. */
693 this->SendDate();
694 break;
695
696 case ADMIN_UPDATE_CLIENT_INFO:
697 /* The admin is requesting client info. */
698 if (d1 == UINT32_MAX) {
699 this->SendClientInfo(nullptr, NetworkClientInfo::GetByClientID(CLIENT_ID_SERVER));
700 for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
701 this->SendClientInfo(cs, cs->GetInfo());
702 }
703 } else {
704 if (d1 == CLIENT_ID_SERVER) {
705 this->SendClientInfo(nullptr, NetworkClientInfo::GetByClientID(CLIENT_ID_SERVER));
706 } else {
707 const NetworkClientSocket *cs = NetworkClientSocket::GetByClientID((ClientID)d1);
708 if (cs != nullptr) this->SendClientInfo(cs, cs->GetInfo());
709 }
710 }
711 break;
712
713 case ADMIN_UPDATE_COMPANY_INFO:
714 /* The admin is asking for company info. */
715 if (d1 == UINT32_MAX) {
716 for (const Company *company : Company::Iterate()) {
717 this->SendCompanyInfo(company);
718 }
719 } else {
720 const Company *company = Company::GetIfValid(d1);
721 if (company != nullptr) this->SendCompanyInfo(company);
722 }
723 break;
724
725 case ADMIN_UPDATE_COMPANY_ECONOMY:
726 /* The admin is requesting economy info. */
727 this->SendCompanyEconomy();
728 break;
729
730 case ADMIN_UPDATE_COMPANY_STATS:
731 /* the admin is requesting company stats. */
732 this->SendCompanyStats();
733 break;
734
735 case ADMIN_UPDATE_CMD_NAMES:
736 /* The admin is requesting the names of DoCommands. */
737 this->SendCmdNames();
738 break;
739
740 default:
741 /* An unsupported "poll" update type. */
742 Debug(net, 1, "[admin] Not supported poll {} ({}) from '{}' ({}).", type, d1, this->admin_name, this->admin_version);
743 return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
744 }
745
746 return NETWORK_RECV_STATUS_OKAY;
747 }
748
749 NetworkRecvStatus ServerNetworkAdminSocketHandler::Receive_ADMIN_CHAT(Packet *p)
750 {
751 if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
752
753 NetworkAction action = (NetworkAction)p->Recv_uint8();
754 DestType desttype = (DestType)p->Recv_uint8();
755 int dest = p->Recv_uint32();
756
757 std::string msg = p->Recv_string(NETWORK_CHAT_LENGTH);
758
759 switch (action) {
760 case NETWORK_ACTION_CHAT:
761 case NETWORK_ACTION_CHAT_CLIENT:
762 case NETWORK_ACTION_CHAT_COMPANY:
763 case NETWORK_ACTION_SERVER_MESSAGE:
764 NetworkServerSendChat(action, desttype, dest, msg, _network_own_client_id, 0, true);
765 break;
766
767 default:
768 Debug(net, 1, "[admin] Invalid chat action {} from admin '{}' ({}).", action, this->admin_name, this->admin_version);
769 return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
770 }
771
772 return NETWORK_RECV_STATUS_OKAY;
773 }
774
775 NetworkRecvStatus ServerNetworkAdminSocketHandler::Receive_ADMIN_EXTERNAL_CHAT(Packet *p)
776 {
777 if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
778
779 std::string source = p->Recv_string(NETWORK_CHAT_LENGTH);
780 TextColour colour = (TextColour)p->Recv_uint16();
781 std::string user = p->Recv_string(NETWORK_CHAT_LENGTH);
782 std::string msg = p->Recv_string(NETWORK_CHAT_LENGTH);
783
784 if (!IsValidConsoleColour(colour)) {
785 Debug(net, 1, "[admin] Not supported chat colour {} ({}, {}, {}) from '{}' ({}).", (uint16_t)colour, source, user, msg, this->admin_name, this->admin_version);
786 return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
787 }
788
789 NetworkServerSendExternalChat(source, colour, user, msg);
790
791 return NETWORK_RECV_STATUS_OKAY;
792 }
793
794 /*
795 * Useful wrapper functions
796 */
797
803 void NetworkAdminClientInfo(const NetworkClientSocket *cs, bool new_client)
804 {
805 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
806 if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO] & ADMIN_FREQUENCY_AUTOMATIC) {
807 as->SendClientInfo(cs, cs->GetInfo());
808 if (new_client) {
809 as->SendClientJoin(cs->client_id);
810 }
811 }
812 }
813 }
814
819 void NetworkAdminClientUpdate(const NetworkClientInfo *ci)
820 {
821 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
822 if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO] & ADMIN_FREQUENCY_AUTOMATIC) {
823 as->SendClientUpdate(ci);
824 }
825 }
826 }
827
832 void NetworkAdminClientQuit(ClientID client_id)
833 {
834 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
835 if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO] & ADMIN_FREQUENCY_AUTOMATIC) {
836 as->SendClientQuit(client_id);
837 }
838 }
839 }
840
846 void NetworkAdminClientError(ClientID client_id, NetworkErrorCode error_code)
847 {
848 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
849 if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO] & ADMIN_FREQUENCY_AUTOMATIC) {
850 as->SendClientError(client_id, error_code);
851 }
852 }
853 }
854
860 void NetworkAdminCompanyInfo(const Company *company, bool new_company)
861 {
862 if (company == nullptr) {
863 Debug(net, 1, "[admin] Empty company given for update");
864 return;
865 }
866
867 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
868 if (as->update_frequency[ADMIN_UPDATE_COMPANY_INFO] != ADMIN_FREQUENCY_AUTOMATIC) continue;
869
870 as->SendCompanyInfo(company);
871 if (new_company) {
872 as->SendCompanyNew(company->index);
873 }
874 }
875 }
876
881 void NetworkAdminCompanyUpdate(const Company *company)
882 {
883 if (company == nullptr) return;
884
885 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
886 if (as->update_frequency[ADMIN_UPDATE_COMPANY_INFO] != ADMIN_FREQUENCY_AUTOMATIC) continue;
887
888 as->SendCompanyUpdate(company);
889 }
890 }
891
897 void NetworkAdminCompanyRemove(CompanyID company_id, AdminCompanyRemoveReason bcrr)
898 {
899 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
900 as->SendCompanyRemove(company_id, bcrr);
901 }
902 }
903
904
908 void NetworkAdminChat(NetworkAction action, DestType desttype, ClientID client_id, const std::string &msg, int64_t data, bool from_admin)
909 {
910 if (from_admin) return;
911
912 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
913 if (as->update_frequency[ADMIN_UPDATE_CHAT] & ADMIN_FREQUENCY_AUTOMATIC) {
914 as->SendChat(action, desttype, client_id, msg, data);
915 }
916 }
917 }
918
925 void NetworkServerSendAdminRcon(AdminIndex admin_index, TextColour colour_code, const std::string_view string)
926 {
927 ServerNetworkAdminSocketHandler::Get(admin_index)->SendRcon(colour_code, string);
928 }
929
935 void NetworkAdminConsole(const std::string_view origin, const std::string_view string)
936 {
937 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
938 if (as->update_frequency[ADMIN_UPDATE_CONSOLE] & ADMIN_FREQUENCY_AUTOMATIC) {
939 as->SendConsole(origin, string);
940 }
941 }
942 }
943
948 void NetworkAdminGameScript(const std::string_view json)
949 {
950 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
951 if (as->update_frequency[ADMIN_UPDATE_GAMESCRIPT] & ADMIN_FREQUENCY_AUTOMATIC) {
952 as->SendGameScript(json);
953 }
954 }
955 }
956
962 void NetworkAdminCmdLogging(const NetworkClientSocket *owner, const CommandPacket *cp)
963 {
964 ClientID client_id = owner == nullptr ? _network_own_client_id : owner->client_id;
965
966 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
967 if (as->update_frequency[ADMIN_UPDATE_CMD_LOGGING] & ADMIN_FREQUENCY_AUTOMATIC) {
968 as->SendCmdLogging(client_id, cp);
969 }
970 }
971 }
972
976 void ServerNetworkAdminSocketHandler::WelcomeAll()
977 {
978 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
979 as->SendWelcome();
980 }
981 }
982
987 void NetworkAdminUpdate(AdminUpdateFrequency freq)
988 {
989 for (ServerNetworkAdminSocketHandler *as : ServerNetworkAdminSocketHandler::IterateActive()) {
990 for (int i = 0; i < ADMIN_UPDATE_END; i++) {
991 if (as->update_frequency[i] & freq) {
992 /* Update the admin for the required details */
993 switch (i) {
994 case ADMIN_UPDATE_DATE:
995 as->SendDate();
996 break;
997
998 case ADMIN_UPDATE_COMPANY_ECONOMY:
999 as->SendCompanyEconomy();
1000 break;
1001
1002 case ADMIN_UPDATE_COMPANY_STATS:
1003 as->SendCompanyStats();
1004 break;
1005
1006 default: NOT_REACHED();
1007 }
1008 }
1009 }
1010 }
1011 }
ServerNetworkAdminSocketHandler::SendPong
NetworkRecvStatus SendPong(uint32_t d1)
Send ping-reply (pong) to admin.
Definition: network_admin.cpp:566
ADMIN_PACKET_SERVER_GAMESCRIPT
@ ADMIN_PACKET_SERVER_GAMESCRIPT
The server gives the admin information from the GameScript in JSON.
Definition: tcp_admin.h:60
NetworkCompanyStats::num_station
uint16_t num_station[NETWORK_VEH_END]
How many stations are there of this type?
Definition: network_type.h:69
CompanyProperties::is_ai
bool is_ai
If true, the company is (also) controlled by the computer (a NoAI program).
Definition: company_base.h:95
NetworkCompanyStats
Simple calculated statistics of a company.
Definition: network_type.h:67
ADMIN_UPDATE_CMD_NAMES
@ ADMIN_UPDATE_CMD_NAMES
The admin would like a list of all DoCommand names.
Definition: tcp_admin.h:84
ADMIN_UPDATE_COMPANY_INFO
@ ADMIN_UPDATE_COMPANY_INFO
Updates about the generic information of companies.
Definition: tcp_admin.h:79
ServerNetworkAdminSocketHandler::Receive_ADMIN_UPDATE_FREQUENCY
NetworkRecvStatus Receive_ADMIN_UPDATE_FREQUENCY(Packet *p) override
Register updates to be sent at certain frequencies (as announced in the PROTOCOL packet): uint16_t Up...
Definition: network_admin.cpp:663
Packet::Send_uint64
void Send_uint64(uint64_t data)
Package a 64 bits integer in the packet.
Definition: packet.cpp:163
Pool::PoolItem<&_networkadminsocket_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:335
NetworkAdminSocketHandler::admin_version
std::string admin_version
Version string of the admin.
Definition: tcp_admin.h:115
NetworkAdminUpdate
void NetworkAdminUpdate(AdminUpdateFrequency freq)
Send (push) updates to the admin network as they have registered for these updates.
Definition: network_admin.cpp:987
NetworkAdminSocketHandler::status
AdminStatus status
Status of this admin.
Definition: tcp_admin.h:116
NetworkAdminChat
void NetworkAdminChat(NetworkAction action, DestType desttype, ClientID client_id, const std::string &msg, int64_t data, bool from_admin)
Send chat to the admin network (if they did opt in for the respective update).
Definition: network_admin.cpp:908
NetworkAdminSocketHandler::CloseConnection
NetworkRecvStatus CloseConnection(bool error=true) override
This will put this socket handler in a close state.
Definition: tcp_admin.cpp:35
Pool::PoolItem<&_company_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:346
NetworkClientInfo::client_name
std::string client_name
Name of the client.
Definition: network_base.h:26
GameCreationSettings::landscape
byte landscape
the landscape we're currently in
Definition: settings_type.h:356
ADMIN_PACKET_SERVER_CLIENT_QUIT
@ ADMIN_PACKET_SERVER_CLIENT_QUIT
The server tells the admin that a client quit.
Definition: tcp_admin.h:47
ServerNetworkAdminSocketHandler::SendError
NetworkRecvStatus SendError(NetworkErrorCode error)
Send an error to the admin.
Definition: network_admin.cpp:135
ServerNetworkAdminSocketHandler::SendRconEnd
NetworkRecvStatus SendRconEnd(const std::string_view command)
Send a notification indicating the rcon command has completed.
Definition: network_admin.cpp:466
ADMIN_UPDATE_CLIENT_INFO
@ ADMIN_UPDATE_CLIENT_INFO
Updates about the information of clients.
Definition: tcp_admin.h:78
CommandPacket::frame
uint32_t frame
the frame in which this packet is executed
Definition: network_internal.h:114
ADMIN_PACKET_SERVER_COMPANY_INFO
@ ADMIN_PACKET_SERVER_COMPANY_INFO
The server gives the admin information about a company.
Definition: tcp_admin.h:50
NetworkClientInfo::client_playas
CompanyID client_playas
As which company is this client playing (CompanyID)
Definition: network_base.h:27
NetworkAdminSocketHandler::admin_name
std::string admin_name
Name of the admin.
Definition: tcp_admin.h:114
ServerNetworkAdminSocketHandler::SendCompanyEconomy
NetworkRecvStatus SendCompanyEconomy()
Send economic information of all companies.
Definition: network_admin.cpp:382
ServerNetworkAdminSocketHandler::update_frequency
AdminUpdateFrequency update_frequency[ADMIN_UPDATE_END]
Admin requested update intervals.
Definition: network_admin.h:40
ADMIN_UPDATE_CONSOLE
@ ADMIN_UPDATE_CONSOLE
The admin would like to have console messages.
Definition: tcp_admin.h:83
ADMIN_PACKET_SERVER_PONG
@ ADMIN_PACKET_SERVER_PONG
The server replies to a ping request from the admin.
Definition: tcp_admin.h:62
NetworkAction
NetworkAction
Actions that can be used for NetworkTextMessage.
Definition: network_type.h:102
ADMIN_UPDATE_CHAT
@ ADMIN_UPDATE_CHAT
The admin would like to have chat messages.
Definition: tcp_admin.h:82
Pool::PoolItem<&_networkadminsocket_pool >::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:234
NetworkPopulateCompanyStats
void NetworkPopulateCompanyStats(NetworkCompanyStats *stats)
Populate the company stats.
Definition: network_server.cpp:1533
ServerNetworkAdminSocketHandler::WelcomeAll
static void WelcomeAll()
Send a Welcome packet to all connected admins.
Definition: network_admin.cpp:976
NETWORK_CHAT_LENGTH
static const uint NETWORK_CHAT_LENGTH
The maximum length of a chat message, in bytes including '\0'.
Definition: config.h:63
ServerNetworkAdminSocketHandler::Receive_ADMIN_JOIN
NetworkRecvStatus Receive_ADMIN_JOIN(Packet *p) override
Join the admin network: string Password the server is expecting for this network.
Definition: network_admin.cpp:630
ADMIN_PACKET_SERVER_NEWGAME
@ ADMIN_PACKET_SERVER_NEWGAME
The server tells the admin its going to start a new game.
Definition: tcp_admin.h:40
ADMIN_FREQUENCY_DAILY
@ ADMIN_FREQUENCY_DAILY
The admin gets information about this on a daily basis.
Definition: tcp_admin.h:93
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:253
ServerNetworkAdminSocketHandler::IterateActive
static Pool::IterateWrapperFiltered< ServerNetworkAdminSocketHandler, ServerNetworkAdminSocketHandlerFilter > IterateActive(size_t from=0)
Returns an iterable ensemble of all active admin sockets.
Definition: network_admin.h:96
ADMIN_PACKET_SERVER_CHAT
@ ADMIN_PACKET_SERVER_CHAT
The server received a chat message and relays it.
Definition: tcp_admin.h:55
ADMIN_PACKET_SERVER_COMPANY_NEW
@ ADMIN_PACKET_SERVER_COMPANY_NEW
The server tells the admin that a new company has started.
Definition: tcp_admin.h:49
ServerNetworkAdminSocketHandler::SendCompanyUpdate
NetworkRecvStatus SendCompanyUpdate(const Company *c)
Send an update about a company.
Definition: network_admin.cpp:346
CeilDiv
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:320
ADMIN_PACKET_SERVER_PROTOCOL
@ ADMIN_PACKET_SERVER_PROTOCOL
The server tells the admin its protocol version.
Definition: tcp_admin.h:38
ADMIN_UPDATE_CMD_LOGGING
@ ADMIN_UPDATE_CMD_LOGGING
The admin would like to have DoCommand information.
Definition: tcp_admin.h:85
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:54
ADMIN_FREQUENCY_MONTHLY
@ ADMIN_FREQUENCY_MONTHLY
The admin gets information about this on a monthly basis.
Definition: tcp_admin.h:95
GetNetworkErrorMsg
StringID GetNetworkErrorMsg(NetworkErrorCode err)
Retrieve the string id of an internal error number.
Definition: network.cpp:298
ADMIN_PACKET_SERVER_COMPANY_STATS
@ ADMIN_PACKET_SERVER_COMPANY_STATS
The server gives the admin some statistics about a company.
Definition: tcp_admin.h:54
NetworkServerSendChat
void NetworkServerSendChat(NetworkAction action, DestType type, int dest, const std::string &msg, ClientID from_id, int64_t data=0, bool from_admin=false)
Send an actual chat message.
Definition: network_server.cpp:1271
NETWORK_CLIENT_NAME_LENGTH
static const uint NETWORK_CLIENT_NAME_LENGTH
The maximum length of a client's name, in bytes including '\0'.
Definition: config.h:60
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
NETWORK_GAME_ADMIN_VERSION
static const byte NETWORK_GAME_ADMIN_VERSION
What version of the admin network do we use?
Definition: config.h:48
ServerNetworkAdminSocketHandler::SendCompanyInfo
NetworkRecvStatus SendCompanyInfo(const Company *c)
Send the admin some information about a company.
Definition: network_admin.cpp:321
ServerNetworkAdminSocketHandler::address
NetworkAddress address
Address of the admin.
Definition: network_admin.h:42
INVALID_ADMIN_ID
static const AdminIndex INVALID_ADMIN_ID
An invalid admin marker.
Definition: network_type.h:64
NetworkAdminClientQuit
void NetworkAdminClientQuit(ClientID client_id)
Notify the admin network that a client quit (if they have opt in for the respective update).
Definition: network_admin.cpp:832
_redirect_console_to_admin
AdminIndex _redirect_console_to_admin
Redirection of the (remote) console to the admin.
Definition: network_admin.cpp:32
_networkadminsocket_pool
NetworkAdminSocketPool _networkadminsocket_pool("NetworkAdminSocket")
The pool with sockets/clients.
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
ServerNetworkAdminSocketHandler::Send
static void Send()
Send the packets for the server sockets.
Definition: network_admin.cpp:102
network_base.h
NetworkAdminClientInfo
void NetworkAdminClientInfo(const NetworkClientSocket *cs, bool new_client)
Notify the admin network of a new client (if they did opt in for the respective update).
Definition: network_admin.cpp:803
GameSettings::game_creation
GameCreationSettings game_creation
settings used during the creation of a game (map)
Definition: settings_type.h:619
Packet::Recv_string
std::string Recv_string(size_t length, StringValidationSettings settings=SVS_REPLACE_WITH_QUESTION_MARK)
Reads characters (bytes) from the packet until it finds a '\0', or reaches a maximum of length charac...
Definition: packet.cpp:408
NetworkAdminConsole
void NetworkAdminConsole(const std::string_view origin, const std::string_view string)
Send console to the admin network (if they did opt in for the respective update).
Definition: network_admin.cpp:935
Pool::MAX_SIZE
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
Definition: pool_type.hpp:84
NetworkClientInfo::GetByClientID
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it's client-identifier.
Definition: network.cpp:114
NetworkAdminGameScript
void NetworkAdminGameScript(const std::string_view json)
Send GameScript JSON to the admin network (if they did opt in for the respective update).
Definition: network_admin.cpp:948
ADMIN_FREQUENCY_QUARTERLY
@ ADMIN_FREQUENCY_QUARTERLY
The admin gets information about this on a quarterly basis.
Definition: tcp_admin.h:96
CommandPacket::company
CompanyID company
company that is executing the command
Definition: network_internal.h:113
ADMIN_STATUS_INACTIVE
@ ADMIN_STATUS_INACTIVE
The admin is not connected nor active.
Definition: tcp_admin.h:70
ADMIN_PACKET_SERVER_DATE
@ ADMIN_PACKET_SERVER_DATE
The server tells the admin what the current game date is.
Definition: tcp_admin.h:43
ADMIN_PACKET_SERVER_ERROR
@ ADMIN_PACKET_SERVER_ERROR
The server tells the admin an error has occurred.
Definition: tcp_admin.h:37
ServerNetworkAdminSocketHandler::SendShutdown
NetworkRecvStatus SendShutdown()
Tell the admin we're shutting down.
Definition: network_admin.cpp:199
Packet::Send_uint32
void Send_uint32(uint32_t data)
Package a 32 bits integer in the packet.
Definition: packet.cpp:150
Packet::Send_uint8
void Send_uint8(uint8_t data)
Package a 8 bits integer in the packet.
Definition: packet.cpp:129
ServerNetworkAdminSocketHandler::connect_time
std::chrono::steady_clock::time_point connect_time
Time of connection.
Definition: network_admin.h:41
CommandPacket
Everything we need to know about a command to be able to execute it.
Definition: network_internal.h:109
MAX_ADMINS
static const AdminIndex MAX_ADMINS
Maximum number of allowed admins.
Definition: network_type.h:62
Packet::Recv_uint32
uint32_t Recv_uint32()
Read a 32 bits integer from the packet.
Definition: packet.cpp:346
ServerNetworkAdminSocketHandler::SendConsole
NetworkRecvStatus SendConsole(const std::string_view origin, const std::string_view command)
Send console output of other clients.
Definition: network_admin.cpp:534
NetworkCompanyStats::num_vehicle
uint16_t num_vehicle[NETWORK_VEH_END]
How many vehicles are there of this type?
Definition: network_type.h:68
IConsoleCmdExec
void IConsoleCmdExec(const std::string &command_string, const uint recurse_count)
Execute a given command passed to us.
Definition: console.cpp:293
CompanyProperties::months_of_bankruptcy
byte months_of_bankruptcy
Number of months that the company is unable to pay its debts.
Definition: company_base.h:81
ServerNetworkAdminSocketHandler::SendCompanyRemove
NetworkRecvStatus SendCompanyRemove(CompanyID company_id, AdminCompanyRemoveReason bcrr)
Tell the admin that a company got removed.
Definition: network_admin.cpp:369
TimerGameCalendar::ConvertYMDToDate
static Date ConvertYMDToDate(Year year, Month month, Day day)
Converts a tuple of Year, Month and Day to a Date.
Definition: timer_game_calendar.cpp:55
CompanyProperties::colour
Colours colour
Company colour.
Definition: company_base.h:72
NetworkAdminSocketHandler
Main socket handler for admin related connections.
Definition: tcp_admin.h:112
ADMIN_PACKET_SERVER_COMPANY_REMOVE
@ ADMIN_PACKET_SERVER_COMPANY_REMOVE
The server tells the admin that a company was removed.
Definition: tcp_admin.h:52
Packet::Send_buffer
void Send_buffer(const std::vector< byte > &data)
Copy a sized byte buffer into the packet.
Definition: packet.cpp:192
NetworkSettings::admin_password
std::string admin_password
password for the admin network
Definition: settings_type.h:317
ADMIN_FREQUENCY_POLL
@ ADMIN_FREQUENCY_POLL
The admin can poll this.
Definition: tcp_admin.h:92
ADMIN_PACKET_SERVER_CLIENT_ERROR
@ ADMIN_PACKET_SERVER_CLIENT_ERROR
The server tells the admin that a client caused an error.
Definition: tcp_admin.h:48
ADMIN_UPDATE_DATE
@ ADMIN_UPDATE_DATE
Updates about the date of the game.
Definition: tcp_admin.h:77
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:55
ServerNetworkAdminSocketHandler::AllowConnection
static bool AllowConnection()
Whether a connection is allowed or not at this moment.
Definition: network_admin.cpp:91
ServerNetworkAdminSocketHandler::SendWelcome
NetworkRecvStatus SendWelcome()
Send a welcome message to the admin.
Definition: network_admin.cpp:170
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:147
ServerNetworkAdminSocketHandler::SendGameScript
NetworkRecvStatus SendGameScript(const std::string_view json)
Send GameScript JSON output.
Definition: network_admin.cpp:555
MAX_COMPANIES
@ MAX_COMPANIES
Maximum number of companies.
Definition: company_type.h:23
ADMIN_UPDATE_COMPANY_STATS
@ ADMIN_UPDATE_COMPANY_STATS
Updates about the statistics of companies.
Definition: tcp_admin.h:81
GameCreationSettings::starting_year
TimerGameCalendar::Year starting_year
starting date
Definition: settings_type.h:341
IsValidConsoleColour
bool IsValidConsoleColour(TextColour c)
Check whether the given TextColour is valid for console usage.
Definition: console_gui.cpp:488
ADMIN_UPDATE_COMPANY_ECONOMY
@ ADMIN_UPDATE_COMPANY_ECONOMY
Updates about the economy of companies.
Definition: tcp_admin.h:80
NetworkTCPSocketHandler::SendPacket
virtual void SendPacket(Packet *packet)
This function puts the packet in the send-queue and it is send as soon as possible.
Definition: tcp.cpp:81
ServerNetworkAdminSocketHandler::~ServerNetworkAdminSocketHandler
~ServerNetworkAdminSocketHandler()
Clear everything related to this admin.
Definition: network_admin.cpp:75
ADMIN_PACKET_SERVER_RCON
@ ADMIN_PACKET_SERVER_RCON
The server's reply to a remove console command.
Definition: tcp_admin.h:56
ServerNetworkAdminSocketHandler::SendClientQuit
NetworkRecvStatus SendClientQuit(ClientID client_id)
Tell the admin that a client quit.
Definition: network_admin.cpp:277
AdminCompanyRemoveReason
AdminCompanyRemoveReason
Reasons for removing a company - communicated to admins.
Definition: tcp_admin.h:103
ADMIN_PACKET_SERVER_CONSOLE
@ ADMIN_PACKET_SERVER_CONSOLE
The server gives the admin the data that got printed to its console.
Definition: tcp_admin.h:57
ADMIN_PACKET_SERVER_CLIENT_UPDATE
@ ADMIN_PACKET_SERVER_CLIENT_UPDATE
The server gives the admin an information update on a client.
Definition: tcp_admin.h:46
network_server.h
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:62
ADMIN_UPDATE_GAMESCRIPT
@ ADMIN_UPDATE_GAMESCRIPT
The admin would like to have gamescript messages.
Definition: tcp_admin.h:86
Packet
Internal entity of a packet.
Definition: packet.h:42
ADMIN_FREQUENCY_ANUALLY
@ ADMIN_FREQUENCY_ANUALLY
The admin gets information about this on a yearly basis.
Definition: tcp_admin.h:97
ServerNetworkAdminSocketHandler::SendCmdNames
NetworkRecvStatus SendCmdNames()
Send the names of the commands.
Definition: network_admin.cpp:577
NetworkAdminCompanyRemove
void NetworkAdminCompanyRemove(CompanyID company_id, AdminCompanyRemoveReason bcrr)
Notify the admin network of a company to be removed (including the reason why).
Definition: network_admin.cpp:897
NETWORK_REVISION_LENGTH
static const uint NETWORK_REVISION_LENGTH
The maximum length of the revision, in bytes including '\0'.
Definition: config.h:58
NetworkCompanyIsPassworded
bool NetworkCompanyIsPassworded(CompanyID company_id)
Check if the company we want to join requires a password.
Definition: network.cpp:209
AdminUpdateType
AdminUpdateType
Update types an admin can register a frequency for.
Definition: tcp_admin.h:76
NetworkClientInfo::client_id
ClientID client_id
Client identifier (same as ClientState->client_id)
Definition: network_base.h:25
ADMIN_PACKET_SERVER_RCON_END
@ ADMIN_PACKET_SERVER_RCON_END
The server indicates that the remote console command has completed.
Definition: tcp_admin.h:61
NETWORK_PASSWORD_LENGTH
static const uint NETWORK_PASSWORD_LENGTH
The maximum length of the password, in bytes including '\0' (must be >= NETWORK_SERVER_ID_LENGTH)
Definition: config.h:59
ServerNetworkAdminSocketHandler::SendNewGame
NetworkRecvStatus SendNewGame()
Tell the admin we started a new game.
Definition: network_admin.cpp:191
Packet::Send_bool
void Send_bool(bool data)
Package a boolean in the packet.
Definition: packet.cpp:120
_network_own_client_id
ClientID _network_own_client_id
Our client identifier.
Definition: network.cpp:65
NetworkAdminCompanyUpdate
void NetworkAdminCompanyUpdate(const Company *company)
Notify the admin network of company updates.
Definition: network_admin.cpp:881
Map::SizeX
static debug_inline uint SizeX()
Get the size of the map along the X.
Definition: map_func.h:270
NetworkSettings::server_name
std::string server_name
name of the server
Definition: settings_type.h:314
CompanyProperties::inaugurated_year
TimerGameEconomy::Year inaugurated_year
Economy year of starting the company.
Definition: company_base.h:79
ADMIN_PACKET_SERVER_CLIENT_JOIN
@ ADMIN_PACKET_SERVER_CLIENT_JOIN
The server tells the admin that a client has joined.
Definition: tcp_admin.h:44
NetworkAddress
Wrapper for (un)resolved network addresses; there's no reason to transform a numeric IP to a string a...
Definition: address.h:28
NETWORK_RCONCOMMAND_LENGTH
static const uint NETWORK_RCONCOMMAND_LENGTH
The maximum length of a rconsole command, in bytes including '\0'.
Definition: config.h:61
Pool::PoolItem<&_networkadminsocket_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:384
ServerNetworkAdminSocketHandler::SendDate
NetworkRecvStatus SendDate()
Tell the admin the date.
Definition: network_admin.cpp:207
ServerNetworkAdminSocketHandler::SendCompanyNew
NetworkRecvStatus SendCompanyNew(CompanyID company_id)
Tell the admin that a new company was founded.
Definition: network_admin.cpp:307
Pool
Base class for all pools.
Definition: pool_type.hpp:80
ADMIN_PACKET_SERVER_CMD_NAMES
@ ADMIN_PACKET_SERVER_CMD_NAMES
The server sends out the names of the DoCommands to the admins.
Definition: tcp_admin.h:58
GameCreationSettings::generation_seed
uint32_t generation_seed
noise seed for world generation
Definition: settings_type.h:340
ClientID
ClientID
'Unique' identifier to be given to clients
Definition: network_type.h:49
ServerNetworkAdminSocketHandler::Receive_ADMIN_QUIT
NetworkRecvStatus Receive_ADMIN_QUIT(Packet *p) override
Notification to the server that this admin is quitting.
Definition: network_admin.cpp:657
ADMIN_PACKET_SERVER_CLIENT_INFO
@ ADMIN_PACKET_SERVER_CLIENT_INFO
The server gives the admin information about a client.
Definition: tcp_admin.h:45
CMD_END
@ CMD_END
Must ALWAYS be on the end of this list!! (period)
Definition: command_type.h:361
Packet::CanWriteToPacket
bool CanWriteToPacket(size_t bytes_to_write)
Is it safe to write to the packet, i.e.
Definition: packet.cpp:99
DestType
DestType
Destination of our chat messages.
Definition: network_type.h:91
ServerNetworkAdminSocketHandler::ServerNetworkAdminSocketHandler
ServerNetworkAdminSocketHandler(SOCKET s)
Sanity check.
Definition: network_admin.cpp:65
CommandPacket::data
CommandDataBuffer data
command parameters.
Definition: network_internal.h:120
SetDParam
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings.cpp:104
ServerNetworkAdminSocketHandler
Class for handling the server side of the game connection.
Definition: network_admin.h:25
NetworkRecvStatus
NetworkRecvStatus
Status of a network client; reasons why a client has quit.
Definition: core.h:22
ServerNetworkAdminSocketHandler::Receive_ADMIN_POLL
NetworkRecvStatus Receive_ADMIN_POLL(Packet *p) override
Poll the server for certain updates, an invalid poll (e.g.
Definition: network_admin.cpp:683
ServerNetworkAdminSocketHandler::SendClientInfo
NetworkRecvStatus SendClientInfo(const NetworkClientSocket *cs, const NetworkClientInfo *ci)
Send an initial set of data from some client's information.
Definition: network_admin.cpp:236
ADMIN_FREQUENCY_AUTOMATIC
@ ADMIN_FREQUENCY_AUTOMATIC
The admin gets information about this when it changes.
Definition: tcp_admin.h:98
NetworkServerSendExternalChat
void NetworkServerSendExternalChat(const std::string &source, TextColour colour, const std::string &user, const std::string &msg)
Send a chat message from external source.
Definition: network_server.cpp:1389
ADMIN_STATUS_ACTIVE
@ ADMIN_STATUS_ACTIVE
The admin is active.
Definition: tcp_admin.h:71
ADMIN_PACKET_SERVER_COMPANY_UPDATE
@ ADMIN_PACKET_SERVER_COMPANY_UPDATE
The server gives the admin an information update on a company.
Definition: tcp_admin.h:51
ServerNetworkAdminSocketHandler::SendProtocol
NetworkRecvStatus SendProtocol()
Send the protocol version to the admin.
Definition: network_admin.cpp:150
GetString
std::string GetString(StringID string)
Resolve the given StringID into a std::string with all the associated DParam lookups and formatting.
Definition: strings.cpp:327
GetCommandName
const char * GetCommandName(Commands cmd)
This function mask the parameter with CMD_ID_MASK and returns the name which belongs to the given com...
Definition: command.cpp:132
ServerNetworkAdminSocketHandler::SendChat
NetworkRecvStatus SendChat(NetworkAction action, DestType desttype, ClientID client_id, const std::string &msg, int64_t data)
Send a chat message.
Definition: network_admin.cpp:448
ServerNetworkAdminSocketHandler::Receive_ADMIN_PING
NetworkRecvStatus Receive_ADMIN_PING(Packet *p) override
Ping the server, requiring the server to reply with a pong packet.
Definition: network_admin.cpp:518
NetworkAddress::GetHostname
const std::string & GetHostname()
Get the hostname; in case it wasn't given the IPv4 dotted representation is given.
Definition: address.cpp:23
Pool::PoolItem<&_networkadminsocket_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:305
ADMIN_PACKET_SERVER_WELCOME
@ ADMIN_PACKET_SERVER_WELCOME
The server welcomes the admin to a game.
Definition: tcp_admin.h:39
ServerNetworkAdminSocketHandler::AcceptConnection
static void AcceptConnection(SOCKET s, const NetworkAddress &address)
Handle the acception of a connection.
Definition: network_admin.cpp:121
ServerNetworkAdminSocketHandler::SendClientUpdate
NetworkRecvStatus SendClientUpdate(const NetworkClientInfo *ci)
Send an update for some client's information.
Definition: network_admin.cpp:260
INSTANTIATE_POOL_METHODS
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
Definition: pool_func.hpp:225
ADMIN_PACKET_SERVER_COMPANY_ECONOMY
@ ADMIN_PACKET_SERVER_COMPANY_ECONOMY
The server gives the admin some economy related company information.
Definition: tcp_admin.h:53
ADMIN_PACKET_SERVER_CMD_LOGGING
@ ADMIN_PACKET_SERVER_CMD_LOGGING
The server gives the admin copies of incoming command packets.
Definition: tcp_admin.h:63
Packet::Send_string
void Send_string(const std::string_view data)
Sends a string over the network.
Definition: packet.cpp:181
NetworkAdminClientUpdate
void NetworkAdminClientUpdate(const NetworkClientInfo *ci)
Notify the admin network of a client update (if they did opt in for the respective update).
Definition: network_admin.cpp:819
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:300
ClientSettings::network
NetworkSettings network
settings related to the network
Definition: settings_type.h:637
OverflowSafeInt< int64_t >
COMPAT_MTU
static const uint16_t COMPAT_MTU
Number of bytes we can pack in a single packet for backward compatibility.
Definition: config.h:46
_network_admins_connected
byte _network_admins_connected
The amount of admins connected.
Definition: network_admin.cpp:35
ServerNetworkAdminSocketHandler::Receive_ADMIN_EXTERNAL_CHAT
NetworkRecvStatus Receive_ADMIN_EXTERNAL_CHAT(Packet *p) override
Send chat from the external source: string Name of the source this message came from.
Definition: network_admin.cpp:775
NETWORK_RECV_STATUS_OKAY
@ NETWORK_RECV_STATUS_OKAY
Everything is okay.
Definition: core.h:23
TimerGameCalendar::date
static Date date
Current date in days (day counter).
Definition: timer_game_calendar.h:34
ADMIN_FREQUENCY_WEEKLY
@ ADMIN_FREQUENCY_WEEKLY
The admin gets information about this on a weekly basis.
Definition: tcp_admin.h:94
Commands
Commands
List of commands.
Definition: command_type.h:187
ServerNetworkAdminSocketHandler::Receive_ADMIN_RCON
NetworkRecvStatus Receive_ADMIN_RCON(Packet *p) override
Execute a command on the servers console: string Command to be executed.
Definition: network_admin.cpp:492
_admin_update_type_frequencies
static const AdminUpdateFrequency _admin_update_type_frequencies[]
Frequencies, which may be registered for a certain update type.
Definition: network_admin.cpp:46
ServerNetworkAdminSocketHandler::Receive_ADMIN_CHAT
NetworkRecvStatus Receive_ADMIN_CHAT(Packet *p) override
Send chat as the server: uint8_t Action such as NETWORK_ACTION_CHAT_CLIENT (see NetworkAction).
Definition: network_admin.cpp:749
NetworkAdminCmdLogging
void NetworkAdminCmdLogging(const NetworkClientSocket *owner, const CommandPacket *cp)
Distribute CommandPacket details over the admin network for logging purposes.
Definition: network_admin.cpp:962
ServerNetworkAdminSocketHandler::Receive_ADMIN_GAMESCRIPT
NetworkRecvStatus Receive_ADMIN_GAMESCRIPT(Packet *p) override
Send a JSON string to the current active GameScript.
Definition: network_admin.cpp:506
Packet::Recv_uint16
uint16_t Recv_uint16()
Read a 16 bits integer from the packet.
Definition: packet.cpp:331
network_admin.h
ServerNetworkAdminSocketHandler::SendCompanyStats
NetworkRecvStatus SendCompanyStats()
Send statistics about the companies.
Definition: network_admin.cpp:413
NETWORK_GAMESCRIPT_JSON_LENGTH
static const uint NETWORK_GAMESCRIPT_JSON_LENGTH
The maximum length of a receiving gamescript json string, in bytes including '\0'.
Definition: config.h:62
ADMIN_AUTHORISATION_TIMEOUT
static const std::chrono::seconds ADMIN_AUTHORISATION_TIMEOUT(10)
The timeout for authorisation of the client.
ADMIN_UPDATE_END
@ ADMIN_UPDATE_END
Must ALWAYS be on the end of this list!! (period)
Definition: tcp_admin.h:87
Company
Definition: company_base.h:116
AdminUpdateFrequency
AdminUpdateFrequency
Update frequencies an admin can register.
Definition: tcp_admin.h:91
CLIENT_ID_SERVER
@ CLIENT_ID_SERVER
Servers always have this ID.
Definition: network_type.h:51
ServerNetworkAdminSocketHandler::SendClientJoin
NetworkRecvStatus SendClientJoin(ClientID client_id)
Tell the admin that a client joined.
Definition: network_admin.cpp:221
DebugReconsiderSendRemoteMessages
void DebugReconsiderSendRemoteMessages()
Reconsider whether we need to send debug messages to either NetworkAdminConsole or IConsolePrint.
Definition: debug.cpp:268
AdminIndex
uint8_t AdminIndex
Indices into the admin tables.
Definition: network_type.h:59
NetworkAdminCompanyInfo
void NetworkAdminCompanyInfo(const Company *company, bool new_company)
Notify the admin network of company details.
Definition: network_admin.cpp:860
NetworkErrorCode
NetworkErrorCode
The error codes we send around in the protocols.
Definition: network_type.h:122
NetworkClientInfo
Container for all information known about a client.
Definition: network_base.h:24
NetworkClientInfo::join_date
TimerGameEconomy::Date join_date
Gamedate the client has joined.
Definition: network_base.h:28
Packet::Send_uint16
void Send_uint16(uint16_t data)
Package a 16 bits integer in the packet.
Definition: packet.cpp:139
Packet::Recv_uint8
uint8_t Recv_uint8()
Read a 8 bits integer from the packet.
Definition: packet.cpp:317
NetworkAdminClientError
void NetworkAdminClientError(ClientID client_id, NetworkErrorCode error_code)
Notify the admin network of a client error (if they have opt in for the respective update).
Definition: network_admin.cpp:846
ServerNetworkAdminSocketHandler::SendRcon
NetworkRecvStatus SendRcon(uint16_t colour, const std::string_view command)
Send the reply of an rcon command.
Definition: network_admin.cpp:481
Map::SizeY
static uint SizeY()
Get the size of the map along the Y.
Definition: map_func.h:279
ServerNetworkAdminSocketHandler::SendClientError
NetworkRecvStatus SendClientError(ClientID client_id, NetworkErrorCode error)
Tell the admin that a client made an error.
Definition: network_admin.cpp:292
ADMIN_PACKET_SERVER_SHUTDOWN
@ ADMIN_PACKET_SERVER_SHUTDOWN
The server tells the admin its shutting down.
Definition: tcp_admin.h:41
CommandPacket::cmd
Commands cmd
command being executed.
Definition: network_internal.h:117
NetworkServerSendAdminRcon
void NetworkServerSendAdminRcon(AdminIndex admin_index, TextColour colour_code, const std::string_view string)
Pass the rcon reply to the admin.
Definition: network_admin.cpp:925
ServerNetworkAdminSocketHandler::SendCmdLogging
NetworkRecvStatus SendCmdLogging(ClientID client_id, const CommandPacket *cp)
Send a command for logging purposes.
Definition: network_admin.cpp:611