1

/* $Id$ */

     2

     7

#ifdef ENABLE_NETWORK

     8

     9

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

    10

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

    11

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

    12

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

    13

#include "table/strings.h"

    14

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

    15

    16

#include "../network_data.h"

    17

#include "packet.h"

    18

#include "tcp.h"

    19

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

    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

void NetworkTCPSocketHandler::Destroy()

    42

{

    43

	closesocket(this->sock);

    44

	this->writable = false;

    45

	this->has_quit = true;

    46

    47

	/* Free all pending and partially received packets */

    48

	while (this->packet_queue != NULL) {

    49

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

    50

		delete this->packet_queue;

    51

		this->packet_queue = p;

    52

	}

    53

	delete this->packet_recv;

    54

	this->packet_recv = NULL;

    55

    56

	while (this->command_queue != NULL) {

    57

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

    58

		free(this->command_queue);

    59

		this->command_queue = p;

    60

	}

    61

}

    62

    63

/**

    64

 * Functions to help NetworkRecv_Packet/NetworkSend_Packet a bit

    65

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

    66

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

    67

 * For servers: close connection and that is it

    68

 * @return the new status

    69

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

    70

 */

    71

NetworkRecvStatus NetworkTCPSocketHandler::CloseConnection()

    72

{

    73

	NetworkCloseClient(this);

    74

    75

	/* Clients drop back to the main menu */

    76

	if (!_network_server && _networking) {

    77

		_switch_mode = SM_MENU;

    78

		_networking = false;

    79

		_switch_mode_errorstr = STR_NETWORK_ERR_LOSTCONNECTION;

    80

    81

		return NETWORK_RECV_STATUS_CONN_LOST;

    82

	}

    83

    84

	return NETWORK_RECV_STATUS_OKAY;

    85

}

    86

    87

/**

    88

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

    89

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

    90

 * if the OS-network-buffer is full)

    91

 * @param packet the packet to send

    92

 */

    93

void NetworkTCPSocketHandler::Send_Packet(Packet *packet)

    94

{

    95

	Packet *p;

    96

	assert(packet != NULL);

    97

    98

	packet->PrepareToSend();

    99

   100

	/* Locate last packet buffered for the client */

   101

	p = this->packet_queue;

   102

	if (p == NULL) {

   103

		/* No packets yet */

   104

		this->packet_queue = packet;

   105

	} else {

   106

		/* Skip to the last packet */

   107

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

   108

		p->next = packet;

   109

	}

   110

}

   111

   112

/**

   113

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

   114

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

   115

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

   116

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

   117

 *   3) sending took too long

   118

 */

   119

bool NetworkTCPSocketHandler::Send_Packets()

   120

{

   121

	ssize_t res;

   122

	Packet *p;

   123

   124

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

   125

	if (!this->writable) return false;

   126

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

   127

   128

	p = this->packet_queue;

   129

	while (p != NULL) {

   130

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

   131

		if (res == -1) {

   132

			int err = GET_LAST_ERROR();

   133

			if (err != EWOULDBLOCK) {

   134

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

   135

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

   136

				this->CloseConnection();

   137

				return false;

   138

			}

   139

			return true;

   140

		}

   141

		if (res == 0) {

   142

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

   143

			this->CloseConnection();

   144

			return false;

   145

		}

   146

   147

		p->pos += res;

   148

   149

		/* Is this packet sent? */

   150

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

   151

			/* Go to the next packet */

   152

			this->packet_queue = p->next;

   153

			delete p;

   154

			p = this->packet_queue;

   155

		} else {

   156

			return true;

   157

		}

   158

	}

   159

   160

	return true;

   161

}

   162

   163

/**

   164

 * Receives a packet for the given client

   165

 * @param status the variable to store the status into

   166

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

   167

 */

   168

Packet *NetworkTCPSocketHandler::Recv_Packet(NetworkRecvStatus *status)

   169

{

   170

	ssize_t res;

   171

	Packet *p;

   172

   173

	*status = NETWORK_RECV_STATUS_OKAY;

   174

   175

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

   176

   177

	if (this->packet_recv == NULL) {

   178

		this->packet_recv = new Packet(this);

   179

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

   180

	}

   181

   182

	p = this->packet_recv;

   183

   184

	/* Read packet size */

   185

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

   186

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

   187

		/* Read the size of the packet */

   188

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

   189

			if (res == -1) {

   190

				int err = GET_LAST_ERROR();

   191

				if (err != EWOULDBLOCK) {

   192

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

   193

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

   194

					*status = this->CloseConnection();

   195

					return NULL;

   196

				}

   197

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

   198

				return NULL;

   199

			}

   200

			if (res == 0) {

   201

				/* Client/server has left */

   202

				*status = this->CloseConnection();

   203

				return NULL;

   204

			}

   205

			p->pos += res;

   206

		}

   207

   208

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

   209

		p->ReadRawPacketSize();

   210

   211

		if (p->size > SEND_MTU) {

   212

			*status = this->CloseConnection();

   213

			return NULL;

   214

		}

   215

	}

   216

   217

	/* Read rest of packet */

   218

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

   219

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

   220

		if (res == -1) {

   221

			int err = GET_LAST_ERROR();

   222

			if (err != EWOULDBLOCK) {

   223

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

   224

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

   225

				*status = this->CloseConnection();

   226

				return NULL;

   227

			}

   228

			/* Connection would block */

   229

			return NULL;

   230

		}

   231

		if (res == 0) {

   232

			/* Client/server has left */

   233

			*status = this->CloseConnection();

   234

			return NULL;

   235

		}

   236

   237

		p->pos += res;

   238

	}

   239

   240

	/* Prepare for receiving a new packet */

   241

	this->packet_recv = NULL;

   242

   243

	p->PrepareToRead();

   244

	return p;

   245

}

   246

   247

bool NetworkTCPSocketHandler::IsPacketQueueEmpty()

   248

{

   249

	return this->packet_queue == NULL;

   250

}

   251

   252

   253

#endif /* ENABLE_NETWORK */