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 2

    22

// What version of company info is this?

    23

#define NETWORK_COMPANY_INFO_VERSION 3

    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_CHAT,

   102

	NETWORK_ACTION_CHAT_PLAYER,

   103

	NETWORK_ACTION_CHAT_CLIENT,

   104

	NETWORK_ACTION_GIVE_MONEY,

   105

	NETWORK_ACTION_NAME_CHANGE,

   106

} NetworkAction;

   107

   108

typedef enum {

   109

	NETWORK_GAME_PASSWORD,

   110

	NETWORK_COMPANY_PASSWORD,

   111

} NetworkPasswordType;

   112

   113

// To keep the clients all together

   114

typedef struct NetworkClientState {

   115

	SOCKET socket;

   116

	uint16 index;

   117

	uint32 last_frame;

   118

	uint32 last_frame_server;

   119

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

   120

   121

	ClientStatus status;

   122

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

   123

	bool quited;

   124

   125

	Packet *packet_queue; // Packets that are awaiting delivery

   126

	Packet *packet_recv; // Partially received packet

   127

   128

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

   129

} NetworkClientState;

   130

   131

// What packet types are there

   132

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

   133

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

   134

//   is the respond to a wrong revision)

   135

typedef enum {

   136

	PACKET_SERVER_FULL,

   137

	PACKET_SERVER_BANNED,

   138

	PACKET_CLIENT_JOIN,

   139

	PACKET_SERVER_ERROR,

   140

	PACKET_CLIENT_COMPANY_INFO,

   141

	PACKET_SERVER_COMPANY_INFO,

   142

	PACKET_SERVER_CLIENT_INFO,

   143

	PACKET_SERVER_NEED_PASSWORD,

   144

	PACKET_CLIENT_PASSWORD,

   145

	PACKET_SERVER_WELCOME,

   146

	PACKET_CLIENT_GETMAP,

   147

	PACKET_SERVER_WAIT,

   148

	PACKET_SERVER_MAP,

   149

	PACKET_CLIENT_MAP_OK,

   150

	PACKET_SERVER_JOIN,

   151

	PACKET_SERVER_FRAME,

   152

	PACKET_SERVER_SYNC,

   153

	PACKET_CLIENT_ACK,

   154

	PACKET_CLIENT_COMMAND,

   155

	PACKET_SERVER_COMMAND,

   156

	PACKET_CLIENT_CHAT,

   157

	PACKET_SERVER_CHAT,

   158

	PACKET_CLIENT_SET_PASSWORD,

   159

	PACKET_CLIENT_SET_NAME,

   160

	PACKET_CLIENT_QUIT,

   161

	PACKET_CLIENT_ERROR,

   162

	PACKET_SERVER_QUIT,

   163

	PACKET_SERVER_ERROR_QUIT,

   164

	PACKET_SERVER_SHUTDOWN,

   165

	PACKET_SERVER_NEWGAME,

   166

	PACKET_SERVER_RCON,

   167

	PACKET_CLIENT_RCON,

   168

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

   169

} PacketType;

   170

   171

typedef enum {

   172

	DESTTYPE_BROADCAST,

   173

	DESTTYPE_PLAYER,

   174

	DESTTYPE_CLIENT

   175

} DestType;

   176

   177

CommandPacket *_local_command_queue;

   178

   179

SOCKET _udp_client_socket; // udp client socket

   180

SOCKET _udp_server_socket; // udp server socket

   181

SOCKET _udp_master_socket; // udp master socket

   182

   183

// Here we keep track of the clients

   184

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

   185

NetworkClientState _clients[MAX_CLIENTS];

   186

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

   187

// This returns the NetworkClientInfo from a NetworkClientState

   188

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

   189

   190

// Macros to make life a bit more easier

   191

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

   192

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

   193

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

   194

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

   195

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

   196

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

   197

   198

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

   199

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

   200

   201

#define FOR_ALL_CLIENTS(cs) for (cs = _clients; cs != &_clients[MAX_CLIENTS] && cs->socket != INVALID_SOCKET; cs++)

   202

   203

Packet *NetworkSend_Init(PacketType type);

   204

void NetworkSend_uint8(Packet *packet, uint8 data);

   205

void NetworkSend_uint16(Packet *packet, uint16 data);

   206

void NetworkSend_uint32(Packet *packet, uint32 data);

   207

void NetworkSend_uint64(Packet *packet, uint64 data);

   208

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

   209

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

   210

   211

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

   212

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

   213

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

   214

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

   215

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

   216

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

   217

   218

bool NetworkSend_Packets(NetworkClientState *cs);

   219

void NetworkExecuteCommand(CommandPacket *cp);

   220

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

   221

   222

// from network.c

   223

void NetworkCloseClient(NetworkClientState *cs);

   224

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

   225

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

   226

uint NetworkCalculateLag(const NetworkClientState *cs);

   227

byte NetworkGetCurrentLanguageIndex(void);

   228

NetworkClientInfo *NetworkFindClientInfoFromIndex(uint16 client_index);

   229

NetworkClientInfo *NetworkFindClientInfoFromIP(const char *ip);

   230

NetworkClientState *NetworkFindClientStateFromIndex(uint16 client_index);

   231

unsigned long NetworkResolveHost(const char *hostname);

   232

char *GetNetworkErrorMsg(char *buf, NetworkErrorCode err);

   233

   234

#endif /* ENABLE_NETWORK */

   235

   236

#endif /* NETWORK_DATA_H */