1 /* $Id$ */

     2 

     3 #ifndef NETWORK_DATA_H

     4 #define NETWORK_DATA_H

     5 

     6 #include "openttd.h"

     7 #include "network.h"

     8 #include "network_core.h"

     9 

    10 // Is the network enabled?

    11 #ifdef ENABLE_NETWORK

    12 

    13 #define SEND_MTU 1460

    14 #define MAX_TEXT_MSG_LEN 1024 /* long long long long sentences :-) */

    15 

    16 // The client-info-server-index is always 1

    17 #define NETWORK_SERVER_INDEX 1

    18 #define NETWORK_EMPTY_INDEX 0

    19 

    20 // What version of game-info do we use?

    21 #define NETWORK_GAME_INFO_VERSION 4

    22 // What version of company info is this?

    23 #define NETWORK_COMPANY_INFO_VERSION 4

    24 // What version of master-server-protocol do we use?

    25 #define NETWORK_MASTER_SERVER_VERSION 1

    26 

    27 typedef uint16 PacketSize;

    28 

    29 typedef struct Packet {

    30 	struct Packet *next;

    31 	PacketSize size;

    32 	PacketSize pos;

    33 	byte buffer[SEND_MTU];

    34 } Packet;

    35 

    36 typedef struct CommandPacket {

    37 	struct CommandPacket *next;

    38 	PlayerID player; /// player that is executing the command

    39 	uint32 cmd;    /// command being executed

    40 	uint32 p1;     /// parameter p1

    41 	uint32 p2;     /// parameter p2

    42 	TileIndex tile; /// tile command being executed on

    43 	char text[80];

    44 	uint32 frame;  /// the frame in which this packet is executed

    45 	byte callback; /// any callback function executed upon successful completion of the command

    46 } CommandPacket;

    47 

    48 typedef enum {

    49 	STATUS_INACTIVE,

    50 	STATUS_AUTH, // This means that the client is authorized

    51 	STATUS_MAP_WAIT, // This means that the client is put on hold because someone else is getting the map

    52 	STATUS_MAP,

    53 	STATUS_DONE_MAP,

    54 	STATUS_PRE_ACTIVE,

    55 	STATUS_ACTIVE,

    56 } ClientStatus;

    57 

    58 typedef enum {

    59 	MAP_PACKET_START,

    60 	MAP_PACKET_NORMAL,

    61 	MAP_PACKET_END,

    62 } MapPacket;

    63 

    64 typedef enum {

    65 	NETWORK_RECV_STATUS_OKAY,

    66 	NETWORK_RECV_STATUS_DESYNC,

    67 	NETWORK_RECV_STATUS_SAVEGAME,

    68 	NETWORK_RECV_STATUS_CONN_LOST,

    69 	NETWORK_RECV_STATUS_MALFORMED_PACKET,

    70 	NETWORK_RECV_STATUS_SERVER_ERROR, // The server told us we made an error

    71 	NETWORK_RECV_STATUS_SERVER_FULL,

    72 	NETWORK_RECV_STATUS_SERVER_BANNED,

    73 	NETWORK_RECV_STATUS_CLOSE_QUERY, // Done quering the server

    74 } NetworkRecvStatus;

    75 

    76 typedef enum {

    77 	NETWORK_ERROR_GENERAL, // Try to use thisone like never

    78 

    79 	// Signals from clients

    80 	NETWORK_ERROR_DESYNC,

    81 	NETWORK_ERROR_SAVEGAME_FAILED,

    82 	NETWORK_ERROR_CONNECTION_LOST,

    83 	NETWORK_ERROR_ILLEGAL_PACKET,

    84 

    85 	// Signals from servers

    86 	NETWORK_ERROR_NOT_AUTHORIZED,

    87 	NETWORK_ERROR_NOT_EXPECTED,

    88 	NETWORK_ERROR_WRONG_REVISION,

    89 	NETWORK_ERROR_NAME_IN_USE,

    90 	NETWORK_ERROR_WRONG_PASSWORD,

    91 	NETWORK_ERROR_PLAYER_MISMATCH, // Happens in CLIENT_COMMAND

    92 	NETWORK_ERROR_KICKED,

    93 	NETWORK_ERROR_CHEATER,

    94 	NETWORK_ERROR_FULL,

    95 } NetworkErrorCode;

    96 

    97 // Actions that can be used for NetworkTextMessage

    98 typedef enum {

    99 	NETWORK_ACTION_JOIN,

   100 	NETWORK_ACTION_LEAVE,

   101 	NETWORK_ACTION_SERVER_MESSAGE,

   102 	NETWORK_ACTION_CHAT,

   103 	NETWORK_ACTION_CHAT_COMPANY,

   104 	NETWORK_ACTION_CHAT_CLIENT,

   105 	NETWORK_ACTION_GIVE_MONEY,

   106 	NETWORK_ACTION_NAME_CHANGE,

   107 } NetworkAction;

   108 

   109 typedef enum {

   110 	NETWORK_GAME_PASSWORD,

   111 	NETWORK_COMPANY_PASSWORD,

   112 } NetworkPasswordType;

   113 

   114 // To keep the clients all together

   115 typedef struct NetworkClientState {

   116 	SOCKET socket;

   117 	uint16 index;

   118 	uint32 last_frame;

   119 	uint32 last_frame_server;

   120 	byte lag_test; // This byte is used for lag-testing the client

   121 

   122 	ClientStatus status;

   123 	bool writable; // is client ready to write to?

   124 	bool has_quit;

   125 

   126 	Packet *packet_queue; // Packets that are awaiting delivery

   127 	Packet *packet_recv; // Partially received packet

   128 

   129 	CommandPacket *command_queue; // The command-queue awaiting delivery

   130 } NetworkClientState;

   131 

   132 // What packet types are there

   133 // WARNING: The first 3 packets can NEVER change order again

   134 //   it protects old clients from joining newer servers (because SERVER_ERROR

   135 //   is the respond to a wrong revision)

   136 typedef enum {

   137 	PACKET_SERVER_FULL,

   138 	PACKET_SERVER_BANNED,

   139 	PACKET_CLIENT_JOIN,

   140 	PACKET_SERVER_ERROR,

   141 	PACKET_CLIENT_COMPANY_INFO,

   142 	PACKET_SERVER_COMPANY_INFO,

   143 	PACKET_SERVER_CLIENT_INFO,

   144 	PACKET_SERVER_NEED_PASSWORD,

   145 	PACKET_CLIENT_PASSWORD,

   146 	PACKET_SERVER_WELCOME,

   147 	PACKET_CLIENT_GETMAP,

   148 	PACKET_SERVER_WAIT,

   149 	PACKET_SERVER_MAP,

   150 	PACKET_CLIENT_MAP_OK,

   151 	PACKET_SERVER_JOIN,

   152 	PACKET_SERVER_FRAME,

   153 	PACKET_SERVER_SYNC,

   154 	PACKET_CLIENT_ACK,

   155 	PACKET_CLIENT_COMMAND,

   156 	PACKET_SERVER_COMMAND,

   157 	PACKET_CLIENT_CHAT,

   158 	PACKET_SERVER_CHAT,

   159 	PACKET_CLIENT_SET_PASSWORD,

   160 	PACKET_CLIENT_SET_NAME,

   161 	PACKET_CLIENT_QUIT,

   162 	PACKET_CLIENT_ERROR,

   163 	PACKET_SERVER_QUIT,

   164 	PACKET_SERVER_ERROR_QUIT,

   165 	PACKET_SERVER_SHUTDOWN,

   166 	PACKET_SERVER_NEWGAME,

   167 	PACKET_SERVER_RCON,

   168 	PACKET_CLIENT_RCON,

   169 	PACKET_END // Should ALWAYS be on the end of this list!! (period)

   170 } PacketType;

   171 

   172 typedef enum {

   173 	DESTTYPE_BROADCAST, ///< Send message/notice to all players (All)

   174 	DESTTYPE_TEAM,    ///< Send message/notice to everyone playing the same company (Team)

   175 	DESTTYPE_CLIENT,    ///< Send message/notice to only a certain player (Private)

   176 } DestType;

   177 

   178 CommandPacket *_local_command_queue;

   179 

   180 SOCKET _udp_client_socket; // udp client socket

   181 SOCKET _udp_server_socket; // udp server socket

   182 SOCKET _udp_master_socket; // udp master socket

   183 

   184 // Here we keep track of the clients

   185 //  (and the client uses [0] for his own communication)

   186 NetworkClientState _clients[MAX_CLIENTS];

   187 #define DEREF_CLIENT(i) (&_clients[i])

   188 // This returns the NetworkClientInfo from a NetworkClientState

   189 #define DEREF_CLIENT_INFO(cs) (&_network_client_info[cs - _clients])

   190 

   191 // Macros to make life a bit more easier

   192 #define DEF_CLIENT_RECEIVE_COMMAND(type) NetworkRecvStatus NetworkPacketReceive_ ## type ## _command(Packet *p)

   193 #define DEF_CLIENT_SEND_COMMAND(type) void NetworkPacketSend_ ## type ## _command(void)

   194 #define DEF_CLIENT_SEND_COMMAND_PARAM(type) void NetworkPacketSend_ ## type ## _command

   195 #define DEF_SERVER_RECEIVE_COMMAND(type) void NetworkPacketReceive_ ## type ## _command(NetworkClientState *cs, Packet *p)

   196 #define DEF_SERVER_SEND_COMMAND(type) void NetworkPacketSend_ ## type ## _command(NetworkClientState *cs)

   197 #define DEF_SERVER_SEND_COMMAND_PARAM(type) void NetworkPacketSend_ ## type ## _command

   198 

   199 #define SEND_COMMAND(type) NetworkPacketSend_ ## type ## _command

   200 #define RECEIVE_COMMAND(type) NetworkPacketReceive_ ## type ## _command

   201 

   202 #define FOR_ALL_CLIENTS(cs) for (cs = _clients; cs != endof(_clients) && cs->socket != INVALID_SOCKET; cs++)

   203 #define FOR_ALL_ACTIVE_CLIENT_INFOS(ci) for (ci = _network_client_info; ci != endof(_network_client_info); ci++) if (ci->client_index != NETWORK_EMPTY_INDEX)

   204 

   205 Packet *NetworkSend_Init(PacketType type);

   206 void NetworkSend_uint8(Packet *packet, uint8 data);

   207 void NetworkSend_uint16(Packet *packet, uint16 data);

   208 void NetworkSend_uint32(Packet *packet, uint32 data);

   209 void NetworkSend_uint64(Packet *packet, uint64 data);

   210 void NetworkSend_string(Packet *packet, const char* data);

   211 void NetworkSend_Packet(Packet *packet, NetworkClientState *cs);

   212 

   213 uint8 NetworkRecv_uint8(NetworkClientState *cs, Packet *packet);

   214 uint16 NetworkRecv_uint16(NetworkClientState *cs, Packet *packet);

   215 uint32 NetworkRecv_uint32(NetworkClientState *cs, Packet *packet);

   216 uint64 NetworkRecv_uint64(NetworkClientState *cs, Packet *packet);

   217 void NetworkRecv_string(NetworkClientState *cs, Packet *packet, char* buffer, size_t size);

   218 Packet *NetworkRecv_Packet(NetworkClientState *cs, NetworkRecvStatus *status);

   219 

   220 bool NetworkSend_Packets(NetworkClientState *cs);

   221 void NetworkExecuteCommand(CommandPacket *cp);

   222 void NetworkAddCommandQueue(NetworkClientState *cs, CommandPacket *cp);

   223 

   224 // from network.c

   225 void NetworkCloseClient(NetworkClientState *cs);

   226 void CDECL NetworkTextMessage(NetworkAction action, uint16 color, bool self_send, const char *name, const char *str, ...);

   227 void NetworkGetClientName(char *clientname, size_t size, const NetworkClientState *cs);

   228 uint NetworkCalculateLag(const NetworkClientState *cs);

   229 byte NetworkGetCurrentLanguageIndex(void);

   230 NetworkClientInfo *NetworkFindClientInfoFromIndex(uint16 client_index);

   231 NetworkClientInfo *NetworkFindClientInfoFromIP(const char *ip);

   232 NetworkClientState *NetworkFindClientStateFromIndex(uint16 client_index);

   233 unsigned long NetworkResolveHost(const char *hostname);

   234 char* GetNetworkErrorMsg(char* buf, NetworkErrorCode err, const char* last);

   235 

   236 #endif /* ENABLE_NETWORK */

   237 

   238 #endif /* NETWORK_DATA_H */