OpenTTD
network_admin.cpp
Go to the documentation of this file.
1 /* $Id: network_admin.cpp 26482 2014-04-23 20:13:33Z rubidium $ */
2 
3 /*
4  * This file is part of OpenTTD.
5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
8  */
9 
12 #ifdef ENABLE_NETWORK
13 
14 #include "../stdafx.h"
15 #include "../strings_func.h"
16 #include "../date_func.h"
17 #include "network_admin.h"
18 #include "network_base.h"
19 #include "network_server.h"
20 #include "../command_func.h"
21 #include "../company_base.h"
22 #include "../console_func.h"
23 #include "../core/pool_func.hpp"
24 #include "../map_func.h"
25 #include "../rev.h"
26 #include "../game/game.hpp"
27 
28 #include "../safeguards.h"
29 
30 
31 /* This file handles all the admin network commands. */
32 
35 
38 
41 INSTANTIATE_POOL_METHODS(NetworkAdminSocket)
42 
43 
44 static const int ADMIN_AUTHORISATION_TIMEOUT = 10000;
45 
46 
59 };
62 
68 {
72 }
73 
78 {
80  DEBUG(net, 1, "[admin] '%s' (%s) has disconnected", this->admin_name, this->admin_version);
82 }
83 
89 {
91  /* We can't go over the MAX_ADMINS limit here. However, if we accept
92  * the connection, there has to be space in the pool. */
95  return accept;
96 }
97 
100 {
104  DEBUG(net, 1, "[admin] Admin did not send its authorisation within %d seconds", ADMIN_AUTHORISATION_TIMEOUT / 1000);
105  as->CloseConnection(true);
106  continue;
107  }
108  if (as->writable) {
109  as->SendPackets();
110  }
111  }
112 }
113 
120 {
122  as->address = address; // Save the IP of the client
123 }
124 
125 /***********
126  * Sending functions for admin network
127  ************/
128 
134 {
136 
137  p->Send_uint8(error);
138  this->SendPacket(p);
139 
140  char str[100];
141  StringID strid = GetNetworkErrorMsg(error);
142  GetString(str, strid, lastof(str));
143 
144  DEBUG(net, 1, "[admin] the admin '%s' (%s) made an error and has been disconnected. Reason: '%s'", this->admin_name, this->admin_version, str);
145 
146  return this->CloseConnection(true);
147 }
148 
151 {
153 
154  /* announce the protocol version */
156 
157  for (int i = 0; i < ADMIN_UPDATE_END; i++) {
158  p->Send_bool (true);
159  p->Send_uint16(i);
161  }
162 
163  p->Send_bool(false);
164  this->SendPacket(p);
165 
166  return this->SendWelcome();
167 }
168 
171 {
173 
175  p->Send_string(_openttd_revision);
177 
182  p->Send_uint16(MapSizeX());
183  p->Send_uint16(MapSizeY());
184 
185  this->SendPacket(p);
186 
188 }
189 
192 {
194  this->SendPacket(p);
196 }
197 
200 {
202  this->SendPacket(p);
204 }
205 
208 {
210 
211  p->Send_uint32(_date);
212  this->SendPacket(p);
213 
215 }
216 
222 {
224 
225  p->Send_uint32(client_id);
226  this->SendPacket(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 == NULL) return NETWORK_RECV_STATUS_OKAY;
240 
242 
243  p->Send_uint32(ci->client_id);
244  p->Send_string(cs == NULL ? "" : const_cast<NetworkAddress &>(cs->client_address).GetHostname());
245  p->Send_string(ci->client_name);
246  p->Send_uint8 (ci->client_lang);
247  p->Send_uint32(ci->join_date);
248  p->Send_uint8 (ci->client_playas);
249 
250  this->SendPacket(p);
251 
253 }
254 
255 
261 {
263 
264  p->Send_uint32(ci->client_id);
265  p->Send_string(ci->client_name);
266  p->Send_uint8 (ci->client_playas);
267 
268  this->SendPacket(p);
269 
271 }
272 
278 {
280 
281  p->Send_uint32(client_id);
282  this->SendPacket(p);
283 
285 }
286 
293 {
295 
296  p->Send_uint32(client_id);
297  p->Send_uint8 (error);
298  this->SendPacket(p);
299 
301 }
302 
308 {
310  p->Send_uint8(company_id);
311 
312  this->SendPacket(p);
313 
315 }
316 
322 {
323  char company_name[NETWORK_COMPANY_NAME_LENGTH];
324  char manager_name[NETWORK_COMPANY_NAME_LENGTH];
325 
326  SetDParam(0, c->index);
327  GetString(company_name, STR_COMPANY_NAME, lastof(company_name));
328 
329  SetDParam(0, c->index);
330  GetString(manager_name, STR_PRESIDENT_NAME, lastof(manager_name));
331 
333 
334  p->Send_uint8 (c->index);
335  p->Send_string(company_name);
336  p->Send_string(manager_name);
337  p->Send_uint8 (c->colour);
340  p->Send_bool (c->is_ai);
341  p->Send_uint8 (CeilDiv(c->months_of_bankruptcy, 3)); // send as quarters_of_bankruptcy
342 
343  for (size_t i = 0; i < lengthof(c->share_owners); i++) {
344  p->Send_uint8(c->share_owners[i]);
345  }
346 
347  this->SendPacket(p);
348 
350 }
351 
352 
358 {
359  char company_name[NETWORK_COMPANY_NAME_LENGTH];
360  char manager_name[NETWORK_COMPANY_NAME_LENGTH];
361 
362  SetDParam(0, c->index);
363  GetString(company_name, STR_COMPANY_NAME, lastof(company_name));
364 
365  SetDParam(0, c->index);
366  GetString(manager_name, STR_PRESIDENT_NAME, lastof(manager_name));
367 
369 
370  p->Send_uint8 (c->index);
371  p->Send_string(company_name);
372  p->Send_string(manager_name);
373  p->Send_uint8 (c->colour);
375  p->Send_uint8 (CeilDiv(c->months_of_bankruptcy, 3)); // send as quarters_of_bankruptcy
376 
377  for (size_t i = 0; i < lengthof(c->share_owners); i++) {
378  p->Send_uint8(c->share_owners[i]);
379  }
380 
381  this->SendPacket(p);
382 
384 }
385 
392 {
394 
395  p->Send_uint8(company_id);
396  p->Send_uint8(acrr);
397 
398  this->SendPacket(p);
399 
401 }
402 
405 {
406  const Company *company;
407  FOR_ALL_COMPANIES(company) {
408  /* Get the income. */
409  Money income = 0;
410  for (uint i = 0; i < lengthof(company->yearly_expenses[0]); i++) {
411  income -= company->yearly_expenses[0][i];
412  }
413 
415 
416  p->Send_uint8(company->index);
417 
418  /* Current information. */
419  p->Send_uint64(company->money);
420  p->Send_uint64(company->current_loan);
421  p->Send_uint64(income);
422  p->Send_uint16(min(UINT16_MAX, company->cur_economy.delivered_cargo.GetSum<OverflowSafeInt64>()));
423 
424  /* Send stats for the last 2 quarters. */
425  for (uint i = 0; i < 2; i++) {
426  p->Send_uint64(company->old_economy[i].company_value);
428  p->Send_uint16(min(UINT16_MAX, company->old_economy[i].delivered_cargo.GetSum<OverflowSafeInt64>()));
429  }
430 
431  this->SendPacket(p);
432  }
433 
434 
436 }
437 
440 {
441  /* Fetch the latest version of the stats. */
442  NetworkCompanyStats company_stats[MAX_COMPANIES];
443  NetworkPopulateCompanyStats(company_stats);
444 
445  const Company *company;
446 
447  /* Go through all the companies. */
448  FOR_ALL_COMPANIES(company) {
450 
451  /* Send the information. */
452  p->Send_uint8(company->index);
453 
454  for (uint i = 0; i < NETWORK_VEH_END; i++) {
455  p->Send_uint16(company_stats[company->index].num_vehicle[i]);
456  }
457 
458  for (uint i = 0; i < NETWORK_VEH_END; i++) {
459  p->Send_uint16(company_stats[company->index].num_station[i]);
460  }
461 
462  this->SendPacket(p);
463  }
464 
466 }
467 
476 NetworkRecvStatus ServerNetworkAdminSocketHandler::SendChat(NetworkAction action, DestType desttype, ClientID client_id, const char *msg, int64 data)
477 {
479 
480  p->Send_uint8 (action);
481  p->Send_uint8 (desttype);
482  p->Send_uint32(client_id);
483  p->Send_string(msg);
484  p->Send_uint64(data);
485 
486  this->SendPacket(p);
488 }
489 
495 {
497 
498  p->Send_string(command);
499  this->SendPacket(p);
500 
502 }
503 
510 {
512 
513  p->Send_uint16(colour);
514  p->Send_string(result);
515  this->SendPacket(p);
516 
518 }
519 
521 {
522  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
523 
524  char command[NETWORK_RCONCOMMAND_LENGTH];
525 
526  p->Recv_string(command, sizeof(command));
527 
528  DEBUG(net, 2, "[admin] Rcon command from '%s' (%s): '%s'", this->admin_name, this->admin_version, command);
529 
531  IConsoleCmdExec(command);
533  return this->SendRconEnd(command);
534 }
535 
537 {
538  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
539 
541 
542  p->Recv_string(json, sizeof(json));
543 
544  DEBUG(net, 2, "[admin] GameScript JSON from '%s' (%s): '%s'", this->admin_name, this->admin_version, json);
545 
546  Game::NewEvent(new ScriptEventAdminPort(json));
548 }
549 
551 {
552  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
553 
554  uint32 d1 = p->Recv_uint32();
555 
556  DEBUG(net, 2, "[admin] Ping from '%s' (%s): '%d'", this->admin_name, this->admin_version, d1);
557 
558  return this->SendPong(d1);
559 }
560 
567 {
568  /* If the length of both strings, plus the 2 '\0' terminations and 3 bytes of the packet
569  * are bigger than the MTU, just ignore the message. Better safe than sorry. It should
570  * never occur though as the longest strings are chat messages, which are still 30%
571  * smaller than SEND_MTU. */
572  if (strlen(origin) + strlen(string) + 2 + 3 >= SEND_MTU) return NETWORK_RECV_STATUS_OKAY;
573 
575 
576  p->Send_string(origin);
577  p->Send_string(string);
578  this->SendPacket(p);
579 
581 }
582 
588 {
589  /* At the moment we cannot transmit anything larger than MTU. So we limit
590  * the maximum amount of json data that can be sent. Account also for
591  * the trailing \0 of the string */
592  if (strlen(json) + 1 >= NETWORK_GAMESCRIPT_JSON_LENGTH) return NETWORK_RECV_STATUS_OKAY;
593 
595 
596  p->Send_string(json);
597  this->SendPacket(p);
598 
600 }
601 
604 {
606 
607  p->Send_uint32(d1);
608  this->SendPacket(p);
609 
611 }
612 
615 {
617 
618  for (uint i = 0; i < CMD_END; i++) {
619  const char *cmdname = GetCommandName(i);
620 
621  /* Should SEND_MTU be exceeded, start a new packet
622  * (magic 5: 1 bool "more data" and one uint16 "command id", one
623  * byte for string '\0' termination and 1 bool "no more data" */
624  if (p->size + strlen(cmdname) + 5 >= SEND_MTU) {
625  p->Send_bool(false);
626  this->SendPacket(p);
627 
629  }
630 
631  p->Send_bool(true);
632  p->Send_uint16(i);
633  p->Send_string(cmdname);
634  }
635 
636  /* Marker to notify the end of the packet has been reached. */
637  p->Send_bool(false);
638  this->SendPacket(p);
639 
641 }
642 
649 {
651 
652  p->Send_uint32(client_id);
653  p->Send_uint8 (cp->company);
654  p->Send_uint16(cp->cmd & CMD_ID_MASK);
655  p->Send_uint32(cp->p1);
656  p->Send_uint32(cp->p2);
657  p->Send_uint32(cp->tile);
658  p->Send_string(cp->text);
659  p->Send_uint32(cp->frame);
660 
661  this->SendPacket(p);
662 
664 }
665 
666 /***********
667  * Receiving functions
668  ************/
669 
671 {
672  if (this->status != ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
673 
674  char password[NETWORK_PASSWORD_LENGTH];
675  p->Recv_string(password, sizeof(password));
676 
678  strcmp(password, _settings_client.network.admin_password) != 0) {
679  /* Password is invalid */
680  return this->SendError(NETWORK_ERROR_WRONG_PASSWORD);
681  }
682 
683  p->Recv_string(this->admin_name, sizeof(this->admin_name));
684  p->Recv_string(this->admin_version, sizeof(this->admin_version));
685 
686  if (StrEmpty(this->admin_name) || StrEmpty(this->admin_version)) {
687  /* no name or version supplied */
688  return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
689  }
690 
691  this->status = ADMIN_STATUS_ACTIVE;
692 
693  DEBUG(net, 1, "[admin] '%s' (%s) has connected", this->admin_name, this->admin_version);
694 
695  return this->SendProtocol();
696 }
697 
699 {
700  /* The admin is leaving nothing else to do */
701  return this->CloseConnection();
702 }
703 
705 {
706  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
707 
710 
711  if (type >= ADMIN_UPDATE_END || (_admin_update_type_frequencies[type] & freq) != freq) {
712  /* The server does not know of this UpdateType. */
713  DEBUG(net, 3, "[admin] Not supported update frequency %d (%d) from '%s' (%s).", type, freq, this->admin_name, this->admin_version);
714  return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
715  }
716 
717  this->update_frequency[type] = freq;
718 
720 }
721 
723 {
724  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
725 
727  uint32 d1 = p->Recv_uint32();
728 
729  switch (type) {
730  case ADMIN_UPDATE_DATE:
731  /* The admin is requesting the current date. */
732  this->SendDate();
733  break;
734 
736  /* The admin is requesting client info. */
737  const NetworkClientSocket *cs;
738  if (d1 == UINT32_MAX) {
741  this->SendClientInfo(cs, cs->GetInfo());
742  }
743  } else {
744  if (d1 == CLIENT_ID_SERVER) {
746  } else {
747  cs = NetworkClientSocket::GetByClientID((ClientID)d1);
748  if (cs != NULL) this->SendClientInfo(cs, cs->GetInfo());
749  }
750  }
751  break;
752 
754  /* The admin is asking for company info. */
755  const Company *company;
756  if (d1 == UINT32_MAX) {
757  FOR_ALL_COMPANIES(company) {
758  this->SendCompanyInfo(company);
759  }
760  } else {
761  company = Company::GetIfValid(d1);
762  if (company != NULL) this->SendCompanyInfo(company);
763  }
764  break;
765 
767  /* The admin is requesting economy info. */
768  this->SendCompanyEconomy();
769  break;
770 
772  /* the admin is requesting company stats. */
773  this->SendCompanyStats();
774  break;
775 
777  /* The admin is requesting the names of DoCommands. */
778  this->SendCmdNames();
779  break;
780 
781  default:
782  /* An unsupported "poll" update type. */
783  DEBUG(net, 3, "[admin] Not supported poll %d (%d) from '%s' (%s).", type, d1, this->admin_name, this->admin_version);
784  return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
785  }
786 
788 }
789 
791 {
792  if (this->status == ADMIN_STATUS_INACTIVE) return this->SendError(NETWORK_ERROR_NOT_EXPECTED);
793 
794  NetworkAction action = (NetworkAction)p->Recv_uint8();
795  DestType desttype = (DestType)p->Recv_uint8();
796  int dest = p->Recv_uint32();
797 
798  char msg[NETWORK_CHAT_LENGTH];
800 
801  switch (action) {
802  case NETWORK_ACTION_CHAT:
803  case NETWORK_ACTION_CHAT_CLIENT:
804  case NETWORK_ACTION_CHAT_COMPANY:
805  case NETWORK_ACTION_SERVER_MESSAGE:
806  NetworkServerSendChat(action, desttype, dest, msg, _network_own_client_id, 0, true);
807  break;
808 
809  default:
810  DEBUG(net, 3, "[admin] Invalid chat action %d from admin '%s' (%s).", action, this->admin_name, this->admin_version);
811  return this->SendError(NETWORK_ERROR_ILLEGAL_PACKET);
812  }
813 
815 }
816 
817 /*
818  * Useful wrapper functions
819  */
820 
826 void NetworkAdminClientInfo(const NetworkClientSocket *cs, bool new_client)
827 {
831  as->SendClientInfo(cs, cs->GetInfo());
832  if (new_client) {
833  as->SendClientJoin(cs->client_id);
834  }
835  }
836  }
837 }
838 
844 {
848  as->SendClientUpdate(ci);
849  }
850  }
851 }
852 
858 {
862  as->SendClientQuit(client_id);
863  }
864  }
865 }
866 
873 {
877  as->SendClientError(client_id, error_code);
878  }
879  }
880 }
881 
887 void NetworkAdminCompanyInfo(const Company *company, bool new_company)
888 {
889  if (company == NULL) {
890  DEBUG(net, 1, "[admin] Empty company given for update");
891  return;
892  }
893 
897 
898  as->SendCompanyInfo(company);
899  if (new_company) {
900  as->SendCompanyNew(company->index);
901  }
902  }
903 }
904 
909 void NetworkAdminCompanyUpdate(const Company *company)
910 {
911  if (company == NULL) return;
912 
916 
917  as->SendCompanyUpdate(company);
918  }
919 }
920 
927 {
930  as->SendCompanyRemove(company_id, bcrr);
931  }
932 }
933 
934 
938 void NetworkAdminChat(NetworkAction action, DestType desttype, ClientID client_id, const char *msg, int64 data, bool from_admin)
939 {
940  if (from_admin) return;
941 
945  as->SendChat(action, desttype, client_id, msg, data);
946  }
947  }
948 }
949 
956 void NetworkServerSendAdminRcon(AdminIndex admin_index, TextColour colour_code, const char *string)
957 {
958  ServerNetworkAdminSocketHandler::Get(admin_index)->SendRcon(colour_code, string);
959 }
960 
966 void NetworkAdminConsole(const char *origin, const char *string)
967 {
971  as->SendConsole(origin, string);
972  }
973  }
974 }
975 
980 void NetworkAdminGameScript(const char *json)
981 {
985  as->SendGameScript(json);
986  }
987  }
988 }
989 
995 void NetworkAdminCmdLogging(const NetworkClientSocket *owner, const CommandPacket *cp)
996 {
997  ClientID client_id = owner == NULL ? _network_own_client_id : owner->client_id;
998 
1002  as->SendCmdLogging(client_id, cp);
1003  }
1004  }
1005 }
1006 
1011 {
1014  as->SendWelcome();
1015  }
1016 }
1017 
1023 {
1026  for (int i = 0; i < ADMIN_UPDATE_END; i++) {
1027  if (as->update_frequency[i] & freq) {
1028  /* Update the admin for the required details */
1029  switch (i) {
1030  case ADMIN_UPDATE_DATE:
1031  as->SendDate();
1032  break;
1033 
1035  as->SendCompanyEconomy();
1036  break;
1037 
1039  as->SendCompanyStats();
1040  break;
1041 
1042  default: NOT_REACHED();
1043  }
1044  }
1045  }
1046  }
1047 }
1048 
1049 #endif /* ENABLE_NETWORK */
Everything is okay.
Definition: core.h:27
char admin_name[NETWORK_CLIENT_NAME_LENGTH]
Name of the admin.
Definition: tcp_admin.h:116
The admin would like to have console messages.
Definition: tcp_admin.h:85
static const byte NETWORK_GAME_ADMIN_VERSION
What version of the admin network do we use?
Definition: config.h:37
void NetworkAdminCompanyUpdate(const Company *company)
Notify the admin network of company updates.
static uint MapSizeX()
Get the size of the map along the X.
Definition: map_func.h:74
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:77
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:134
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:257
const char * GetCommandName(uint32 cmd)
Definition: command.cpp:393
static uint MapSizeY()
Get the size of the map along the Y.
Definition: map_func.h:84
#define FOR_ALL_ACTIVE_ADMIN_SOCKETS(var)
Iterate over all the active sockets.
Container for all information known about a client.
Definition: network_base.h:27
NetworkRecvStatus SendClientUpdate(const NetworkClientInfo *ci)
Send an update for some client&#39;s information.
uint32 _realtime_tick
The real time in the game.
Definition: debug.cpp:48
Internal entity of a packet.
Definition: packet.h:44
The server replies to a ping request from the admin.
Definition: tcp_admin.h:65
AdminCompanyRemoveReason
Reasons for removing a company - communicated to admins.
Definition: tcp_admin.h:105
byte landscape
the landscape we&#39;re currently in
static void WelcomeAll()
Send a Welcome packet to all connected admins.
The admin would like to have chat messages.
Definition: tcp_admin.h:84
uint32 Recv_uint32()
Read a 32 bits integer from the packet.
Definition: packet.cpp:250
The server gives the admin information from the GameScript in JSON.
Definition: tcp_admin.h:63
char server_name[NETWORK_NAME_LENGTH]
name of the server
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:246
int32 performance_history
Company score (scale 0-1000)
Definition: company_base.h:27
The server tells the admin its going to start a new game.
Definition: tcp_admin.h:43
void NetworkAdminGameScript(const char *json)
Send GameScript JSON to the admin network (if they did opt in for the respective update).
void Send_string(const char *data)
Sends a string over the network.
Definition: packet.cpp:152
Year inaugurated_year
Year of starting the company.
Definition: company_base.h:79
The server tells the admin its shutting down.
Definition: tcp_admin.h:44
void NetworkPopulateCompanyStats(NetworkCompanyStats *stats)
Populate the company stats.
NetworkErrorCode
The error codes we send around in the protocols.
Definition: network_type.h:104
The server received a chat message and relays it.
Definition: tcp_admin.h:58
The server tells the admin that a new company has started.
Definition: tcp_admin.h:52
The server tells the admin its protocol version.
Definition: tcp_admin.h:41
ClientID client_id
Client identifier (same as ClientState->client_id)
Definition: network_base.h:28
The admin would like a list of all DoCommand names.
Definition: tcp_admin.h:86
void Send_uint8(uint8 data)
Package a 8 bits integer in the packet.
Definition: packet.cpp:100
NetworkRecvStatus SendWelcome()
Send a welcome message to the admin.
uint32 p2
parameter p2.
Definition: command_type.h:475
The server tells the admin that a client quit.
Definition: tcp_admin.h:50
static void Send()
Send the packets for the server sockets.
Wrapper for (un)resolved network addresses; there&#39;s no reason to transform a numeric IP to a string a...
Definition: address.h:31
Tindex index
Index of this pool item.
Definition: pool_type.hpp:147
byte months_of_bankruptcy
Number of months that the company is unable to pay its debts.
Definition: company_base.h:81
static const AdminIndex INVALID_ADMIN_ID
An invalid admin marker.
Definition: network_type.h:58
The server tells the admin an error has occurred.
Definition: tcp_admin.h:40
void Send_uint32(uint32 data)
Package a 32 bits integer in the packet.
Definition: packet.cpp:121
#define lastof(x)
Get the last element of an fixed size array.
Definition: depend.cpp:50
static void AcceptConnection(SOCKET s, const NetworkAddress &address)
Handle the acception of a connection.
Updates about the information of clients.
Definition: tcp_admin.h:80
bool NetworkCompanyIsPassworded(CompanyID company_id)
Check if the company we want to join requires a password.
Definition: network.cpp:225
char admin_version[NETWORK_REVISION_LENGTH]
Version string of the admin.
Definition: tcp_admin.h:117
Base core network types and some helper functions to access them.
AdminIndex _redirect_console_to_admin
Redirection of the (remote) console to the admin.
uint32 realtime_connect
Time of connection.
Definition: network_admin.h:44
The admin gets information about this on a daily basis.
Definition: tcp_admin.h:95
virtual NetworkRecvStatus Receive_ADMIN_UPDATE_FREQUENCY(Packet *p)
Register updates to be sent at certain frequencies (as announced in the PROTOCOL packet): uint16 Upda...
char text[32 *MAX_CHAR_LENGTH]
possible text sent for name changes etc, in bytes including &#39;\0&#39;.
Definition: command_type.h:478
The server tells the admin what the current game date is.
Definition: tcp_admin.h:46
SendPacketsState SendPackets(bool closing_down=false)
Sends all the buffered packets out for this client.
Definition: tcp.cpp:99
The admin would like to have DoCommand information.
Definition: tcp_admin.h:87
AdminUpdateFrequency
Update frequencies an admin can register.
Definition: tcp_admin.h:93
NetworkRecvStatus SendConsole(const char *origin, const char *command)
Send console output of other clients.
StringID GetNetworkErrorMsg(NetworkErrorCode err)
Retrieve the string id of an internal error number.
Definition: network.cpp:310
Servers always have this ID.
Definition: network_type.h:45
The admin gets information about this on a monthly basis.
Definition: tcp_admin.h:97
bool _network_dedicated
are we a dedicated server?
Definition: network.cpp:59
NetworkRecvStatus SendCompanyRemove(CompanyID company_id, AdminCompanyRemoveReason bcrr)
Tell the admin that a company got removed.
The server gives the admin some statistics about a company.
Definition: tcp_admin.h:57
uint16 num_vehicle[NETWORK_VEH_END]
How many vehicles are there of this type?
Definition: network_type.h:62
static const size_t MAX_SIZE
Make template parameter accessible from outside.
Definition: pool_type.hpp:87
void NetworkAdminClientQuit(ClientID client_id)
Notify the admin network that a client quit (if they have opt in for the respective update)...
void NetworkAdminConsole(const char *origin, const char *string)
Send console to the admin network (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 NetworkAdminUpdate(AdminUpdateFrequency freq)
Send (push) updates to the admin network as they have registered for these updates.
NetworkSettings network
settings related to the network
NetworkRecvStatus SendDate()
Tell the admin the date.
CompanyID client_playas
As which company is this client playing (CompanyID)
Definition: network_base.h:31
static const uint NETWORK_RCONCOMMAND_LENGTH
The maximum length of a rconsole command, in bytes including &#39;\0&#39;.
Definition: config.h:50
AdminStatus status
Status of this admin.
Definition: tcp_admin.h:118
void Send_uint64(uint64 data)
Package a 64 bits integer in the packet.
Definition: packet.cpp:134
The admin can poll this.
Definition: tcp_admin.h:94
The server&#39;s reply to a remove console command.
Definition: tcp_admin.h:59
virtual NetworkRecvStatus Receive_ADMIN_JOIN(Packet *p)
Join the admin network: string Password the server is expecting for this network. ...
NetworkRecvStatus SendCompanyEconomy()
Send economic information of all companies.
char client_name[NETWORK_CLIENT_NAME_LENGTH]
Name of the client.
Definition: network_base.h:29
Updates about the statistics of companies.
Definition: tcp_admin.h:83
Server part of the network protocol.
The server gives the admin an information update on a client.
Definition: tcp_admin.h:49
NetworkRecvStatus SendRcon(uint16 colour, const char *command)
Send the reply of an rcon command.
void Send_uint16(uint16 data)
Package a 16 bits integer in the packet.
Definition: packet.cpp:110
Updates about the economy of companies.
Definition: tcp_admin.h:82
mask for the command ID
Definition: command_type.h:376
uint32 p1
parameter p1.
Definition: command_type.h:474
NetworkRecvStatus SendClientInfo(const NetworkClientSocket *cs, const NetworkClientInfo *ci)
Send an initial set of data from some client&#39;s information.
The admin is not connected nor active.
Definition: tcp_admin.h:72
AdminUpdateFrequency update_frequency[ADMIN_UPDATE_END]
Admin requested update intervals.
Definition: network_admin.h:43
NetworkRecvStatus SendClientQuit(ClientID client_id)
Tell the admin that a client quit.
bool writable
Can we write to this socket?
Definition: tcp.h:37
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)...
virtual NetworkRecvStatus Receive_ADMIN_CHAT(Packet *p)
Send chat as the server: uint8 Action such as NETWORK_ACTION_CHAT_CLIENT (see NetworkAction).
virtual NetworkRecvStatus Receive_ADMIN_GAMESCRIPT(Packet *p)
Send a JSON string to the current active GameScript.
Money current_loan
Amount of money borrowed from the bank.
Definition: company_base.h:66
void IConsoleCmdExec(const char *cmdstr)
Execute a given command passed to us.
Definition: console.cpp:409
~ServerNetworkAdminSocketHandler()
Clear everything related to this admin.
ClientID _network_own_client_id
Our client identifier.
Definition: network.cpp:63
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:76
NetworkRecvStatus SendRconEnd(const char *command)
Send a notification indicating the rcon command has completed.
virtual NetworkRecvStatus Receive_ADMIN_POLL(Packet *p)
Poll the server for certain updates, an invalid poll (e.g.
NetworkRecvStatus SendClientJoin(ClientID client_id)
Tell the admin that a client joined.
The admin gets information about this on a quarterly basis.
Definition: tcp_admin.h:98
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
Definition: gfx_type.h:247
The admin would like to have gamescript messages.
Definition: tcp_admin.h:88
NetworkRecvStatus SendNewGame()
Tell the admin we started a new game.
static uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:316
virtual NetworkRecvStatus Receive_ADMIN_RCON(Packet *p)
Execute a command on the servers console: string Command to be executed.
NetworkRecvStatus SendCmdNames()
Send the names of the commands.
NetworkRecvStatus
Status of a network client; reasons why a client has quit.
Definition: core.h:26
The server indicates that the remote console command has completed.
Definition: tcp_admin.h:64
NetworkRecvStatus SendCompanyUpdate(const Company *c)
Send an update about a company.
static const uint NETWORK_CHAT_LENGTH
The maximum length of a chat message, in bytes including &#39;\0&#39;.
Definition: config.h:52
bool is_ai
If true, the company is (also) controlled by the computer (a NoAI program).
Definition: company_base.h:94
Money money
Money owned by the company.
Definition: company_base.h:64
Updates about the date of the game.
Definition: tcp_admin.h:79
void NetworkAdminChat(NetworkAction action, DestType desttype, ClientID client_id, const char *msg, int64 data, bool from_admin)
Send chat to the admin network (if they did opt in for the respective update).
PacketSize size
The size of the whole packet for received packets.
Definition: packet.h:52
NetworkRecvStatus SendCompanyInfo(const Company *c)
Send the admin some information about a company.
CompanyID company
company that is executing the command
byte _network_admins_connected
The amount of admins connected.
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:42
NetworkServerGameInfo _network_game_info
Information about our game.
Definition: network.cpp:61
virtual NetworkRecvStatus Receive_ADMIN_QUIT(Packet *p)
Notification to the server that this admin is quitting.
static T min(const T a, const T b)
Returns the minimum of two values.
Definition: math_func.hpp:42
static bool AllowConnection()
Whether a connection is allowed or not at this moment.
The server tells the admin that a company was removed.
Definition: tcp_admin.h:55
static const AdminIndex MAX_ADMINS
Maximum number of allowed admins.
Definition: network_type.h:56
The server sends out the names of the DoCommands to the admins.
Definition: tcp_admin.h:61
#define FOR_ALL_CLIENT_SOCKETS(var)
Iterate over all the sockets.
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).
uint32 frame
the frame in which this packet is executed
uint32 StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:18
The server tells the admin that a client caused an error.
Definition: tcp_admin.h:51
Maximum number of companies.
Definition: company_type.h:25
void NetworkServerSendAdminRcon(AdminIndex admin_index, TextColour colour_code, const char *string)
Pass the rcon reply to the admin.
The server gives the admin the data that got printed to its console.
Definition: tcp_admin.h:60
uint8 AdminIndex
Indices into the admin tables.
Definition: network_type.h:53
static const uint NETWORK_GAMESCRIPT_JSON_LENGTH
The maximum length of a gamescript json string, in bytes including &#39;\0&#39;. Must not be longer than SEND...
Definition: config.h:51
Date join_date
Gamedate the client has joined.
Definition: network_base.h:32
void NetworkAdminCompanyRemove(CompanyID company_id, AdminCompanyRemoveReason bcrr)
Notify the admin network of a company to be removed (including the reason why).
Base class for all pools.
Definition: pool_type.hpp:83
NetworkRecvStatus SendError(NetworkErrorCode error)
Send an error to the admin.
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:39
The server gives the admin an information update on a company.
Definition: tcp_admin.h:54
char map_name[NETWORK_NAME_LENGTH]
Map which is played ["random" for a randomized map].
Definition: game.h:29
assert_compile(lengthof(_admin_update_type_frequencies)==ADMIN_UPDATE_END)
Sanity check.
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don&#39;t get linker errors.
Definition: pool_func.hpp:224
NetworkRecvStatus SendProtocol()
Send the protocol version to the admin.
uint8 Recv_uint8()
Read a 8 bits integer from the packet.
Definition: packet.cpp:221
void NetworkServerSendChat(NetworkAction action, DestType type, int dest, const char *msg, ClientID from_id, int64 data=0, bool from_admin=false)
Send an actual chat message.
uint32 generation_seed
noise seed for world generation
NetworkRecvStatus SendClientError(ClientID client_id, NetworkErrorCode error)
Tell the admin that a client made an error.
The admin gets information about this on a yearly basis.
Definition: tcp_admin.h:99
static bool StrEmpty(const char *s)
Check if a string buffer is empty.
Definition: string_func.h:59
static const AdminUpdateFrequency _admin_update_type_frequencies[]
Frequencies, which may be registered for a certain update type.
Must ALWAYS be on the end of this list!! (period)
Definition: command_type.h:332
The server tells the admin that a client has joined.
Definition: tcp_admin.h:47
OwnerByte share_owners[4]
Owners of the 4 shares of the company. INVALID_OWNER if nobody has bought them yet.
Definition: company_base.h:77
The admin gets information about this on a weekly basis.
Definition: tcp_admin.h:96
byte colour
Company colour.
Definition: company_base.h:68
CargoArray delivered_cargo
The amount of delivered cargo.
Definition: company_base.h:26
NetworkRecvStatus SendGameScript(const char *json)
Send GameScript JSON output.
ClientID
&#39;Unique&#39; identifier to be given to clients
Definition: network_type.h:43
static const uint NETWORK_COMPANY_NAME_LENGTH
The maximum length of the company name, in bytes including &#39;\0&#39;.
Definition: config.h:43
void CDECL error(const char *s,...)
Error handling for fatal non-user errors.
Definition: openttd.cpp:110
ServerNetworkAdminSocketHandler(SOCKET s)
Create a new socket for the server side of the admin network.
uint16 num_station[NETWORK_VEH_END]
How many stations are there of this type?
Definition: network_type.h:63
CompanyEconomyEntry old_economy[MAX_HISTORY_QUARTERS]
Economic data of the company of the last MAX_HISTORY_QUARTERS quarters.
Definition: company_base.h:98
Class for handling the server side of the game connection.
Definition: network_admin.h:29
Must ALWAYS be on the end of this list!! (period)
Definition: tcp_admin.h:89
void NetworkAdminCompanyInfo(const Company *company, bool new_company)
Notify the admin network of company details.
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function() ...
Definition: pool_type.hpp:216
The server gives the admin information about a client.
Definition: tcp_admin.h:48
static const uint16 SEND_MTU
Number of bytes we can pack in a single packet.
Definition: config.h:35
char admin_password[NETWORK_PASSWORD_LENGTH]
password for the admin network
Main socket handler for admin related connections.
Definition: tcp_admin.h:114
NetworkRecvStatus SendCompanyStats()
Send statistics about the companies.
TileIndex tile
tile command being executed on.
Definition: command_type.h:473
The server welcomes the admin to a game.
Definition: tcp_admin.h:42
NetworkRecvStatus SendChat(NetworkAction action, DestType desttype, ClientID client_id, const char *msg, int64 data)
Send a chat message.
Everything we need to know about a command to be able to execute it.
Money yearly_expenses[3][EXPENSES_END]
Expenses of the company for the last three years, in every #Expenses category.
Definition: company_base.h:96
NetworkRecvStatus SendShutdown()
Tell the admin we&#39;re shutting down.
The admin gets information about this when it changes.
Definition: tcp_admin.h:100
The admin is active.
Definition: tcp_admin.h:73
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:65
Simple calculated statistics of a company.
Definition: network_type.h:61
static const uint NETWORK_PASSWORD_LENGTH
The maximum length of the password, in bytes including &#39;\0&#39; (must be >= NETWORK_SERVER_ID_LENGTH) ...
Definition: config.h:47
void NetworkAdminClientUpdate(const NetworkClientInfo *ci)
Notify the admin network of a client update (if they did opt in for the respective update)...
The server gives the admin copies of incoming command packets.
Definition: tcp_admin.h:62
GameCreationSettings game_creation
settings used during the creation of a game (map)
Date ConvertYMDToDate(Year year, Month month, Day day)
Converts a tuple of Year, Month and Day to a Date.
Definition: date.cpp:149
#define FOR_ALL_ADMIN_SOCKETS(var)
Iterate over all the sockets.
uint16 Recv_uint16()
Read a 16 bits integer from the packet.
Definition: packet.cpp:235
Owner
Enum for all companies/owners.
Definition: company_type.h:20
void Send_bool(bool data)
Package a boolean in the packet.
Definition: packet.cpp:91
Money company_value
The value of the company.
Definition: company_base.h:28
NetworkRecvStatus SendCmdLogging(ClientID client_id, const CommandPacket *cp)
Send a command for logging purposes.
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it&#39;s client-identifier.
Definition: network.cpp:126
NetworkAdminSocketPool _networkadminsocket_pool("NetworkAdminSocket")
The pool with sockets/clients.
Updates about the generic information of companies.
Definition: tcp_admin.h:81
The server gives the admin some economy related company information.
Definition: tcp_admin.h:56
CompanyEconomyEntry cur_economy
Economic data of the company of this quarter.
Definition: company_base.h:97
virtual NetworkRecvStatus Receive_ADMIN_PING(Packet *p)
Ping the server, requiring the server to reply with a pong packet.
Date _date
Current date in days (day counter)
Definition: date.cpp:28
NetworkRecvStatus SendCompanyNew(CompanyID company_id)
Tell the admin that a new company was founded.
AdminUpdateType
Update types an admin can register a frequency for.
Definition: tcp_admin.h:78
Year starting_year
starting date
uint32 cmd
command being executed.
Definition: command_type.h:476
NetworkRecvStatus CloseConnection(bool error=true)
Close the current connection; for TCP this will be mostly equivalent to Close(), but for UDP it just ...
Definition: tcp_admin.cpp:45
DestType
Destination of our chat messages.
Definition: network_type.h:82
byte client_lang
The language of the client.
Definition: network_base.h:30
static const int ADMIN_AUTHORISATION_TIMEOUT
The timeout for authorisation of the client.
NetworkAction
Actions that can be used for NetworkTextMessage.
Definition: network_type.h:89
NetworkRecvStatus SendPong(uint32 d1)
Send ping-reply (pong) to admin.
const T GetSum() const
Get the sum of all cargo amounts.
Definition: cargo_type.h:114
NetworkAddress address
Address of the admin.
Definition: network_admin.h:45
void Recv_string(char *buffer, size_t size, StringValidationSettings settings=SVS_REPLACE_WITH_QUESTION_MARK)
Reads a string till it finds a &#39;\0&#39; in the stream.
Definition: packet.cpp:290
Server part of the admin network protocol.
The server gives the admin information about a company.
Definition: tcp_admin.h:53
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:201