1

/* $Id$ */

     2

     3

#ifdef ENABLE_NETWORK

     4

     5

#include "../../stdafx.h"

     6

#include "../../debug.h"

     7

#include "../../openttd.h"

     8

#include "../../variables.h"

     9

#include "table/strings.h"

    10

#include "../../functions.h"

    11

    12

#include "../network_data.h"

    13

#include "packet.h"

    14

#include "tcp.h"

    16

    17

/**

    18

 * @file tcp.c Basic functions to receive and send TCP packets.

    19

 */

    20

    21

/**

    22

 * Functions to help NetworkRecv_Packet/NetworkSend_Packet a bit

    23

 *  A socket can make errors. When that happens this handles what to do.

    24

 * For clients: close connection and drop back to main-menu

    25

 * For servers: close connection and that is it

    26

 * @param cs the client to close the connection of

    27

 * @return the new status

    28

 */

    29

NetworkRecvStatus CloseConnection(NetworkClientState *cs)

    30

{

    31

	NetworkCloseClient(cs);

    32

    33

	/* Clients drop back to the main menu */

    34

	if (!_network_server && _networking) {

    35

		_switch_mode = SM_MENU;

    36

		_networking = false;

    37

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

    38

    39

		return NETWORK_RECV_STATUS_CONN_LOST;

    40

	}

    41

    42

	return NETWORK_RECV_STATUS_OKAY;

    43

}

    44

    45

/**

    46

 * Whether the client has quit or not (used in packet.c)

    47

 * @param cs the client to check

    48

 * @return true if the client has quit

    49

 */

    50

bool HasClientQuit(const NetworkClientState *cs)

    51

{

    52

	return cs->has_quit;

    53

}

    54

    55

/**

    56

 * This function puts the packet in the send-queue and it is send as

    57

 * soon as possible. This is the next tick, or maybe one tick later

    58

 * if the OS-network-buffer is full)

    59

 * @param packet the packet to send

    60

 * @param cs     the client to send to

    61

 */

    62

void NetworkSend_Packet(Packet *packet, NetworkClientState *cs)

    63

{

    64

	Packet *p;

    65

	assert(packet != NULL);

    66

    67

	packet->pos = 0;

    68

	packet->next = NULL;

    69

    70

	NetworkSend_FillPacketSize(packet);

    71

    72

	/* Locate last packet buffered for the client */

    73

	p = cs->packet_queue;

    74

	if (p == NULL) {

    75

		/* No packets yet */

    76

		cs->packet_queue = packet;

    77

	} else {

    78

		/* Skip to the last packet */

    79

		while (p->next != NULL) p = p->next;

    80

		p->next = packet;

    81

	}

    82

}

    83

    84

/**

    85

 * Sends all the buffered packets out for this client. It stops when:

    86

 *   1) all packets are send (queue is empty)

    87

 *   2) the OS reports back that it can not send any more

    88

 *      data right now (full network-buffer, it happens ;))

    89

 *   3) sending took too long

    90

 * @param cs the client to send the packets for

    91

 */

    92

bool NetworkSend_Packets(NetworkClientState *cs)

    93

{

    94

	ssize_t res;

    95

	Packet *p;

    96

    97

	/* We can not write to this socket!! */

    98

	if (!cs->writable) return false;

    99

	if (cs->socket == INVALID_SOCKET) return false;

   100

   101

	p = cs->packet_queue;

   102

	while (p != NULL) {

   104

		if (res == -1) {

   105

			int err = GET_LAST_ERROR();

   106

			if (err != EWOULDBLOCK) {

   107

				/* Something went wrong.. close client! */

   108

				DEBUG(net, 0, "send failed with error %d", err);

   109

				CloseConnection(cs);

   110

				return false;

   111

			}

   112

			return true;

   113

		}

   114

		if (res == 0) {

   115

			/* Client/server has left us :( */

   116

			CloseConnection(cs);

   117

			return false;

   118

		}

   119

   120

		p->pos += res;

   121

   122

		/* Is this packet sent? */

   123

		if (p->pos == p->size) {

   124

			/* Go to the next packet */

   125

			cs->packet_queue = p->next;

   126

			free(p);

   127

			p = cs->packet_queue;

   128

		} else {

   129

			return true;

   130

		}

   131

	}

   132

   133

	return true;

   134

}

   135

   136

/**

   137

 * Receives a packet for the given client

   138

 * @param cs     the client to (try to) receive a packet for

   139

 * @param status the variable to store the status into

   140

 * @return the received packet (or NULL when it didn't receive one)

   141

 */

   142

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

   143

{

   144

	ssize_t res;

   145

	Packet *p;

   146

   147

	*status = NETWORK_RECV_STATUS_OKAY;

   148

   149

	if (cs->socket == INVALID_SOCKET) return NULL;

   150

   151

	if (cs->packet_recv == NULL) {

   153

		if (cs->packet_recv == NULL) error("Failed to allocate packet");

   154

		/* Set pos to zero! */

   155

		cs->packet_recv->pos = 0;

   156

		cs->packet_recv->size = 0; // Can be ommited, just for safety reasons

   157

	}

   158

   159

	p = cs->packet_recv;

   160

   161

	/* Read packet size */

   162

	if (p->pos < sizeof(PacketSize)) {

   163

		while (p->pos < sizeof(PacketSize)) {

   164

			/* Read the size of the packet */

   166

			if (res == -1) {

   167

				int err = GET_LAST_ERROR();

   168

				if (err != EWOULDBLOCK) {

   169

					/* Something went wrong... (104 is connection reset by peer) */

   170

					if (err != 104) DEBUG(net, 0, "recv failed with error %d", err);

   171

					*status = CloseConnection(cs);

   172

					return NULL;

   173

				}

   174

				/* Connection would block, so stop for now */

   175

				return NULL;

   176

			}

   177

			if (res == 0) {

   178

				/* Client/server has left */

   179

				*status = CloseConnection(cs);

   180

				return NULL;

   181

			}

   182

			p->pos += res;

   183

		}

   184

   185

		NetworkRecv_ReadPacketSize(p);

   186

   187

		if (p->size > SEND_MTU) {

   188

			*status = CloseConnection(cs);

   189

			return NULL;

   190

		}

   191

	}

   192

   193

	/* Read rest of packet */

   194

	while (p->pos < p->size) {

   196

		if (res == -1) {

   197

			int err = GET_LAST_ERROR();

   198

			if (err != EWOULDBLOCK) {

   199

				/* Something went wrong... (104 is connection reset by peer) */

   200

				if (err != 104) DEBUG(net, 0, "recv failed with error %d", err);

   201

				*status = CloseConnection(cs);

   202

				return NULL;

   203

			}

   204

			/* Connection would block */

   205

			return NULL;

   206

		}

   207

		if (res == 0) {

   208

			/* Client/server has left */

   209

			*status = CloseConnection(cs);

   210

			return NULL;

   211

		}

   212

   213

		p->pos += res;

   214

	}

   215

   216

	/* We have a complete packet, return it! */

   217

	p->pos = 2;

   218

	p->next = NULL; // Should not be needed, but who knows...

   219

   220

	/* Prepare for receiving a new packet */

   221

	cs->packet_recv = NULL;

   222

   223

	return p;

   224

}

   225

   226

#endif /* ENABLE_NETWORK */