1

/* $Id$ */

     2

     3

/**

     4

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

     5

 */

     6

     7

#ifdef ENABLE_NETWORK

     8

     9

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

    10

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

    11

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

    12

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

    13

    14

#include "../network_data.h"

    15

#include "packet.h"

    16

#include "tcp.h"

    19

    20

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

    21

void NetworkTCPSocketHandler::Initialize()

    22

{

    23

	this->sock              = INVALID_SOCKET;

    24

    25

	this->index             = 0;

    26

	this->last_frame        = 0;

    27

	this->last_frame_server = 0;

    28

	this->lag_test          = 0;

    29

    30

	this->status            = STATUS_INACTIVE;

    31

	this->has_quit          = false;

    32

	this->writable          = false;

    33

    34

	this->packet_queue      = NULL;

    35

	this->packet_recv       = NULL;

    36

    37

	this->command_queue     = NULL;

    38

}

    39

    40

void NetworkTCPSocketHandler::Destroy()

    41

{

    42

	closesocket(this->sock);

    43

	this->writable = false;

    44

	this->has_quit = true;

    45

    46

	/* Free all pending and partially received packets */

    47

	while (this->packet_queue != NULL) {

    48

		Packet *p = this->packet_queue->next;

    49

		delete this->packet_queue;

    50

		this->packet_queue = p;

    51

	}

    52

	delete this->packet_recv;

    53

	this->packet_recv = NULL;

    54

    55

	while (this->command_queue != NULL) {

    56

		CommandPacket *p = this->command_queue->next;

    57

		free(this->command_queue);

    58

		this->command_queue = p;

    59

	}

    60

}

    61

    62

/**

    63

 * Functions to help NetworkRecv_Packet/NetworkSend_Packet a bit

    64

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

    65

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

    66

 * For servers: close connection and that is it

    67

 * @return the new status

    68

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

    69

 */

    70

NetworkRecvStatus NetworkTCPSocketHandler::CloseConnection()

    71

{

    72

	NetworkCloseClient(this);

    73

    74

	/* Clients drop back to the main menu */

    75

	if (!_network_server && _networking) {

    76

		_switch_mode = SM_MENU;

    77

		_networking = false;

    78

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

    79

    80

		return NETWORK_RECV_STATUS_CONN_LOST;

    81

	}

    82

    83

	return NETWORK_RECV_STATUS_OKAY;

    84

}

    85

    86

/**

    87

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

    88

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

    89

 * if the OS-network-buffer is full)

    90

 * @param packet the packet to send

    91

 */

    92

void NetworkTCPSocketHandler::Send_Packet(Packet *packet)

    93

{

    94

	Packet *p;

    95

	assert(packet != NULL);

    96

    97

	packet->PrepareToSend();

    98

    99

	/* Locate last packet buffered for the client */

   100

	p = this->packet_queue;

   101

	if (p == NULL) {

   102

		/* No packets yet */

   103

		this->packet_queue = packet;

   104

	} else {

   105

		/* Skip to the last packet */

   106

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

   107

		p->next = packet;

   108

	}

   109

}

   110

   111

/**

   112

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

   113

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

   114

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

   115

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

   116

 *   3) sending took too long

   117

 */

   118

bool NetworkTCPSocketHandler::Send_Packets()

   119

{

   120

	ssize_t res;

   121

	Packet *p;

   122

   123

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

   124

	if (!this->writable) return false;

   125

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

   126

   127

	p = this->packet_queue;

   128

	while (p != NULL) {

   129

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

   130

		if (res == -1) {

   131

			int err = GET_LAST_ERROR();

   132

			if (err != EWOULDBLOCK) {

   133

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

   134

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

   135

				this->CloseConnection();

   136

				return false;

   137

			}

   138

			return true;

   139

		}

   140

		if (res == 0) {

   141

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

   142

			this->CloseConnection();

   143

			return false;

   144

		}

   145

   146

		p->pos += res;

   147

   148

		/* Is this packet sent? */

   149

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

   150

			/* Go to the next packet */

   151

			this->packet_queue = p->next;

   152

			delete p;

   153

			p = this->packet_queue;

   154

		} else {

   155

			return true;

   156

		}

   157

	}

   158

   159

	return true;

   160

}

   161

   162

/**

   163

 * Receives a packet for the given client

   164

 * @param status the variable to store the status into

   165

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

   166

 */

   167

Packet *NetworkTCPSocketHandler::Recv_Packet(NetworkRecvStatus *status)

   168

{

   169

	ssize_t res;

   170

	Packet *p;

   171

   172

	*status = NETWORK_RECV_STATUS_OKAY;

   173

   174

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

   175

   176

	if (this->packet_recv == NULL) {

   177

		this->packet_recv = new Packet(this);

   178

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

   179

	}

   180

   181

	p = this->packet_recv;

   182

   183

	/* Read packet size */

   184

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

   185

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

   186

		/* Read the size of the packet */

   187

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

   188

			if (res == -1) {

   189

				int err = GET_LAST_ERROR();

   190

				if (err != EWOULDBLOCK) {

   191

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

   192

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

   193

					*status = this->CloseConnection();

   194

					return NULL;

   195

				}

   196

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

   197

				return NULL;

   198

			}

   199

			if (res == 0) {

   200

				/* Client/server has left */

   201

				*status = this->CloseConnection();

   202

				return NULL;

   203

			}

   204

			p->pos += res;

   205

		}

   206

   207

		/* Read the packet size from the received packet */

   208

		p->ReadRawPacketSize();

   209

   210

		if (p->size > SEND_MTU) {

   211

			*status = this->CloseConnection();

   212

			return NULL;

   213

		}

   214

	}

   215

   216

	/* Read rest of packet */

   217

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

   218

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

   219

		if (res == -1) {

   220

			int err = GET_LAST_ERROR();

   221

			if (err != EWOULDBLOCK) {

   222

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

   223

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

   224

				*status = this->CloseConnection();

   225

				return NULL;

   226

			}

   227

			/* Connection would block */

   228

			return NULL;

   229

		}

   230

		if (res == 0) {

   231

			/* Client/server has left */

   232

			*status = this->CloseConnection();

   233

			return NULL;

   234

		}

   235

   236

		p->pos += res;

   237

	}

   238

   239

	/* Prepare for receiving a new packet */

   240

	this->packet_recv = NULL;

   241

   242

	p->PrepareToRead();

   243

	return p;

   244

}

   245

   246

bool NetworkTCPSocketHandler::IsPacketQueueEmpty()

   247

{

   248

	return this->packet_queue == NULL;

   249

}

   250

   251

   252

#endif /* ENABLE_NETWORK */