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"

    15

#include "../../helpers.hpp"

    16

    17

/**

    18

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

    19

 */

    20

    21

/** Very ugly temporary hack !!! */

    22

void NetworkTCPSocketHandler::Initialize()

    23

{

    24

	this->sock              = INVALID_SOCKET;

    25

    26

	this->index             = 0;

    27

	this->last_frame        = 0;

    28

	this->last_frame_server = 0;

    29

	this->lag_test          = 0;

    30

    31

	this->status            = STATUS_INACTIVE;

    32

	this->has_quit          = false;

    33

	this->writable          = false;

    34

    35

	this->packet_queue      = NULL;

    36

	this->packet_recv       = NULL;

    37

    38

	this->command_queue     = NULL;

    39

}

    40

    41

/**

    42

 * Functions to help NetworkRecv_Packet/NetworkSend_Packet a bit

    43

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

    44

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

    45

 * For servers: close connection and that is it

    46

 * @return the new status

    47

 * TODO: needs to be splitted when using client and server socket packets

    48

 */

    49

NetworkRecvStatus NetworkTCPSocketHandler::CloseConnection()

    50

{

    51

	NetworkCloseClient(this);

    52

    53

	/* Clients drop back to the main menu */

    54

	if (!_network_server && _networking) {

    55

		_switch_mode = SM_MENU;

    56

		_networking = false;

    57

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

    58

    59

		return NETWORK_RECV_STATUS_CONN_LOST;

    60

	}

    61

    62

	return NETWORK_RECV_STATUS_OKAY;

    63

}

    64

    65

/**

    66

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

    67

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

    68

 * if the OS-network-buffer is full)

    69

 * @param packet the packet to send

    70

 * @param cs     the client to send to

    71

 */

    72

void NetworkSend_Packet(Packet *packet, NetworkTCPSocketHandler *cs)

    73

{

    74

	Packet *p;

    75

	assert(packet != NULL);

    76

    78

    79

	/* Locate last packet buffered for the client */

    80

	p = cs->packet_queue;

    81

	if (p == NULL) {

    82

		/* No packets yet */

    83

		cs->packet_queue = packet;

    84

	} else {

    85

		/* Skip to the last packet */

    86

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

    87

		p->next = packet;

    88

	}

    89

}

    90

    91

/**

    92

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

    93

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

    94

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

    95

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

    96

 *   3) sending took too long

    97

 * @param cs the client to send the packets for

    98

 */

    99

bool NetworkSend_Packets(NetworkTCPSocketHandler *cs)

   100

{

   101

	ssize_t res;

   102

	Packet *p;

   103

   104

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

   105

	if (!cs->writable) return false;

   106

	if (!cs->IsConnected()) return false;

   107

   108

	p = cs->packet_queue;

   109

	while (p != NULL) {

   110

		res = send(cs->sock, (const char*)p->buffer + p->pos, p->size - p->pos, 0);

   111

		if (res == -1) {

   112

			int err = GET_LAST_ERROR();

   113

			if (err != EWOULDBLOCK) {

   114

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

   115

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

   116

				cs->CloseConnection();

   117

				return false;

   118

			}

   119

			return true;

   120

		}

   121

		if (res == 0) {

   122

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

   123

			cs->CloseConnection();

   124

			return false;

   125

		}

   126

   127

		p->pos += res;

   128

   129

		/* Is this packet sent? */

   130

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

   131

			/* Go to the next packet */

   132

			cs->packet_queue = p->next;

   134

			p = cs->packet_queue;

   135

		} else {

   136

			return true;

   137

		}

   138

	}

   139

   140

	return true;

   141

}

   142

   143

/**

   144

 * Receives a packet for the given client

   145

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

   146

 * @param status the variable to store the status into

   147

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

   148

 */

   149

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

   150

{

   151

	ssize_t res;

   152

	Packet *p;

   153

   154

	*status = NETWORK_RECV_STATUS_OKAY;

   155

   156

	if (!cs->IsConnected()) return NULL;

   157

   158

	if (cs->packet_recv == NULL) {

   160

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

   161

	}

   162

   163

	p = cs->packet_recv;

   164

   165

	/* Read packet size */

   166

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

   167

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

   168

		/* Read the size of the packet */

   169

			res = recv(cs->sock, (char*)p->buffer + p->pos, sizeof(PacketSize) - p->pos, 0);

   170

			if (res == -1) {

   171

				int err = GET_LAST_ERROR();

   172

				if (err != EWOULDBLOCK) {

   173

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

   174

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

   175

					*status = cs->CloseConnection();

   176

					return NULL;

   177

				}

   178

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

   179

				return NULL;

   180

			}

   181

			if (res == 0) {

   182

				/* Client/server has left */

   183

				*status = cs->CloseConnection();

   184

				return NULL;

   185

			}

   186

			p->pos += res;

   187

		}

   188

   191

   192

		if (p->size > SEND_MTU) {

   193

			*status = cs->CloseConnection();

   194

			return NULL;

   195

		}

   196

	}

   197

   198

	/* Read rest of packet */

   199

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

   200

		res = recv(cs->sock, (char*)p->buffer + p->pos, p->size - p->pos, 0);

   201

		if (res == -1) {

   202

			int err = GET_LAST_ERROR();

   203

			if (err != EWOULDBLOCK) {

   204

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

   205

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

   206

				*status = cs->CloseConnection();

   207

				return NULL;

   208

			}

   209

			/* Connection would block */

   210

			return NULL;

   211

		}

   212

		if (res == 0) {

   213

			/* Client/server has left */

   214

			*status = cs->CloseConnection();

   215

			return NULL;

   216

		}

   217

   218

		p->pos += res;

   219

	}

   220

   221

	/* Prepare for receiving a new packet */

   222

	cs->packet_recv = NULL;

   223

   225

	return p;

   226

}

   227

   228

#endif /* ENABLE_NETWORK */