OpenTTD Source 20250612-master-gb012d9e3dc
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 "table/strings.h"
27
28#include "../safeguards.h"
29
30
31/* This file handles all the admin network commands. */
32
35
38INSTANTIATE_POOL_METHODS(NetworkAdminSocket)
39
42
44static const std::chrono::seconds ADMIN_AUTHORISATION_TIMEOUT(10);
45
46
62
72
77{
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 = AdminID::Invalid();
80
84 }
85}
86
95
98{
100 if (as->status <= ADMIN_STATUS_AUTHENTICATE && std::chrono::steady_clock::now() > as->connect_time + ADMIN_AUTHORISATION_TIMEOUT) {
101 Debug(net, 2, "[admin] Admin did not send its authorisation within {} seconds", std::chrono::duration_cast<std::chrono::seconds>(ADMIN_AUTHORISATION_TIMEOUT).count());
102 as->CloseConnection(true);
103 continue;
104 }
105 if (as->writable) {
106 as->SendPackets();
107 }
108 }
109}
110
116/* static */ void ServerNetworkAdminSocketHandler::AcceptConnection(SOCKET s, const NetworkAddress &address)
117{
119 as->address = address; // Save the IP of the client
120}
121
122/***********
123 * Sending functions for admin network
124 ************/
125
131{
132 /* Whatever the error might be, authentication (keys) must be released as soon as possible. */
133 this->authentication_handler = nullptr;
134
135 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_ERROR);
136
137 p->Send_uint8(error);
138 this->SendPacket(std::move(p));
139
140 std::string error_message = GetString(GetNetworkErrorMsg(error));
141
142 Debug(net, 1, "[admin] The admin '{}' ({}) made an error and has been disconnected: '{}'", this->admin_name, this->admin_version, error_message);
143
144 return this->CloseConnection(true);
145}
146
149{
151
152 auto p = std::make_unique<Packet>(this, 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].base());
161 }
162
163 p->Send_bool(false);
164 this->SendPacket(std::move(p));
165
166 return this->SendWelcome();
167}
168
171{
172 auto p = std::make_unique<Packet>(this, 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.
182 p->Send_uint16(Map::SizeX());
183 p->Send_uint16(Map::SizeY());
184
185 this->SendPacket(std::move(p));
186
188}
189
192{
193 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_NEWGAME);
194 this->SendPacket(std::move(p));
196}
197
200{
201 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_SHUTDOWN);
202 this->SendPacket(std::move(p));
204}
205
208{
209 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_DATE);
210
211 p->Send_uint32(TimerGameCalendar::date.base());
212 this->SendPacket(std::move(p));
213
215}
216
222{
223 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_CLIENT_JOIN);
224
225 p->Send_uint32(client_id);
226 this->SendPacket(std::move(p));
227
229}
230
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 auto p = std::make_unique<Packet>(this, 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(std::move(p));
251
253}
254
255
261{
262 auto p = std::make_unique<Packet>(this, 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(std::move(p));
269
271}
272
278{
279 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_CLIENT_QUIT);
280
281 p->Send_uint32(client_id);
282 this->SendPacket(std::move(p));
283
285}
286
293{
294 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_CLIENT_ERROR);
295
296 p->Send_uint32(client_id);
297 p->Send_uint8 (error);
298 this->SendPacket(std::move(p));
299
301}
302
308{
309 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_COMPANY_NEW);
310 p->Send_uint8(company_id);
311
312 this->SendPacket(std::move(p));
313
315}
316
322{
323 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_COMPANY_INFO);
324
325 p->Send_uint8 (c->index);
326 p->Send_string(GetString(STR_COMPANY_NAME, c->index));
327 p->Send_string(GetString(STR_PRESIDENT_NAME, c->index));
328 p->Send_uint8 (c->colour);
329 p->Send_bool (true);
330 p->Send_uint32(c->inaugurated_year.base());
331 p->Send_bool (c->is_ai);
332 p->Send_uint8 (CeilDiv(c->months_of_bankruptcy, 3)); // send as quarters_of_bankruptcy
333
334 this->SendPacket(std::move(p));
335
337}
338
339
345{
346 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_COMPANY_UPDATE);
347
348 p->Send_uint8 (c->index);
349 p->Send_string(GetString(STR_COMPANY_NAME, c->index));
350 p->Send_string(GetString(STR_PRESIDENT_NAME, c->index));
351 p->Send_uint8 (c->colour);
352 p->Send_bool (true);
353 p->Send_uint8 (CeilDiv(c->months_of_bankruptcy, 3)); // send as quarters_of_bankruptcy
354
355 this->SendPacket(std::move(p));
356
358}
359
366{
367 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_COMPANY_REMOVE);
368
369 p->Send_uint8(company_id);
370 p->Send_uint8(acrr);
371
372 this->SendPacket(std::move(p));
373
375}
376
379{
380 for (const Company *company : Company::Iterate()) {
381 /* Get the income. */
382 Money income = -std::reduce(std::begin(company->yearly_expenses[0]), std::end(company->yearly_expenses[0]));
383
384 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_COMPANY_ECONOMY);
385
386 p->Send_uint8(company->index);
387
388 /* Current information. */
389 p->Send_uint64(company->money);
390 p->Send_uint64(company->current_loan);
391 p->Send_uint64(income);
392 p->Send_uint16(static_cast<uint16_t>(std::min<uint64_t>(UINT16_MAX, company->cur_economy.delivered_cargo.GetSum<OverflowSafeInt64>())));
393
394 /* Send stats for the last 2 quarters. */
395 for (uint i = 0; i < 2; i++) {
396 p->Send_uint64(company->old_economy[i].company_value);
397 p->Send_uint16(company->old_economy[i].performance_history);
398 p->Send_uint16(static_cast<uint16_t>(std::min<uint64_t>(UINT16_MAX, company->old_economy[i].delivered_cargo.GetSum<OverflowSafeInt64>())));
399 }
400
401 this->SendPacket(std::move(p));
402 }
403
404
406}
407
410{
411 /* Fetch the latest version of the stats. */
413
414 /* Go through all the companies. */
415 for (const Company *company : Company::Iterate()) {
416 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_COMPANY_STATS);
417
418 /* Send the information. */
419 p->Send_uint8(company->index);
420
421 for (uint i = 0; i < NETWORK_VEH_END; i++) {
422 p->Send_uint16(company_stats[company->index].num_vehicle[i]);
423 }
424
425 for (uint i = 0; i < NETWORK_VEH_END; i++) {
426 p->Send_uint16(company_stats[company->index].num_station[i]);
427 }
428
429 this->SendPacket(std::move(p));
430 }
431
433}
434
443NetworkRecvStatus ServerNetworkAdminSocketHandler::SendChat(NetworkAction action, DestType desttype, ClientID client_id, std::string_view msg, int64_t data)
444{
445 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_CHAT);
446
447 p->Send_uint8 (action);
448 p->Send_uint8 (desttype);
449 p->Send_uint32(client_id);
450 p->Send_string(msg);
451 p->Send_uint64(data);
452
453 this->SendPacket(std::move(p));
455}
456
462{
463 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_RCON_END);
464
465 p->Send_string(command);
466 this->SendPacket(std::move(p));
467
469}
470
476NetworkRecvStatus ServerNetworkAdminSocketHandler::SendRcon(uint16_t colour, std::string_view result)
477{
478 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_RCON);
479
480 p->Send_uint16(colour);
481 p->Send_string(result);
482 this->SendPacket(std::move(p));
483
485}
486
488{
489 if (this->status <= ADMIN_STATUS_AUTHENTICATE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
490
491 std::string command = p.Recv_string(NETWORK_RCONCOMMAND_LENGTH);
492
493 Debug(net, 3, "[admin] Rcon command from '{}' ({}): {}", this->admin_name, this->admin_version, command);
494
496 IConsoleCmdExec(command);
497 _redirect_console_to_admin = AdminID::Invalid();
498 return this->SendRconEnd(command);
499}
500
502{
503 if (this->status <= ADMIN_STATUS_AUTHENTICATE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
504
505 std::string json = p.Recv_string(NETWORK_GAMESCRIPT_JSON_LENGTH);
506
507 Debug(net, 6, "[admin] GameScript JSON from '{}' ({}): {}", this->admin_name, this->admin_version, json);
508
509 Game::NewEvent(new ScriptEventAdminPort(json));
511}
512
514{
515 if (this->status <= ADMIN_STATUS_AUTHENTICATE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
516
517 uint32_t d1 = p.Recv_uint32();
518
519 Debug(net, 6, "[admin] Ping from '{}' ({}): {}", this->admin_name, this->admin_version, d1);
520
521 return this->SendPong(d1);
522}
523
529NetworkRecvStatus ServerNetworkAdminSocketHandler::SendConsole(std::string_view origin, std::string_view string)
530{
531 /* If the length of both strings, plus the 2 '\0' terminations and 3 bytes of the packet
532 * are bigger than the MTU, just ignore the message. Better safe than sorry. It should
533 * never occur though as the longest strings are chat messages, which are still 30%
534 * smaller than COMPAT_MTU. */
535 if (origin.size() + string.size() + 2 + 3 >= COMPAT_MTU) return NETWORK_RECV_STATUS_OKAY;
536
537 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_CONSOLE);
538
539 p->Send_string(origin);
540 p->Send_string(string);
541 this->SendPacket(std::move(p));
542
544}
545
551{
552 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_GAMESCRIPT);
553
554 p->Send_string(json);
555 this->SendPacket(std::move(p));
556
558}
559
562{
563 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_PONG);
564
565 p->Send_uint32(d1);
566 this->SendPacket(std::move(p));
567
569}
570
573{
574 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_CMD_NAMES);
575
576 for (uint16_t i = 0; i < CMD_END; i++) {
577 std::string_view cmdname = GetCommandName(static_cast<Commands>(i));
578
579 /* Should COMPAT_MTU be exceeded, start a new packet
580 * (magic 5: 1 bool "more data" and one uint16_t "command id", one
581 * byte for string '\0' termination and 1 bool "no more data" */
582 if (!p->CanWriteToPacket(cmdname.size() + 5)) {
583 p->Send_bool(false);
584 this->SendPacket(std::move(p));
585
586 p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_CMD_NAMES);
587 }
588
589 p->Send_bool(true);
590 p->Send_uint16(i);
591 p->Send_string(cmdname);
592 }
593
594 /* Marker to notify the end of the packet has been reached. */
595 p->Send_bool(false);
596 this->SendPacket(std::move(p));
597
599}
600
607{
608 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_CMD_LOGGING);
609
610 p->Send_uint32(client_id);
611 p->Send_uint8 (cp.company);
612 p->Send_uint16(cp.cmd);
613 p->Send_buffer(cp.data);
614 p->Send_uint32(cp.frame);
615
616 this->SendPacket(std::move(p));
617
619}
620
621/***********
622 * Receiving functions
623 ************/
624
626{
627 if (this->status != ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
628
630 /* You're not authorized to login using this method. */
631 return this->SendError(NETWORK_ERROR_NOT_AUTHORIZED);
632 }
633
634 std::string password = p.Recv_string(NETWORK_PASSWORD_LENGTH);
635
637 _settings_client.network.admin_password.compare(password) != 0) {
638 /* Password is invalid */
639 return this->SendError(NETWORK_ERROR_WRONG_PASSWORD);
640 }
641
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 Debug(net, 3, "[admin] '{}' ({}) has connected", this->admin_name, this->admin_version);
651
652 return this->SendProtocol();
653}
654
656{
657 /* The admin is leaving nothing else to do */
658 return this->CloseConnection();
659}
660
662{
663 if (this->status <= ADMIN_STATUS_AUTHENTICATE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
664
667
668 if (type >= ADMIN_UPDATE_END || !_admin_update_type_frequencies[type].All(freq)) {
669 /* The server does not know of this UpdateType. */
670 Debug(net, 1, "[admin] Not supported update frequency {} ({}) from '{}' ({})", type, freq, this->admin_name, this->admin_version);
671 return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
672 }
673
674 this->update_frequency[type] = freq;
675
677
679}
680
682{
683 if (this->status <= ADMIN_STATUS_AUTHENTICATE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
684
686 uint32_t d1 = p.Recv_uint32();
687
688 switch (type) {
690 /* The admin is requesting the current date. */
691 this->SendDate();
692 break;
693
695 /* The admin is requesting client info. */
696 if (d1 == UINT32_MAX) {
698 for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
699 this->SendClientInfo(cs, cs->GetInfo());
700 }
701 } else {
702 if (d1 == CLIENT_ID_SERVER) {
704 } else {
705 const NetworkClientSocket *cs = NetworkClientSocket::GetByClientID((ClientID)d1);
706 if (cs != nullptr) this->SendClientInfo(cs, cs->GetInfo());
707 }
708 }
709 break;
710
712 /* The admin is asking for company info. */
713 if (d1 == UINT32_MAX) {
714 for (const Company *company : Company::Iterate()) {
715 this->SendCompanyInfo(company);
716 }
717 } else {
718 const Company *company = Company::GetIfValid(d1);
719 if (company != nullptr) this->SendCompanyInfo(company);
720 }
721 break;
722
724 /* The admin is requesting economy info. */
725 this->SendCompanyEconomy();
726 break;
727
729 /* the admin is requesting company stats. */
730 this->SendCompanyStats();
731 break;
732
734 /* The admin is requesting the names of DoCommands. */
735 this->SendCmdNames();
736 break;
737
738 default:
739 /* An unsupported "poll" update type. */
740 Debug(net, 1, "[admin] Not supported poll {} ({}) from '{}' ({}).", type, d1, this->admin_name, this->admin_version);
741 return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
742 }
743
745}
746
748{
749 if (this->status <= ADMIN_STATUS_AUTHENTICATE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
750
752 DestType desttype = (DestType)p.Recv_uint8();
753 int dest = p.Recv_uint32();
754
755 std::string msg = p.Recv_string(NETWORK_CHAT_LENGTH);
756
757 switch (action) {
758 case NETWORK_ACTION_CHAT:
759 case NETWORK_ACTION_CHAT_CLIENT:
760 case NETWORK_ACTION_CHAT_COMPANY:
761 case NETWORK_ACTION_SERVER_MESSAGE:
762 NetworkServerSendChat(action, desttype, dest, msg, _network_own_client_id, 0, true);
763 break;
764
765 default:
766 Debug(net, 1, "[admin] Invalid chat action {} from admin '{}' ({}).", action, this->admin_name, this->admin_version);
767 return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
768 }
769
771}
772
774{
775 if (this->status <= ADMIN_STATUS_AUTHENTICATE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
776
777 std::string source = p.Recv_string(NETWORK_CHAT_LENGTH);
778 TextColour colour = (TextColour)p.Recv_uint16();
779 std::string user = p.Recv_string(NETWORK_CHAT_LENGTH);
780 std::string msg = p.Recv_string(NETWORK_CHAT_LENGTH);
781
782 if (!IsValidConsoleColour(colour)) {
783 Debug(net, 1, "[admin] Not supported chat colour {} ({}, {}, {}) from '{}' ({}).", (uint16_t)colour, source, user, msg, this->admin_name, this->admin_version);
784 return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
785 }
786
787 NetworkServerSendExternalChat(source, colour, user, msg);
788
790}
791
792/*
793 * Secure authentication send and receive methods.
794 */
795
797{
798 if (this->status != ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
799
803
804 /* Always exclude key exchange only, as that provides no credential checking. */
806
807 if (this->admin_name.empty() || this->admin_version.empty()) {
808 /* No name or version supplied. */
809 return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
810 }
811
813 if (!handler->CanBeUsed()) return this->SendError(NETWORK_ERROR_NO_AUTHENTICATION_METHOD_AVAILABLE);
814
815 this->authentication_handler = std::move(handler);
816 Debug(net, 3, "[admin] '{}' ({}) has connected", this->admin_name, this->admin_version);
817
818 return this->SendAuthRequest();
819}
820
821NetworkRecvStatus ServerNetworkAdminSocketHandler::SendAuthRequest()
822{
824
825 Debug(net, 6, "[admin] '{}' ({}) authenticating using {}", this->admin_name, this->admin_version, this->authentication_handler->GetName());
826
827 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_AUTH_REQUEST);
828 this->authentication_handler->SendRequest(*p);
829
830 this->SendPacket(std::move(p));
831
833}
834
835NetworkRecvStatus ServerNetworkAdminSocketHandler::SendEnableEncryption()
836{
837 if (this->status != ADMIN_STATUS_AUTHENTICATE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
838
839 auto p = std::make_unique<Packet>(this, ADMIN_PACKET_SERVER_ENABLE_ENCRYPTION);
840 this->authentication_handler->SendEnableEncryption(*p);
841 this->SendPacket(std::move(p));
842
844}
845
847{
848 if (this->status != ADMIN_STATUS_AUTHENTICATE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
849
850 switch (this->authentication_handler->ReceiveResponse(p)) {
852 Debug(net, 3, "[admin] '{}' ({}) authenticated", this->admin_name, this->admin_version);
853
854 this->SendEnableEncryption();
855
856 this->receive_encryption_handler = this->authentication_handler->CreateClientToServerEncryptionHandler();
857 this->send_encryption_handler = this->authentication_handler->CreateServerToClientEncryptionHandler();
858 this->authentication_handler = nullptr;
859 return this->SendProtocol();
860
862 Debug(net, 6, "[admin] '{}' ({}) authentication failed, trying next method", this->admin_name, this->admin_version);
863 return this->SendAuthRequest();
864
866 default:
867 Debug(net, 3, "[admin] '{}' ({}) authentication failed", this->admin_name, this->admin_version);
868 return this->SendError(NETWORK_ERROR_WRONG_PASSWORD);
869 }
870}
871
872/*
873 * Useful wrapper functions
874 */
875
881void NetworkAdminClientInfo(const NetworkClientSocket *cs, bool new_client)
882{
884 if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO].Test(AdminUpdateFrequency::Automatic)) {
885 as->SendClientInfo(cs, cs->GetInfo());
886 if (new_client) {
887 as->SendClientJoin(cs->client_id);
888 }
889 }
890 }
891}
892
898{
900 if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO].Test(AdminUpdateFrequency::Automatic)) {
901 as->SendClientUpdate(ci);
902 }
903 }
904}
905
911{
913 if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO].Test(AdminUpdateFrequency::Automatic)) {
914 as->SendClientQuit(client_id);
915 }
916 }
917}
918
925{
927 if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO].Test(AdminUpdateFrequency::Automatic)) {
928 as->SendClientError(client_id, error_code);
929 }
930 }
931}
932
937void NetworkAdminCompanyNew(const Company *company)
938{
939 if (company == nullptr) {
940 Debug(net, 1, "[admin] Empty company given for update");
941 return;
942 }
943
945 if (as->update_frequency[ADMIN_UPDATE_COMPANY_INFO] != AdminUpdateFrequency::Automatic) continue;
946
947 as->SendCompanyNew(company->index);
948 as->SendCompanyInfo(company);
949 }
950}
951
957{
958 if (company == nullptr) return;
959
961 if (as->update_frequency[ADMIN_UPDATE_COMPANY_INFO] != AdminUpdateFrequency::Automatic) continue;
962
963 as->SendCompanyUpdate(company);
964 }
965}
966
973{
975 as->SendCompanyRemove(company_id, bcrr);
976 }
977}
978
979
983void NetworkAdminChat(NetworkAction action, DestType desttype, ClientID client_id, std::string_view msg, int64_t data, bool from_admin)
984{
985 if (from_admin) return;
986
988 if (as->update_frequency[ADMIN_UPDATE_CHAT].Test(AdminUpdateFrequency::Automatic)) {
989 as->SendChat(action, desttype, client_id, msg, data);
990 }
991 }
992}
993
1000void NetworkServerSendAdminRcon(AdminID admin_index, TextColour colour_code, std::string_view string)
1001{
1002 ServerNetworkAdminSocketHandler::Get(admin_index)->SendRcon(colour_code, string);
1003}
1004
1010void NetworkAdminConsole(std::string_view origin, std::string_view string)
1011{
1013 if (as->update_frequency[ADMIN_UPDATE_CONSOLE].Test(AdminUpdateFrequency::Automatic)) {
1014 as->SendConsole(origin, string);
1015 }
1016 }
1017}
1018
1023void NetworkAdminGameScript(std::string_view json)
1024{
1026 if (as->update_frequency[ADMIN_UPDATE_GAMESCRIPT].Test(AdminUpdateFrequency::Automatic)) {
1027 as->SendGameScript(json);
1028 }
1029 }
1030}
1031
1037void NetworkAdminCmdLogging(const NetworkClientSocket *owner, const CommandPacket &cp)
1038{
1039 ClientID client_id = owner == nullptr ? _network_own_client_id : owner->client_id;
1040
1042 if (as->update_frequency[ADMIN_UPDATE_CMD_LOGGING].Test(AdminUpdateFrequency::Automatic)) {
1043 as->SendCmdLogging(client_id, cp);
1044 }
1045 }
1046}
1047
1057
1063{
1065 for (int i = 0; i < ADMIN_UPDATE_END; i++) {
1066 if (as->update_frequency[i].Test(freq)) {
1067 /* Update the admin for the required details */
1068 switch (i) {
1069 case ADMIN_UPDATE_DATE:
1070 as->SendDate();
1071 break;
1072
1074 as->SendCompanyEconomy();
1075 break;
1076
1078 as->SendCompanyStats();
1079 break;
1080
1081 default: NOT_REACHED();
1082 }
1083 }
1084 }
1085 }
1086}
Enum-as-bit-set wrapper.
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Wrapper for (un)resolved network addresses; there's no reason to transform a numeric IP to a string a...
Definition address.h:28
Main socket handler for admin related connections.
Definition tcp_admin.h:117
NetworkRecvStatus CloseConnection(bool error=true) override
This will put this socket handler in a close state.
Definition tcp_admin.cpp:26
AdminStatus status
Status of this admin.
Definition tcp_admin.h:121
std::string admin_version
Version string of the admin.
Definition tcp_admin.h:120
std::string admin_name
Name of the admin.
Definition tcp_admin.h:119
Default implementation for the authorized key handler.
Default implementation of the password provider.
static std::unique_ptr< NetworkAuthenticationServerHandler > Create(const NetworkAuthenticationPasswordProvider *password_provider, const NetworkAuthenticationAuthorizedKeyHandler *authorized_key_handler, NetworkAuthenticationMethodMask client_supported_method_mask={NetworkAuthenticationMethod::X25519_KeyExchangeOnly, NetworkAuthenticationMethod::X25519_PAKE, NetworkAuthenticationMethod::X25519_AuthorizedKey})
Create a NetworkAuthenticationServerHandler.
@ RetryNextMethod
The client failed to authenticate, but there is another method to try.
@ NotAuthenticated
All authentications for this handler have been exhausted.
@ Authenticated
The client was authenticated successfully.
std::unique_ptr< class NetworkEncryptionHandler > send_encryption_handler
The handler for encrypting sent packets.
Definition core.h:50
std::unique_ptr< class NetworkEncryptionHandler > receive_encryption_handler
The handler for decrypting received packets.
Definition core.h:49
virtual void SendPacket(std::unique_ptr< Packet > &&packet)
This function puts the packet in the send-queue and it is send as soon as possible.
Definition tcp.cpp:58
A sort-of mixin that adds 'at(pos)' and 'operator[](pos)' implementations for 'ConvertibleThroughBase...
Class for handling the server side of the game connection.
static void Send()
Send the packets for the server sockets.
NetworkRecvStatus SendGameScript(std::string_view json)
Send GameScript JSON output.
NetworkRecvStatus SendPong(uint32_t d1)
Send ping-reply (pong) to admin.
NetworkRecvStatus SendDate()
Tell the admin the date.
NetworkRecvStatus Receive_ADMIN_JOIN_SECURE(Packet &p) override
Join the admin network using a secure authentication method: string Name of the application being use...
NetworkRecvStatus SendClientUpdate(const NetworkClientInfo *ci)
Send an update for some client's information.
NetworkRecvStatus SendClientInfo(const NetworkClientSocket *cs, const NetworkClientInfo *ci)
Send an initial set of data from some client's information.
NetworkRecvStatus SendRconEnd(std::string_view command)
Send a notification indicating the rcon command has completed.
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...
NetworkRecvStatus SendNewGame()
Tell the admin we started a new game.
NetworkRecvStatus SendCompanyRemove(CompanyID company_id, AdminCompanyRemoveReason bcrr)
Tell the admin that a company got removed.
NetworkRecvStatus Receive_ADMIN_RCON(Packet &p) override
Execute a command on the servers console: string Command to be executed.
std::array< AdminUpdateFrequencies, ADMIN_UPDATE_END > update_frequency
Admin requested update intervals.
NetworkRecvStatus SendClientError(ClientID client_id, NetworkErrorCode error)
Tell the admin that a client made an error.
NetworkRecvStatus SendCmdNames()
Send the names of the commands.
NetworkRecvStatus Receive_ADMIN_POLL(Packet &p) override
Poll the server for certain updates, an invalid poll (e.g.
NetworkRecvStatus Receive_ADMIN_JOIN(Packet &p) override
Join the admin network using an unsecured password exchange: string Unsecured password the server is ...
NetworkRecvStatus SendShutdown()
Tell the admin we're shutting down.
NetworkRecvStatus SendCompanyStats()
Send statistics about the companies.
NetworkRecvStatus SendWelcome()
Send a welcome message to the admin.
NetworkRecvStatus SendCompanyInfo(const Company *c)
Send the admin some information about a company.
static void WelcomeAll()
Send a Welcome packet to all connected admins.
static void AcceptConnection(SOCKET s, const NetworkAddress &address)
Handle the acception of a connection.
NetworkRecvStatus SendCmdLogging(ClientID client_id, const CommandPacket &cp)
Send a command for logging purposes.
std::unique_ptr< NetworkAuthenticationServerHandler > authentication_handler
The handler for the authentication.
static bool AllowConnection()
Whether a connection is allowed or not at this moment.
NetworkRecvStatus Receive_ADMIN_CHAT(Packet &p) override
Send chat as the server: uint8_t Action such as NETWORK_ACTION_CHAT_CLIENT (see NetworkAction).
static Pool::IterateWrapperFiltered< ServerNetworkAdminSocketHandler, ServerNetworkAdminSocketHandlerFilter > IterateActive(size_t from=0)
Returns an iterable ensemble of all active admin sockets.
NetworkRecvStatus SendRcon(uint16_t colour, std::string_view command)
Send the reply of an rcon command.
NetworkRecvStatus SendConsole(std::string_view origin, std::string_view command)
Send console output of other clients.
NetworkRecvStatus SendCompanyEconomy()
Send economic information of all companies.
NetworkRecvStatus Receive_ADMIN_AUTH_RESPONSE(Packet &p) override
Admin responds to ADMIN_PACKET_SERVER_AUTH_REQUEST with the appropriate data given the agreed upon Ne...
NetworkRecvStatus SendChat(NetworkAction action, DestType desttype, ClientID client_id, std::string_view msg, int64_t data)
Send a chat message.
NetworkRecvStatus SendCompanyUpdate(const Company *c)
Send an update about a company.
NetworkAddress address
Address of the admin.
NetworkRecvStatus SendClientQuit(ClientID client_id)
Tell the admin that a client quit.
NetworkRecvStatus SendCompanyNew(CompanyID company_id)
Tell the admin that a new company was founded.
NetworkRecvStatus Receive_ADMIN_GAMESCRIPT(Packet &p) override
Send a JSON string to the current active GameScript.
NetworkRecvStatus SendProtocol()
Send the protocol version to the admin.
NetworkRecvStatus SendClientJoin(ClientID client_id)
Tell the admin that a client joined.
std::chrono::steady_clock::time_point connect_time
Time of connection.
NetworkRecvStatus Receive_ADMIN_PING(Packet &p) override
Ping the server, requiring the server to reply with a pong packet.
NetworkRecvStatus Receive_ADMIN_EXTERNAL_CHAT(Packet &p) override
Send chat from the external source: string Name of the source this message came from.
NetworkRecvStatus Receive_ADMIN_QUIT(Packet &p) override
Notification to the server that this admin is quitting.
~ServerNetworkAdminSocketHandler()
Clear everything related to this admin.
ServerNetworkAdminSocketHandler(SOCKET s)
Sanity check.
NetworkRecvStatus SendError(NetworkErrorCode error)
Send an error to the admin.
static Date ConvertYMDToDate(Year year, Month month, Day day)
Converts a tuple of Year, Month and Day to a Date.
static Date date
Current date in days (day counter).
std::string_view 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
Commands
List of commands.
@ CMD_END
Must ALWAYS be on the end of this list!! (period)
static const uint NETWORK_GAMESCRIPT_JSON_LENGTH
The maximum length of a receiving gamescript json string, in bytes including '\0'.
Definition config.h:60
static const uint NETWORK_CLIENT_NAME_LENGTH
The maximum length of a client's name, in bytes including '\0'.
Definition config.h:58
static const uint NETWORK_CHAT_LENGTH
The maximum length of a chat message, in bytes including '\0'.
Definition config.h:61
static const size_t COMPAT_MTU
Number of bytes we can pack in a single packet for backward compatibility.
Definition config.h:46
static const uint NETWORK_REVISION_LENGTH
The maximum length of the revision, in bytes including '\0'.
Definition config.h:56
static const uint NETWORK_RCONCOMMAND_LENGTH
The maximum length of a rconsole command, in bytes including '\0'.
Definition config.h:59
static const uint NETWORK_PASSWORD_LENGTH
The maximum length of the password, in bytes including '\0'.
Definition config.h:57
static const uint8_t NETWORK_GAME_ADMIN_VERSION
What version of the admin network do we use?
Definition config.h:48
void IConsoleCmdExec(std::string_view command_string, const uint recurse_count)
Execute a given command passed to us.
Definition console.cpp:269
bool IsValidConsoleColour(TextColour c)
Check whether the given TextColour is valid for console usage.
NetworkRecvStatus
Status of a network client; reasons why a client has quit.
Definition core.h:23
@ NETWORK_RECV_STATUS_OKAY
Everything is okay.
Definition core.h:24
void DebugReconsiderSendRemoteMessages()
Reconsider whether we need to send debug messages to either NetworkAdminConsole or IConsolePrint.
Definition debug.cpp:259
#define Debug(category, level, format_string,...)
Output a line of debugging information.
Definition debug.h:37
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23)
Definition enum_type.hpp:17
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition gfx_type.h:302
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
StringID GetNetworkErrorMsg(NetworkErrorCode err)
Retrieve the string id of an internal error number.
Definition network.cpp:311
bool _network_dedicated
are we a dedicated server?
Definition network.cpp:70
ClientID _network_own_client_id
Our client identifier.
Definition network.cpp:72
void NetworkAdminClientUpdate(const NetworkClientInfo *ci)
Notify the admin network of a client update (if they did opt in for the respective update).
void NetworkAdminClientQuit(ClientID client_id)
Notify the admin network that a client quit (if they have opt in for the respective update).
void NetworkAdminChat(NetworkAction action, DestType desttype, ClientID client_id, std::string_view msg, int64_t data, bool from_admin)
Send chat to the admin network (if they did opt in for the respective update).
void NetworkAdminCompanyUpdate(const Company *company)
Notify the admin network of company updates.
void NetworkAdminUpdate(AdminUpdateFrequency freq)
Send (push) updates to the admin network as they have registered for these updates.
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).
void NetworkAdminCmdLogging(const NetworkClientSocket *owner, const CommandPacket &cp)
Distribute CommandPacket details over the admin network for logging purposes.
void NetworkServerSendAdminRcon(AdminID admin_index, TextColour colour_code, std::string_view string)
Pass the rcon reply to the admin.
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).
void NetworkAdminConsole(std::string_view origin, std::string_view string)
Send console to the admin network (if they did opt in for the respective update).
void NetworkAdminGameScript(std::string_view json)
Send GameScript JSON to the admin network (if they did opt in for the respective update).
void NetworkAdminCompanyNew(const Company *company)
Notify the admin network of a new company.
static NetworkAuthenticationDefaultAuthorizedKeyHandler _admin_authorized_key_handler(_settings_client.network.admin_authorized_keys)
Provides the authorized key handling for the game authentication.
static const AdminUpdateFrequencies _admin_update_type_frequencies[]
Frequencies, which may be registered for a certain update type.
static NetworkAuthenticationDefaultPasswordProvider _admin_password_provider(_settings_client.network.admin_password)
Provides the password validation for the game's password.
NetworkAdminSocketPool _networkadminsocket_pool("NetworkAdminSocket")
The pool with sockets/clients.
void NetworkAdminCompanyRemove(CompanyID company_id, AdminCompanyRemoveReason bcrr)
Notify the admin network of a company to be removed (including the reason why).
AdminID _redirect_console_to_admin
Redirection of the (remote) console to the admin.
static const std::chrono::seconds ADMIN_AUTHORISATION_TIMEOUT(10)
The timeout for authorisation of the client.
Server part of the admin network protocol.
AdminID _redirect_console_to_admin
Redirection of the (remote) console to the admin.
Base core network types and some helper functions to access them.
@ X25519_KeyExchangeOnly
No actual authentication is taking place, just perform a x25519 key exchange. This method is not supp...
void NetworkServerSendExternalChat(std::string_view source, TextColour colour, std::string_view user, std::string_view msg)
Send a chat message from external source.
NetworkCompanyStatsArray NetworkGetCompanyStats()
Get the company stats.
void NetworkServerSendChat(NetworkAction action, DestType type, int dest, std::string_view msg, ClientID from_id, int64_t data=0, bool from_admin=false)
Send an actual chat message.
Server part of the network protocol.
DestType
Destination of our chat messages.
NetworkErrorCode
The error codes we send around in the protocols.
NetworkAction
Actions that can be used for NetworkTextMessage.
ClientID
'Unique' identifier to be given to clients
@ CLIENT_ID_SERVER
Servers always have this ID.
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:61
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:60
#define lengthof(array)
Return the length of an fixed size array.
Definition stdafx.h:271
std::string GetString(StringID string)
Resolve the given StringID into a std::string with formatting but no parameters.
Definition strings.cpp:415
NetworkSettings network
settings related to the network
Everything we need to know about a command to be able to execute it.
CommandDataBuffer data
command parameters.
uint32_t frame
the frame in which this packet is executed
CompanyID company
company that is executing the command
Commands cmd
command being executed.
uint8_t months_of_bankruptcy
Number of months that the company is unable to pay its debts.
bool is_ai
If true, the company is (also) controlled by the computer (a NoAI program).
TimerGameEconomy::Year inaugurated_year
Economy year of starting the company.
Colours colour
Company colour.
LandscapeType landscape
the landscape we're currently in
TimerGameCalendar::Year starting_year
starting date
uint32_t generation_seed
noise seed for world generation
GameCreationSettings game_creation
settings used during the creation of a game (map)
static uint SizeY()
Get the size of the map along the Y.
Definition map_func.h:278
static debug_inline uint SizeX()
Get the size of the map along the X.
Definition map_func.h:269
Container for all information known about a client.
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it's client-identifier.
Definition network.cpp:118
TimerGameEconomy::Date join_date
Gamedate the client has joined.
CompanyID client_playas
As which company is this client playing (CompanyID)
ClientID client_id
Client identifier (same as ClientState->client_id)
std::string client_name
Name of the client.
bool allow_insecure_admin_login
Whether to allow logging in as admin using the insecure old JOIN packet.
std::string admin_password
password for the admin network
std::string server_name
name of the server
Internal entity of a packet.
Definition packet.h:43
uint16_t Recv_uint16()
Read a 16 bits integer from the packet.
Definition packet.cpp:332
uint32_t Recv_uint32()
Read a 32 bits integer from the packet.
Definition packet.cpp:347
std::string Recv_string(size_t length, StringValidationSettings settings=StringValidationSetting::ReplaceWithQuestionMark)
Reads characters (bytes) from the packet until it finds a '\0', or reaches a maximum of length charac...
Definition packet.cpp:425
uint8_t Recv_uint8()
Read a 8 bits integer from the packet.
Definition packet.cpp:318
Templated helper to make a PoolID a single POD value.
Definition pool_type.hpp:43
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
static Titem * Get(auto index)
Returns Titem with given index.
Tindex index
Index of this pool item.
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
static Titem * GetIfValid(auto index)
Returns Titem with given index.
Base class for all pools.
@ ADMIN_PACKET_SERVER_CONSOLE
The server gives the admin the data that got printed to its console.
Definition tcp_admin.h:59
@ ADMIN_PACKET_SERVER_ENABLE_ENCRYPTION
The server tells that authentication has completed and requests to enable encryption with the keys of...
Definition tcp_admin.h:67
@ ADMIN_PACKET_SERVER_CLIENT_UPDATE
The server gives the admin an information update on a client.
Definition tcp_admin.h:48
@ ADMIN_PACKET_SERVER_COMPANY_STATS
The server gives the admin some statistics about a company.
Definition tcp_admin.h:56
@ ADMIN_PACKET_SERVER_COMPANY_ECONOMY
The server gives the admin some economy related company information.
Definition tcp_admin.h:55
@ ADMIN_PACKET_SERVER_GAMESCRIPT
The server gives the admin information from the GameScript in JSON.
Definition tcp_admin.h:62
@ ADMIN_PACKET_SERVER_CLIENT_INFO
The server gives the admin information about a client.
Definition tcp_admin.h:47
@ ADMIN_PACKET_SERVER_CLIENT_ERROR
The server tells the admin that a client caused an error.
Definition tcp_admin.h:50
@ ADMIN_PACKET_SERVER_AUTH_REQUEST
The server gives the admin the used authentication method and required parameters.
Definition tcp_admin.h:66
@ ADMIN_PACKET_SERVER_CHAT
The server received a chat message and relays it.
Definition tcp_admin.h:57
@ ADMIN_PACKET_SERVER_SHUTDOWN
The server tells the admin its shutting down.
Definition tcp_admin.h:43
@ ADMIN_PACKET_SERVER_RCON_END
The server indicates that the remote console command has completed.
Definition tcp_admin.h:63
@ ADMIN_PACKET_SERVER_WELCOME
The server welcomes the admin to a game.
Definition tcp_admin.h:41
@ ADMIN_PACKET_SERVER_COMPANY_REMOVE
The server tells the admin that a company was removed.
Definition tcp_admin.h:54
@ ADMIN_PACKET_SERVER_ERROR
The server tells the admin an error has occurred.
Definition tcp_admin.h:39
@ ADMIN_PACKET_SERVER_NEWGAME
The server tells the admin its going to start a new game.
Definition tcp_admin.h:42
@ ADMIN_PACKET_SERVER_COMPANY_UPDATE
The server gives the admin an information update on a company.
Definition tcp_admin.h:53
@ ADMIN_PACKET_SERVER_PONG
The server replies to a ping request from the admin.
Definition tcp_admin.h:64
@ ADMIN_PACKET_SERVER_CLIENT_JOIN
The server tells the admin that a client has joined.
Definition tcp_admin.h:46
@ ADMIN_PACKET_SERVER_CMD_LOGGING
The server gives the admin copies of incoming command packets.
Definition tcp_admin.h:65
@ ADMIN_PACKET_SERVER_PROTOCOL
The server tells the admin its protocol version.
Definition tcp_admin.h:40
@ ADMIN_PACKET_SERVER_CLIENT_QUIT
The server tells the admin that a client quit.
Definition tcp_admin.h:49
@ ADMIN_PACKET_SERVER_COMPANY_INFO
The server gives the admin information about a company.
Definition tcp_admin.h:52
@ ADMIN_PACKET_SERVER_CMD_NAMES
The server sends out the names of the DoCommands to the admins.
Definition tcp_admin.h:60
@ ADMIN_PACKET_SERVER_DATE
The server tells the admin what the current game date is.
Definition tcp_admin.h:45
@ ADMIN_PACKET_SERVER_COMPANY_NEW
The server tells the admin that a new company has started.
Definition tcp_admin.h:51
@ ADMIN_PACKET_SERVER_RCON
The server's reply to a remove console command.
Definition tcp_admin.h:58
AdminUpdateType
Update types an admin can register a frequency for.
Definition tcp_admin.h:81
@ ADMIN_UPDATE_DATE
Updates about the date of the game.
Definition tcp_admin.h:82
@ ADMIN_UPDATE_GAMESCRIPT
The admin would like to have gamescript messages.
Definition tcp_admin.h:91
@ ADMIN_UPDATE_COMPANY_INFO
Updates about the generic information of companies.
Definition tcp_admin.h:84
@ ADMIN_UPDATE_CONSOLE
The admin would like to have console messages.
Definition tcp_admin.h:88
@ ADMIN_UPDATE_CHAT
The admin would like to have chat messages.
Definition tcp_admin.h:87
@ ADMIN_UPDATE_COMPANY_STATS
Updates about the statistics of companies.
Definition tcp_admin.h:86
@ ADMIN_UPDATE_COMPANY_ECONOMY
Updates about the economy of companies.
Definition tcp_admin.h:85
@ ADMIN_UPDATE_END
Must ALWAYS be on the end of this list!! (period)
Definition tcp_admin.h:92
@ ADMIN_UPDATE_CLIENT_INFO
Updates about the information of clients.
Definition tcp_admin.h:83
@ ADMIN_UPDATE_CMD_NAMES
The admin would like a list of all DoCommand names.
Definition tcp_admin.h:89
@ ADMIN_UPDATE_CMD_LOGGING
The admin would like to have DoCommand information.
Definition tcp_admin.h:90
AdminCompanyRemoveReason
Reasons for removing a company - communicated to admins.
Definition tcp_admin.h:108
AdminUpdateFrequency
Update frequencies an admin can register.
Definition tcp_admin.h:96
@ Automatic
The admin gets information about this when it changes.
@ Annually
The admin gets information about this on a yearly basis.
@ Weekly
The admin gets information about this on a weekly basis.
@ Poll
The admin can poll this.
@ Monthly
The admin gets information about this on a monthly basis.
@ Quarterly
The admin gets information about this on a quarterly basis.
@ Daily
The admin gets information about this on a daily basis.
@ ADMIN_STATUS_INACTIVE
The admin is not connected nor active.
Definition tcp_admin.h:74
@ ADMIN_STATUS_ACTIVE
The admin is active.
Definition tcp_admin.h:76
@ ADMIN_STATUS_AUTHENTICATE
The admin is connected and working on authentication.
Definition tcp_admin.h:75