OpenTTD Source  12.0-beta2
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 "../date_func.h"
13 #include "core/game_info.h"
14 #include "network_admin.h"
15 #include "network_base.h"
16 #include "network_server.h"
17 #include "../command_func.h"
18 #include "../company_base.h"
19 #include "../console_func.h"
20 #include "../core/pool_func.hpp"
21 #include "../map_func.h"
22 #include "../rev.h"
23 #include "../game/game.hpp"
24 
25 #include "../safeguards.h"
26 
27 
28 /* This file handles all the admin network commands. */
29 
32 
35 
38 INSTANTIATE_POOL_METHODS(NetworkAdminSocket)
39 
40 
41 static const std::chrono::seconds ADMIN_AUTHORISATION_TIMEOUT(10);
42 
43 
56 };
59 
65 {
68  this->connect_time = std::chrono::steady_clock::now();
69 }
70 
75 {
77  Debug(net, 3, "[admin] '{}' ({}) has disconnected", this->admin_name, this->admin_version);
79 }
80 
86 {
88  /* We can't go over the MAX_ADMINS limit here. However, if we accept
89  * the connection, there has to be space in the pool. */
92  return accept;
93 }
94 
97 {
99  if (as->status == ADMIN_STATUS_INACTIVE && std::chrono::steady_clock::now() > as->connect_time + ADMIN_AUTHORISATION_TIMEOUT) {
100  Debug(net, 2, "[admin] Admin did not send its authorisation within {} seconds", std::chrono::duration_cast<std::chrono::seconds>(ADMIN_AUTHORISATION_TIMEOUT).count());
101  as->CloseConnection(true);
102  continue;
103  }
104  if (as->writable) {
105  as->SendPackets();
106  }
107  }
108 }
109 
115 /* static */ void ServerNetworkAdminSocketHandler::AcceptConnection(SOCKET s, const NetworkAddress &address)
116 {
118  as->address = address; // Save the IP of the client
119 }
120 
121 /***********
122  * Sending functions for admin network
123  ************/
124 
130 {
132 
133  p->Send_uint8(error);
134  this->SendPacket(p);
135 
136  std::string error_message = GetString(GetNetworkErrorMsg(error));
137 
138  Debug(net, 1, "[admin] The admin '{}' ({}) made an error and has been disconnected: '{}'", this->admin_name, this->admin_version, error_message);
139 
140  return this->CloseConnection(true);
141 }
142 
145 {
147 
148  /* announce the protocol version */
150 
151  for (int i = 0; i < ADMIN_UPDATE_END; i++) {
152  p->Send_bool (true);
153  p->Send_uint16(i);
155  }
156 
157  p->Send_bool(false);
158  this->SendPacket(p);
159 
160  return this->SendWelcome();
161 }
162 
165 {
167 
171 
172  p->Send_string(""); // Used to be map-name.
176  p->Send_uint16(MapSizeX());
177  p->Send_uint16(MapSizeY());
178 
179  this->SendPacket(p);
180 
182 }
183 
186 {
188  this->SendPacket(p);
190 }
191 
194 {
196  this->SendPacket(p);
198 }
199 
202 {
204 
205  p->Send_uint32(_date);
206  this->SendPacket(p);
207 
209 }
210 
216 {
218 
219  p->Send_uint32(client_id);
220  this->SendPacket(p);
221 
223 }
224 
231 {
232  /* Only send data when we're a proper client, not just someone trying to query the server. */
233  if (ci == nullptr) return NETWORK_RECV_STATUS_OKAY;
234 
236 
237  p->Send_uint32(ci->client_id);
238  p->Send_string(cs == nullptr ? "" : const_cast<NetworkAddress &>(cs->client_address).GetHostname());
239  p->Send_string(ci->client_name);
240  p->Send_uint8 (0); // Used to be language
241  p->Send_uint32(ci->join_date);
242  p->Send_uint8 (ci->client_playas);
243 
244  this->SendPacket(p);
245 
247 }
248 
249 
255 {
257 
258  p->Send_uint32(ci->client_id);
259  p->Send_string(ci->client_name);
260  p->Send_uint8 (ci->client_playas);
261 
262  this->SendPacket(p);
263 
265 }
266 
272 {
274 
275  p->Send_uint32(client_id);
276  this->SendPacket(p);
277 
279 }
280 
287 {
289 
290  p->Send_uint32(client_id);
291  p->Send_uint8 (error);
292  this->SendPacket(p);
293 
295 }
296 
302 {
304  p->Send_uint8(company_id);
305 
306  this->SendPacket(p);
307 
309 }
310 
316 {
318 
319  p->Send_uint8 (c->index);
320  SetDParam(0, c->index);
321  p->Send_string(GetString(STR_COMPANY_NAME));
322  SetDParam(0, c->index);
323  p->Send_string(GetString(STR_PRESIDENT_NAME));
324  p->Send_uint8 (c->colour);
327  p->Send_bool (c->is_ai);
328  p->Send_uint8 (CeilDiv(c->months_of_bankruptcy, 3)); // send as quarters_of_bankruptcy
329 
330  for (size_t i = 0; i < lengthof(c->share_owners); i++) {
331  p->Send_uint8(c->share_owners[i]);
332  }
333 
334  this->SendPacket(p);
335 
337 }
338 
339 
345 {
347 
348  p->Send_uint8 (c->index);
349  SetDParam(0, c->index);
350  p->Send_string(GetString(STR_COMPANY_NAME));
351  SetDParam(0, c->index);
352  p->Send_string(GetString(STR_PRESIDENT_NAME));
353  p->Send_uint8 (c->colour);
355  p->Send_uint8 (CeilDiv(c->months_of_bankruptcy, 3)); // send as quarters_of_bankruptcy
356 
357  for (size_t i = 0; i < lengthof(c->share_owners); i++) {
358  p->Send_uint8(c->share_owners[i]);
359  }
360 
361  this->SendPacket(p);
362 
364 }
365 
372 {
374 
375  p->Send_uint8(company_id);
376  p->Send_uint8(acrr);
377 
378  this->SendPacket(p);
379 
381 }
382 
385 {
386  for (const Company *company : Company::Iterate()) {
387  /* Get the income. */
388  Money income = 0;
389  for (uint i = 0; i < lengthof(company->yearly_expenses[0]); i++) {
390  income -= company->yearly_expenses[0][i];
391  }
392 
394 
395  p->Send_uint8(company->index);
396 
397  /* Current information. */
398  p->Send_uint64(company->money);
399  p->Send_uint64(company->current_loan);
400  p->Send_uint64(income);
401  p->Send_uint16(static_cast<uint16>(std::min<uint64>(UINT16_MAX, company->cur_economy.delivered_cargo.GetSum<OverflowSafeInt64>())));
402 
403  /* Send stats for the last 2 quarters. */
404  for (uint i = 0; i < 2; i++) {
405  p->Send_uint64(company->old_economy[i].company_value);
406  p->Send_uint16(company->old_economy[i].performance_history);
407  p->Send_uint16(static_cast<uint16>(std::min<uint64>(UINT16_MAX, company->old_economy[i].delivered_cargo.GetSum<OverflowSafeInt64>())));
408  }
409 
410  this->SendPacket(p);
411  }
412 
413 
415 }
416 
419 {
420  /* Fetch the latest version of the stats. */
421  NetworkCompanyStats company_stats[MAX_COMPANIES];
422  NetworkPopulateCompanyStats(company_stats);
423 
424  /* Go through all the companies. */
425  for (const Company *company : Company::Iterate()) {
427 
428  /* Send the information. */
429  p->Send_uint8(company->index);
430 
431  for (uint i = 0; i < NETWORK_VEH_END; i++) {
432  p->Send_uint16(company_stats[company->index].num_vehicle[i]);
433  }
434 
435  for (uint i = 0; i < NETWORK_VEH_END; i++) {
436  p->Send_uint16(company_stats[company->index].num_station[i]);
437  }
438 
439  this->SendPacket(p);
440  }
441 
443 }
444 
453 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendChat(NetworkAction action, DestType desttype, ClientID client_id, const std::string &msg, int64 data)
454 {
456 
457  p->Send_uint8 (action);
458  p->Send_uint8 (desttype);
459  p->Send_uint32(client_id);
460  p->Send_string(msg);
461  p->Send_uint64(data);
462 
463  this->SendPacket(p);
465 }
466 
472 {
474 
475  p->Send_string(command);
476  this->SendPacket(p);
477 
479 }
480 
486 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendRcon(uint16 colour, const std::string_view result)
487 {
489 
490  p->Send_uint16(colour);
491  p->Send_string(result);
492  this->SendPacket(p);
493 
495 }
496 
498 {
499  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
500 
501  std::string command = p->Recv_string(NETWORK_RCONCOMMAND_LENGTH);
502 
503  Debug(net, 3, "[admin] Rcon command from '{}' ({}): {}", this->admin_name, this->admin_version, command);
504 
506  IConsoleCmdExec(command.c_str());
508  return this->SendRconEnd(command);
509 }
510 
512 {
513  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
514 
515  std::string json = p->Recv_string(NETWORK_GAMESCRIPT_JSON_LENGTH);
516 
517  Debug(net, 6, "[admin] GameScript JSON from '{}' ({}): {}", this->admin_name, this->admin_version, json);
518 
519  Game::NewEvent(new ScriptEventAdminPort(json));
521 }
522 
524 {
525  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
526 
527  uint32 d1 = p->Recv_uint32();
528 
529  Debug(net, 6, "[admin] Ping from '{}' ({}): {}", this->admin_name, this->admin_version, d1);
530 
531  return this->SendPong(d1);
532 }
533 
539 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendConsole(const std::string_view origin, const std::string_view string)
540 {
541  /* If the length of both strings, plus the 2 '\0' terminations and 3 bytes of the packet
542  * are bigger than the MTU, just ignore the message. Better safe than sorry. It should
543  * never occur though as the longest strings are chat messages, which are still 30%
544  * smaller than COMPAT_MTU. */
545  if (origin.size() + string.size() + 2 + 3 >= COMPAT_MTU) return NETWORK_RECV_STATUS_OKAY;
546 
548 
549  p->Send_string(origin);
550  p->Send_string(string);
551  this->SendPacket(p);
552 
554 }
555 
561 {
562  /* At the moment we cannot transmit anything larger than MTU. So we limit
563  * the maximum amount of json data that can be sent. Account also for
564  * the trailing \0 of the string */
565  if (json.size() + 1 >= NETWORK_GAMESCRIPT_JSON_LENGTH) return NETWORK_RECV_STATUS_OKAY;
566 
568 
569  p->Send_string(json);
570  this->SendPacket(p);
571 
573 }
574 
577 {
579 
580  p->Send_uint32(d1);
581  this->SendPacket(p);
582 
584 }
585 
588 {
590 
591  for (uint i = 0; i < CMD_END; i++) {
592  const char *cmdname = GetCommandName(i);
593 
594  /* Should COMPAT_MTU be exceeded, start a new packet
595  * (magic 5: 1 bool "more data" and one uint16 "command id", one
596  * byte for string '\0' termination and 1 bool "no more data" */
597  if (p->CanWriteToPacket(strlen(cmdname) + 5)) {
598  p->Send_bool(false);
599  this->SendPacket(p);
600 
602  }
603 
604  p->Send_bool(true);
605  p->Send_uint16(i);
606  p->Send_string(cmdname);
607  }
608 
609  /* Marker to notify the end of the packet has been reached. */
610  p->Send_bool(false);
611  this->SendPacket(p);
612 
614 }
615 
622 {
624 
625  p->Send_uint32(client_id);
626  p->Send_uint8 (cp->company);
627  p->Send_uint16(cp->cmd & CMD_ID_MASK);
628  p->Send_uint32(cp->p1);
629  p->Send_uint32(cp->p2);
630  p->Send_uint32(cp->tile);
631  p->Send_string(cp->text);
632  p->Send_uint32(cp->frame);
633 
634  this->SendPacket(p);
635 
637 }
638 
639 /***********
640  * Receiving functions
641  ************/
642 
644 {
645  if (this->status != ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
646 
647  std::string password = p->Recv_string(NETWORK_PASSWORD_LENGTH);
648 
650  _settings_client.network.admin_password.compare(password) != 0) {
651  /* Password is invalid */
652  return this->SendError(NETWORK_ERROR_WRONG_PASSWORD);
653  }
654 
657 
658  if (this->admin_name.empty() || this->admin_version.empty()) {
659  /* no name or version supplied */
660  return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
661  }
662 
663  this->status = ADMIN_STATUS_ACTIVE;
664 
665  Debug(net, 3, "[admin] '{}' ({}) has connected", this->admin_name, this->admin_version);
666 
667  return this->SendProtocol();
668 }
669 
671 {
672  /* The admin is leaving nothing else to do */
673  return this->CloseConnection();
674 }
675 
677 {
678  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
679 
682 
683  if (type >= ADMIN_UPDATE_END || (_admin_update_type_frequencies[type] & freq) != freq) {
684  /* The server does not know of this UpdateType. */
685  Debug(net, 1, "[admin] Not supported update frequency {} ({}) from '{}' ({})", type, freq, this->admin_name, this->admin_version);
686  return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
687  }
688 
689  this->update_frequency[type] = freq;
690 
692 }
693 
695 {
696  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
697 
699  uint32 d1 = p->Recv_uint32();
700 
701  switch (type) {
702  case ADMIN_UPDATE_DATE:
703  /* The admin is requesting the current date. */
704  this->SendDate();
705  break;
706 
708  /* The admin is requesting client info. */
709  if (d1 == UINT32_MAX) {
711  for (const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
712  this->SendClientInfo(cs, cs->GetInfo());
713  }
714  } else {
715  if (d1 == CLIENT_ID_SERVER) {
717  } else {
718  const NetworkClientSocket *cs = NetworkClientSocket::GetByClientID((ClientID)d1);
719  if (cs != nullptr) this->SendClientInfo(cs, cs->GetInfo());
720  }
721  }
722  break;
723 
725  /* The admin is asking for company info. */
726  if (d1 == UINT32_MAX) {
727  for (const Company *company : Company::Iterate()) {
728  this->SendCompanyInfo(company);
729  }
730  } else {
731  const Company *company = Company::GetIfValid(d1);
732  if (company != nullptr) this->SendCompanyInfo(company);
733  }
734  break;
735 
737  /* The admin is requesting economy info. */
738  this->SendCompanyEconomy();
739  break;
740 
742  /* the admin is requesting company stats. */
743  this->SendCompanyStats();
744  break;
745 
747  /* The admin is requesting the names of DoCommands. */
748  this->SendCmdNames();
749  break;
750 
751  default:
752  /* An unsupported "poll" update type. */
753  Debug(net, 1, "[admin] Not supported poll {} ({}) from '{}' ({}).", type, d1, this->admin_name, this->admin_version);
754  return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
755  }
756 
758 }
759 
761 {
762  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
763 
764  NetworkAction action = (NetworkAction)p->Recv_uint8();
765  DestType desttype = (DestType)p->Recv_uint8();
766  int dest = p->Recv_uint32();
767 
768  std::string msg = p->Recv_string(NETWORK_CHAT_LENGTH);
769 
770  switch (action) {
771  case NETWORK_ACTION_CHAT:
772  case NETWORK_ACTION_CHAT_CLIENT:
773  case NETWORK_ACTION_CHAT_COMPANY:
774  case NETWORK_ACTION_SERVER_MESSAGE:
775  NetworkServerSendChat(action, desttype, dest, msg, _network_own_client_id, 0, true);
776  break;
777 
778  default:
779  Debug(net, 1, "[admin] Invalid chat action {} from admin '{}' ({}).", action, this->admin_name, this->admin_version);
780  return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
781  }
782 
784 }
785 
786 /*
787  * Useful wrapper functions
788  */
789 
795 void NetworkAdminClientInfo(const NetworkClientSocket *cs, bool new_client)
796 {
798  if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO] & ADMIN_FREQUENCY_AUTOMATIC) {
799  as->SendClientInfo(cs, cs->GetInfo());
800  if (new_client) {
801  as->SendClientJoin(cs->client_id);
802  }
803  }
804  }
805 }
806 
812 {
814  if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO] & ADMIN_FREQUENCY_AUTOMATIC) {
815  as->SendClientUpdate(ci);
816  }
817  }
818 }
819 
825 {
827  if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO] & ADMIN_FREQUENCY_AUTOMATIC) {
828  as->SendClientQuit(client_id);
829  }
830  }
831 }
832 
839 {
841  if (as->update_frequency[ADMIN_UPDATE_CLIENT_INFO] & ADMIN_FREQUENCY_AUTOMATIC) {
842  as->SendClientError(client_id, error_code);
843  }
844  }
845 }
846 
852 void NetworkAdminCompanyInfo(const Company *company, bool new_company)
853 {
854  if (company == nullptr) {
855  Debug(net, 1, "[admin] Empty company given for update");
856  return;
857  }
858 
860  if (as->update_frequency[ADMIN_UPDATE_COMPANY_INFO] != ADMIN_FREQUENCY_AUTOMATIC) continue;
861 
862  as->SendCompanyInfo(company);
863  if (new_company) {
864  as->SendCompanyNew(company->index);
865  }
866  }
867 }
868 
873 void NetworkAdminCompanyUpdate(const Company *company)
874 {
875  if (company == nullptr) return;
876 
878  if (as->update_frequency[ADMIN_UPDATE_COMPANY_INFO] != ADMIN_FREQUENCY_AUTOMATIC) continue;
879 
880  as->SendCompanyUpdate(company);
881  }
882 }
883 
890 {
892  as->SendCompanyRemove(company_id, bcrr);
893  }
894 }
895 
896 
900 void NetworkAdminChat(NetworkAction action, DestType desttype, ClientID client_id, const std::string &msg, int64 data, bool from_admin)
901 {
902  if (from_admin) return;
903 
905  if (as->update_frequency[ADMIN_UPDATE_CHAT] & ADMIN_FREQUENCY_AUTOMATIC) {
906  as->SendChat(action, desttype, client_id, msg, data);
907  }
908  }
909 }
910 
917 void NetworkServerSendAdminRcon(AdminIndex admin_index, TextColour colour_code, const std::string_view string)
918 {
919  ServerNetworkAdminSocketHandler::Get(admin_index)->SendRcon(colour_code, string);
920 }
921 
927 void NetworkAdminConsole(const std::string_view origin, const std::string_view string)
928 {
930  if (as->update_frequency[ADMIN_UPDATE_CONSOLE] & ADMIN_FREQUENCY_AUTOMATIC) {
931  as->SendConsole(origin, string);
932  }
933  }
934 }
935 
940 void NetworkAdminGameScript(const std::string_view json)
941 {
943  if (as->update_frequency[ADMIN_UPDATE_GAMESCRIPT] & ADMIN_FREQUENCY_AUTOMATIC) {
944  as->SendGameScript(json);
945  }
946  }
947 }
948 
954 void NetworkAdminCmdLogging(const NetworkClientSocket *owner, const CommandPacket *cp)
955 {
956  ClientID client_id = owner == nullptr ? _network_own_client_id : owner->client_id;
957 
959  if (as->update_frequency[ADMIN_UPDATE_CMD_LOGGING] & ADMIN_FREQUENCY_AUTOMATIC) {
960  as->SendCmdLogging(client_id, cp);
961  }
962  }
963 }
964 
969 {
971  as->SendWelcome();
972  }
973 }
974 
980 {
982  for (int i = 0; i < ADMIN_UPDATE_END; i++) {
983  if (as->update_frequency[i] & freq) {
984  /* Update the admin for the required details */
985  switch (i) {
986  case ADMIN_UPDATE_DATE:
987  as->SendDate();
988  break;
989 
991  as->SendCompanyEconomy();
992  break;
993 
995  as->SendCompanyStats();
996  break;
997 
998  default: NOT_REACHED();
999  }
1000  }
1001  }
1002  }
1003 }
NetworkCompanyStats::num_station
uint16 num_station[NETWORK_VEH_END]
How many stations are there of this type?
Definition: network_type.h:67
ADMIN_PACKET_SERVER_GAMESCRIPT
@ ADMIN_PACKET_SERVER_GAMESCRIPT
The server gives the admin information from the GameScript in JSON.
Definition: tcp_admin.h:59
CompanyProperties::is_ai
bool is_ai
If true, the company is (also) controlled by the computer (a NoAI program).
Definition: company_base.h:94
NetworkCompanyStats
Simple calculated statistics of a company.
Definition: network_type.h:65
CommandContainer::cmd
uint32 cmd
command being executed.
Definition: command_type.h:483
DestType
DestType
Destination of our chat messages.
Definition: network_type.h:89
ADMIN_UPDATE_CMD_NAMES
@ ADMIN_UPDATE_CMD_NAMES
The admin would like a list of all DoCommand names.
Definition: tcp_admin.h:82
ADMIN_UPDATE_COMPANY_INFO
@ ADMIN_UPDATE_COMPANY_INFO
Updates about the generic information of companies.
Definition: tcp_admin.h:77
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 Upda...
Definition: network_admin.cpp:676
GameCreationSettings::generation_seed
uint32 generation_seed
noise seed for world generation
Definition: settings_type.h:304
Pool::PoolItem<&_networkadminsocket_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:337
NetworkAdminSocketHandler::admin_version
std::string admin_version
Version string of the admin.
Definition: tcp_admin.h:113
NetworkAdminUpdate
void NetworkAdminUpdate(AdminUpdateFrequency freq)
Send (push) updates to the admin network as they have registered for these updates.
Definition: network_admin.cpp:979
NetworkAdminSocketHandler::status
AdminStatus status
Status of this admin.
Definition: tcp_admin.h:114
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:348
NetworkServerSendChat
void NetworkServerSendChat(NetworkAction action, DestType type, int dest, const std::string &msg, ClientID from_id, int64 data=0, bool from_admin=false)
Send an actual chat message.
Definition: network_server.cpp:1153
NetworkClientInfo::client_name
std::string client_name
Name of the client.
Definition: network_base.h:26
NetworkAdminChat
void NetworkAdminChat(NetworkAction action, DestType desttype, ClientID client_id, const std::string &msg, int64 data, bool from_admin)
Send chat to the admin network (if they did opt in for the respective update).
Definition: network_admin.cpp:900
GameCreationSettings::landscape
byte landscape
the landscape we're currently in
Definition: settings_type.h:320
ADMIN_PACKET_SERVER_CLIENT_QUIT
@ ADMIN_PACKET_SERVER_CLIENT_QUIT
The server tells the admin that a client quit.
Definition: tcp_admin.h:46
ServerNetworkAdminSocketHandler::SendError
NetworkRecvStatus SendError(NetworkErrorCode error)
Send an error to the admin.
Definition: network_admin.cpp:129
ServerNetworkAdminSocketHandler::SendRconEnd
NetworkRecvStatus SendRconEnd(const std::string_view command)
Send a notification indicating the rcon command has completed.
Definition: network_admin.cpp:471
ADMIN_UPDATE_CLIENT_INFO
@ ADMIN_UPDATE_CLIENT_INFO
Updates about the information of clients.
Definition: tcp_admin.h:76
ADMIN_PACKET_SERVER_COMPANY_INFO
@ ADMIN_PACKET_SERVER_COMPANY_INFO
The server gives the admin information about a company.
Definition: tcp_admin.h:49
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:112
ServerNetworkAdminSocketHandler::SendCompanyEconomy
NetworkRecvStatus SendCompanyEconomy()
Send economic information of all companies.
Definition: network_admin.cpp:384
ServerNetworkAdminSocketHandler::SendRcon
NetworkRecvStatus SendRcon(uint16 colour, const std::string_view command)
Send the reply of an rcon command.
Definition: network_admin.cpp:486
CompanyProperties::inaugurated_year
Year inaugurated_year
Year of starting the company.
Definition: company_base.h:79
ServerNetworkAdminSocketHandler::update_frequency
AdminUpdateFrequency update_frequency[ADMIN_UPDATE_END]
Admin requested update intervals.
Definition: network_admin.h:39
ADMIN_UPDATE_CONSOLE
@ ADMIN_UPDATE_CONSOLE
The admin would like to have console messages.
Definition: tcp_admin.h:81
ADMIN_PACKET_SERVER_PONG
@ ADMIN_PACKET_SERVER_PONG
The server replies to a ping request from the admin.
Definition: tcp_admin.h:61
GetCommandName
const char * GetCommandName(uint32 cmd)
Definition: command.cpp:407
NetworkAction
NetworkAction
Actions that can be used for NetworkTextMessage.
Definition: network_type.h:99
ADMIN_UPDATE_CHAT
@ ADMIN_UPDATE_CHAT
The admin would like to have chat messages.
Definition: tcp_admin.h:80
CommandPacket::frame
uint32 frame
the frame in which this packet is executed
Definition: network_internal.h:112
Pool::PoolItem<&_networkadminsocket_pool >::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:235
NetworkPopulateCompanyStats
void NetworkPopulateCompanyStats(NetworkCompanyStats *stats)
Populate the company stats.
Definition: network_server.cpp:1390
ServerNetworkAdminSocketHandler::WelcomeAll
static void WelcomeAll()
Send a Welcome packet to all connected admins.
Definition: network_admin.cpp:968
NETWORK_CHAT_LENGTH
static const uint NETWORK_CHAT_LENGTH
The maximum length of a chat message, in bytes including '\0'.
Definition: config.h:66
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:643
ADMIN_PACKET_SERVER_NEWGAME
@ ADMIN_PACKET_SERVER_NEWGAME
The server tells the admin its going to start a new game.
Definition: tcp_admin.h:39
NetworkClientInfo::join_date
Date join_date
Gamedate the client has joined.
Definition: network_base.h:28
ADMIN_FREQUENCY_DAILY
@ ADMIN_FREQUENCY_DAILY
The admin gets information about this on a daily basis.
Definition: tcp_admin.h:91
TextColour
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:250
CommandContainer::p2
uint32 p2
parameter p2.
Definition: command_type.h:482
GetNetworkRevisionString
std::string_view GetNetworkRevisionString()
Get the network version string used by this build.
Definition: game_info.cpp:43
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:95
ADMIN_PACKET_SERVER_CHAT
@ ADMIN_PACKET_SERVER_CHAT
The server received a chat message and relays it.
Definition: tcp_admin.h:54
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:48
ServerNetworkAdminSocketHandler::SendCompanyUpdate
NetworkRecvStatus SendCompanyUpdate(const Company *c)
Send an update about a company.
Definition: network_admin.cpp:344
ADMIN_PACKET_SERVER_PROTOCOL
@ ADMIN_PACKET_SERVER_PROTOCOL
The server tells the admin its protocol version.
Definition: tcp_admin.h:37
ADMIN_UPDATE_CMD_LOGGING
@ ADMIN_UPDATE_CMD_LOGGING
The admin would like to have DoCommand information.
Definition: tcp_admin.h:83
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:52
ADMIN_FREQUENCY_MONTHLY
@ ADMIN_FREQUENCY_MONTHLY
The admin gets information about this on a monthly basis.
Definition: tcp_admin.h:93
GetNetworkErrorMsg
StringID GetNetworkErrorMsg(NetworkErrorCode err)
Retrieve the string id of an internal error number.
Definition: network.cpp:297
ADMIN_PACKET_SERVER_COMPANY_STATS
@ ADMIN_PACKET_SERVER_COMPANY_STATS
The server gives the admin some statistics about a company.
Definition: tcp_admin.h:53
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:63
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:50
Packet::Send_uint8
void Send_uint8(uint8 data)
Package a 8 bits integer in the packet.
Definition: packet.cpp:129
ServerNetworkAdminSocketHandler::SendCompanyInfo
NetworkRecvStatus SendCompanyInfo(const Company *c)
Send the admin some information about a company.
Definition: network_admin.cpp:315
ServerNetworkAdminSocketHandler::address
NetworkAddress address
Address of the admin.
Definition: network_admin.h:41
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:196
INVALID_ADMIN_ID
static const AdminIndex INVALID_ADMIN_ID
An invalid admin marker.
Definition: network_type.h:62
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:824
_redirect_console_to_admin
AdminIndex _redirect_console_to_admin
Redirection of the (remote) console to the admin.
Definition: network_admin.cpp:31
_networkadminsocket_pool
NetworkAdminSocketPool _networkadminsocket_pool("NetworkAdminSocket")
The pool with sockets/clients.
ServerNetworkAdminSocketHandler::Send
static void Send()
Send the packets for the server sockets.
Definition: network_admin.cpp:96
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:795
GameSettings::game_creation
GameCreationSettings game_creation
settings used during the creation of a game (map)
Definition: settings_type.h:576
Packet::Send_uint32
void Send_uint32(uint32 data)
Package a 32 bits integer in the packet.
Definition: packet.cpp:150
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:380
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:927
MapSizeX
static uint MapSizeX()
Get the size of the map along the X.
Definition: map_func.h:72
CommandContainer::text
std::string text
possible text sent for name changes etc.
Definition: command_type.h:485
Pool::MAX_SIZE
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
Definition: pool_type.hpp:85
NetworkClientInfo::GetByClientID
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it's client-identifier.
Definition: network.cpp:112
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:940
ADMIN_FREQUENCY_QUARTERLY
@ ADMIN_FREQUENCY_QUARTERLY
The admin gets information about this on a quarterly basis.
Definition: tcp_admin.h:94
CommandPacket::company
CompanyID company
company that is executing the command
Definition: network_internal.h:111
ADMIN_STATUS_INACTIVE
@ ADMIN_STATUS_INACTIVE
The admin is not connected nor active.
Definition: tcp_admin.h:68
ADMIN_PACKET_SERVER_DATE
@ ADMIN_PACKET_SERVER_DATE
The server tells the admin what the current game date is.
Definition: tcp_admin.h:42
ADMIN_PACKET_SERVER_ERROR
@ ADMIN_PACKET_SERVER_ERROR
The server tells the admin an error has occurred.
Definition: tcp_admin.h:36
CommandContainer::p1
uint32 p1
parameter p1.
Definition: command_type.h:481
ServerNetworkAdminSocketHandler::SendShutdown
NetworkRecvStatus SendShutdown()
Tell the admin we're shutting down.
Definition: network_admin.cpp:193
NetworkCompanyStats::num_vehicle
uint16 num_vehicle[NETWORK_VEH_END]
How many vehicles are there of this type?
Definition: network_type.h:66
Packet::Recv_uint32
uint32 Recv_uint32()
Read a 32 bits integer from the packet.
Definition: packet.cpp:335
CompanyProperties::colour
byte colour
Company colour.
Definition: company_base.h:70
ServerNetworkAdminSocketHandler::connect_time
std::chrono::steady_clock::time_point connect_time
Time of connection.
Definition: network_admin.h:40
CommandPacket
Everything we need to know about a command to be able to execute it.
Definition: network_internal.h:107
_date
Date _date
Current date in days (day counter)
Definition: date.cpp:28
COMPAT_MTU
static const uint16 COMPAT_MTU
Number of bytes we can pack in a single packet for backward compatibility.
Definition: config.h:48
MAX_ADMINS
static const AdminIndex MAX_ADMINS
Maximum number of allowed admins.
Definition: network_type.h:60
ServerNetworkAdminSocketHandler::SendConsole
NetworkRecvStatus SendConsole(const std::string_view origin, const std::string_view command)
Send console output of other clients.
Definition: network_admin.cpp:539
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:371
ConvertYMDToDate
Date ConvertYMDToDate(Year year, Month month, Day day)
Converts a tuple of Year, Month and Day to a Date.
Definition: date.cpp:149
ClientID
ClientID
'Unique' identifier to be given to clients
Definition: network_type.h:47
NetworkAdminSocketHandler
Main socket handler for admin related connections.
Definition: tcp_admin.h:110
ADMIN_PACKET_SERVER_COMPANY_REMOVE
@ ADMIN_PACKET_SERVER_COMPANY_REMOVE
The server tells the admin that a company was removed.
Definition: tcp_admin.h:51
NetworkSettings::admin_password
std::string admin_password
password for the admin network
Definition: settings_type.h:282
ADMIN_FREQUENCY_POLL
@ ADMIN_FREQUENCY_POLL
The admin can poll this.
Definition: tcp_admin.h:90
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:47
ADMIN_UPDATE_DATE
@ ADMIN_UPDATE_DATE
Updates about the date of the game.
Definition: tcp_admin.h:75
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:53
ServerNetworkAdminSocketHandler::AllowConnection
static bool AllowConnection()
Whether a connection is allowed or not at this moment.
Definition: network_admin.cpp:85
ServerNetworkAdminSocketHandler::SendWelcome
NetworkRecvStatus SendWelcome()
Send a welcome message to the admin.
Definition: network_admin.cpp:164
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:141
ServerNetworkAdminSocketHandler::SendGameScript
NetworkRecvStatus SendGameScript(const std::string_view json)
Send GameScript JSON output.
Definition: network_admin.cpp:560
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:79
ADMIN_UPDATE_COMPANY_ECONOMY
@ ADMIN_UPDATE_COMPANY_ECONOMY
Updates about the economy of companies.
Definition: tcp_admin.h:78
Packet::Send_uint16
void Send_uint16(uint16 data)
Package a 16 bits integer in the packet.
Definition: packet.cpp:139
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
CLIENT_ID_SERVER
@ CLIENT_ID_SERVER
Servers always have this ID.
Definition: network_type.h:49
ServerNetworkAdminSocketHandler::~ServerNetworkAdminSocketHandler
~ServerNetworkAdminSocketHandler()
Clear everything related to this admin.
Definition: network_admin.cpp:74
ADMIN_PACKET_SERVER_RCON
@ ADMIN_PACKET_SERVER_RCON
The server's reply to a remove console command.
Definition: tcp_admin.h:55
ServerNetworkAdminSocketHandler::SendClientQuit
NetworkRecvStatus SendClientQuit(ClientID client_id)
Tell the admin that a client quit.
Definition: network_admin.cpp:271
AdminCompanyRemoveReason
AdminCompanyRemoveReason
Reasons for removing a company - communicated to admins.
Definition: tcp_admin.h:101
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:56
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:45
MapSizeY
static uint MapSizeY()
Get the size of the map along the Y.
Definition: map_func.h:82
CompanyProperties::share_owners
Owner share_owners[4]
Owners of the 4 shares of the company. INVALID_OWNER if nobody has bought them yet.
Definition: company_base.h:77
network_server.h
_network_dedicated
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:59
ADMIN_UPDATE_GAMESCRIPT
@ ADMIN_UPDATE_GAMESCRIPT
The admin would like to have gamescript messages.
Definition: tcp_admin.h:84
Packet
Internal entity of a packet.
Definition: packet.h:44
ADMIN_FREQUENCY_ANUALLY
@ ADMIN_FREQUENCY_ANUALLY
The admin gets information about this on a yearly basis.
Definition: tcp_admin.h:95
ServerNetworkAdminSocketHandler::SendCmdNames
NetworkRecvStatus SendCmdNames()
Send the names of the commands.
Definition: network_admin.cpp:587
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:889
NETWORK_REVISION_LENGTH
static const uint NETWORK_REVISION_LENGTH
The maximum length of the revision, in bytes including '\0'.
Definition: config.h:60
NetworkCompanyIsPassworded
bool NetworkCompanyIsPassworded(CompanyID company_id)
Check if the company we want to join requires a password.
Definition: network.cpp:211
AdminUpdateType
AdminUpdateType
Update types an admin can register a frequency for.
Definition: tcp_admin.h:74
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:60
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:61
ServerNetworkAdminSocketHandler::SendNewGame
NetworkRecvStatus SendNewGame()
Tell the admin we started a new game.
Definition: network_admin.cpp:185
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:62
NetworkAdminCompanyUpdate
void NetworkAdminCompanyUpdate(const Company *company)
Notify the admin network of company updates.
Definition: network_admin.cpp:873
NetworkSettings::server_name
std::string server_name
name of the server
Definition: settings_type.h:279
ADMIN_PACKET_SERVER_CLIENT_JOIN
@ ADMIN_PACKET_SERVER_CLIENT_JOIN
The server tells the admin that a client has joined.
Definition: tcp_admin.h:43
NetworkAddress
Wrapper for (un)resolved network addresses; there's no reason to transform a numeric IP to a string a...
Definition: address.h:30
NETWORK_RCONCOMMAND_LENGTH
static const uint NETWORK_RCONCOMMAND_LENGTH
The maximum length of a rconsole command, in bytes including '\0'.
Definition: config.h:64
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:386
ServerNetworkAdminSocketHandler::SendDate
NetworkRecvStatus SendDate()
Tell the admin the date.
Definition: network_admin.cpp:201
ServerNetworkAdminSocketHandler::SendCompanyNew
NetworkRecvStatus SendCompanyNew(CompanyID company_id)
Tell the admin that a new company was founded.
Definition: network_admin.cpp:301
Pool
Base class for all pools.
Definition: pool_type.hpp:81
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:57
ServerNetworkAdminSocketHandler::Receive_ADMIN_QUIT
NetworkRecvStatus Receive_ADMIN_QUIT(Packet *p) override
Notification to the server that this admin is quitting.
Definition: network_admin.cpp:670
ADMIN_PACKET_SERVER_CLIENT_INFO
@ ADMIN_PACKET_SERVER_CLIENT_INFO
The server gives the admin information about a client.
Definition: tcp_admin.h:44
CMD_ID_MASK
@ CMD_ID_MASK
mask for the command ID
Definition: command_type.h:382
ServerNetworkAdminSocketHandler::SendPong
NetworkRecvStatus SendPong(uint32 d1)
Send ping-reply (pong) to admin.
Definition: network_admin.cpp:576
Packet::CanWriteToPacket
bool CanWriteToPacket(size_t bytes_to_write)
Is it safe to write to the packet, i.e.
Definition: packet.cpp:99
Packet::Send_uint64
void Send_uint64(uint64 data)
Package a 64 bits integer in the packet.
Definition: packet.cpp:163
ServerNetworkAdminSocketHandler::SendChat
NetworkRecvStatus SendChat(NetworkAction action, DestType desttype, ClientID client_id, const std::string &msg, int64 data)
Send a chat message.
Definition: network_admin.cpp:453
ServerNetworkAdminSocketHandler::ServerNetworkAdminSocketHandler
ServerNetworkAdminSocketHandler(SOCKET s)
Sanity check.
Definition: network_admin.cpp:64
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:694
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:230
ADMIN_FREQUENCY_AUTOMATIC
@ ADMIN_FREQUENCY_AUTOMATIC
The admin gets information about this when it changes.
Definition: tcp_admin.h:96
ADMIN_STATUS_ACTIVE
@ ADMIN_STATUS_ACTIVE
The admin is active.
Definition: tcp_admin.h:69
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:50
ServerNetworkAdminSocketHandler::SendProtocol
NetworkRecvStatus SendProtocol()
Send the protocol version to the admin.
Definition: network_admin.cpp:144
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:523
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:307
ADMIN_PACKET_SERVER_WELCOME
@ ADMIN_PACKET_SERVER_WELCOME
The server welcomes the admin to a game.
Definition: tcp_admin.h:38
game_info.h
GameCreationSettings::starting_year
Year starting_year
starting date
Definition: settings_type.h:305
Packet::Recv_uint8
uint8 Recv_uint8()
Read a 8 bits integer from the packet.
Definition: packet.cpp:306
ServerNetworkAdminSocketHandler::AcceptConnection
static void AcceptConnection(SOCKET s, const NetworkAddress &address)
Handle the acception of a connection.
Definition: network_admin.cpp:115
ServerNetworkAdminSocketHandler::SendClientUpdate
NetworkRecvStatus SendClientUpdate(const NetworkClientInfo *ci)
Send an update for some client's information.
Definition: network_admin.cpp:254
INSTANTIATE_POOL_METHODS
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
Definition: pool_func.hpp:224
ADMIN_PACKET_SERVER_COMPANY_ECONOMY
@ ADMIN_PACKET_SERVER_COMPANY_ECONOMY
The server gives the admin some economy related company information.
Definition: tcp_admin.h:52
error
void CDECL error(const char *s,...)
Error handling for fatal non-user errors.
Definition: openttd.cpp:132
ADMIN_PACKET_SERVER_CMD_LOGGING
@ ADMIN_PACKET_SERVER_CMD_LOGGING
The server gives the admin copies of incoming command packets.
Definition: tcp_admin.h:58
Packet::Send_string
void Send_string(const std::string_view data)
Sends a string over the network.
Definition: packet.cpp:181
AdminIndex
uint8 AdminIndex
Indices into the admin tables.
Definition: network_type.h:57
Debug
#define Debug(name, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
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:811
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:378
ClientSettings::network
NetworkSettings network
settings related to the network
Definition: settings_type.h:594
OverflowSafeInt< int64 >
_network_admins_connected
byte _network_admins_connected
The amount of admins connected.
Definition: network_admin.cpp:34
IConsoleCmdExec
void IConsoleCmdExec(const char *cmdstr, const uint recurse_count)
Execute a given command passed to us.
Definition: console.cpp:302
NETWORK_RECV_STATUS_OKAY
@ NETWORK_RECV_STATUS_OKAY
Everything is okay.
Definition: core.h:23
CeilDiv
static uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:254
ADMIN_FREQUENCY_WEEKLY
@ ADMIN_FREQUENCY_WEEKLY
The admin gets information about this on a weekly basis.
Definition: tcp_admin.h:92
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:497
_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:45
CMD_END
@ CMD_END
Must ALWAYS be on the end of this list!! (period)
Definition: command_type.h:338
ServerNetworkAdminSocketHandler::Receive_ADMIN_CHAT
NetworkRecvStatus Receive_ADMIN_CHAT(Packet *p) override
Send chat as the server: uint8 Action such as NETWORK_ACTION_CHAT_CLIENT (see NetworkAction).
Definition: network_admin.cpp:760
NetworkAdminCmdLogging
void NetworkAdminCmdLogging(const NetworkClientSocket *owner, const CommandPacket *cp)
Distribute CommandPacket details over the admin network for logging purposes.
Definition: network_admin.cpp:954
ServerNetworkAdminSocketHandler::Receive_ADMIN_GAMESCRIPT
NetworkRecvStatus Receive_ADMIN_GAMESCRIPT(Packet *p) override
Send a JSON string to the current active GameScript.
Definition: network_admin.cpp:511
network_admin.h
CommandContainer::tile
TileIndex tile
tile command being executed on.
Definition: command_type.h:480
ServerNetworkAdminSocketHandler::SendCompanyStats
NetworkRecvStatus SendCompanyStats()
Send statistics about the companies.
Definition: network_admin.cpp:418
NETWORK_GAMESCRIPT_JSON_LENGTH
static const uint NETWORK_GAMESCRIPT_JSON_LENGTH
The maximum length of a gamescript json string, in bytes including '\0'. Must not be longer than COMP...
Definition: config.h:65
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:85
Company
Definition: company_base.h:115
AdminUpdateFrequency
AdminUpdateFrequency
Update frequencies an admin can register.
Definition: tcp_admin.h:89
ServerNetworkAdminSocketHandler::SendClientJoin
NetworkRecvStatus SendClientJoin(ClientID client_id)
Tell the admin that a client joined.
Definition: network_admin.cpp:215
NetworkAdminCompanyInfo
void NetworkAdminCompanyInfo(const Company *company, bool new_company)
Notify the admin network of company details.
Definition: network_admin.cpp:852
NetworkErrorCode
NetworkErrorCode
The error codes we send around in the protocols.
Definition: network_type.h:118
NetworkClientInfo
Container for all information known about a client.
Definition: network_base.h:24
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:838
Packet::Recv_uint16
uint16 Recv_uint16()
Read a 16 bits integer from the packet.
Definition: packet.cpp:320
ServerNetworkAdminSocketHandler::SendClientError
NetworkRecvStatus SendClientError(ClientID client_id, NetworkErrorCode error)
Tell the admin that a client made an error.
Definition: network_admin.cpp:286
ADMIN_PACKET_SERVER_SHUTDOWN
@ ADMIN_PACKET_SERVER_SHUTDOWN
The server tells the admin its shutting down.
Definition: tcp_admin.h:40
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:917
ServerNetworkAdminSocketHandler::SendCmdLogging
NetworkRecvStatus SendCmdLogging(ClientID client_id, const CommandPacket *cp)
Send a command for logging purposes.
Definition: network_admin.cpp:621