1

#include "stdafx.h"

     2

#include "map.h"

     3

#include "network_data.h"

     4

     5

#if defined(WITH_REV)

     6

	extern const char _openttd_revision[];

     7

#elif defined(WITH_REV_HACK)

     8

	#define WITH_REV

     9

	const char _openttd_revision[] = WITH_REV_HACK;

    10

#else

    11

	const char _openttd_revision[] = NOREV_STRING;

    12

#endif

    13

    14

    15

#ifdef ENABLE_NETWORK

    16

    17

#include "table/strings.h"

    18

#include "network_client.h"

    19

#include "network_server.h"

    20

#include "network_udp.h"

    21

#include "network_gamelist.h"

    22

#include "console.h" /* IConsoleCmdExec */

    23

#include <stdarg.h> /* va_list */

    24

#include "md5.h"

    25

    26

// The listen socket for the server

    27

static SOCKET _listensocket;

    28

    29

// Network copy of patches, so the patches of a client are not fucked up

    30

//  after he joined a server

    31

static Patches network_tmp_patches;

    32

    33

// The amount of clients connected

    34

static byte _network_clients_connected = 0;

    35

// The index counter for new clients (is never decreased)

    36

static uint16 _network_client_index = NETWORK_SERVER_INDEX + 1;

    37

    42

// Function that looks up the CI for a given client-index

    43

NetworkClientInfo *NetworkFindClientInfoFromIndex(uint16 client_index)

    44

{

    45

	NetworkClientInfo *ci;

    46

    47

	for (ci = _network_client_info; ci != &_network_client_info[MAX_CLIENT_INFO]; ci++)

    48

		if (ci->client_index == client_index)

    49

			return ci;

    50

    51

	return NULL;

    52

}

    53

    54

// Function that looks up the CS for a given client-index

    56

{

    58

    59

	for (cs = _clients; cs != &_clients[MAX_CLIENT_INFO]; cs++)

    60

		if (cs->index == client_index)

    61

			return cs;

    62

    63

	return NULL;

    64

}

    65

    66

// NetworkGetClientName is a server-safe function to get the name of the client

    67

//  if the user did not send it yet, Client #<no> is used.

    69

{

    70

	NetworkClientInfo *ci = DEREF_CLIENT_INFO(cs);

    71

	if (ci->client_name[0] == '\0')

    72

		snprintf(client_name, size, "Client #%d", cs->index);

    73

	else

    74

		snprintf(client_name, size, "%s", ci->client_name);

    75

}

    76

    77

// This puts a text-message to the console, or in the future, the chat-box,

    78

//  (to keep it all a bit more general)

    79

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

    80

{

    81

	char buf[1024];

    82

	va_list va;

    83

	const int duration = 10; // Game days the messages stay visible

    84

    85

	va_start(va, str);

    86

	vsprintf(buf, str, va);

    87

	va_end(va);

    88

    89

	switch (action) {

    90

		case NETWORK_ACTION_JOIN_LEAVE:

    91

			IConsolePrintF(color, "*** %s %s", name, buf);

    92

			AddTextMessage(color, duration, "*** %s %s", name, buf);

    93

			break;

    94

		case NETWORK_ACTION_GIVE_MONEY:

    95

			IConsolePrintF(color, "*** %s %s", name, buf);

    96

			AddTextMessage(color, duration, "*** %s %s", name, buf);

    97

			break;

    98

		case NETWORK_ACTION_CHAT_PLAYER:

    99

			IConsolePrintF(color, "[Team] %s: %s", name, buf);

   100

			AddTextMessage(color, duration, "[Team] %s: %s", name, buf);

   101

			break;

   102

		case NETWORK_ACTION_CHAT_CLIENT:

   103

			IConsolePrintF(color, "[Private] %s: %s", name, buf);

   104

			AddTextMessage(color, duration, "[Private] %s: %s", name, buf);

   105

			break;

   106

		case NETWORK_ACTION_CHAT_TO_CLIENT:

   107

			IConsolePrintF(color, "[Private] To %s: %s", name, buf);

   108

			AddTextMessage(color, duration, "[Private] To %s: %s", name, buf);

   109

			break;

   110

		case NETWORK_ACTION_CHAT_TO_PLAYER:

   111

			IConsolePrintF(color, "[Team] To %s: %s", name, buf);

   112

			AddTextMessage(color, duration, "[Team] To %s: %s", name, buf);

   113

			break;

   114

		case NETWORK_ACTION_NAME_CHANGE:

   115

			IConsolePrintF(color, "*** %s changed his name to %s", name, buf);

   116

			AddTextMessage(color, duration, "*** %s changed his name to %s", name, buf);

   117

			break;

   118

		default:

   119

			IConsolePrintF(color, "[All] %s: %s", name, buf);

   120

			AddTextMessage(color, duration, "[All] %s: %s", name, buf);

   121

			break;

   122

	}

   123

}

   124

   125

// Calculate the frame-lag of a client

   127

{

   128

	int lag = cs->last_frame_server - cs->last_frame;

   129

	// This client has missed his ACK packet after 1 DAY_TICKS..

   130

	//  so we increase his lag for every frame that passes!

   131

	// The packet can be out by a max of _net_frame_freq

   132

	if (cs->last_frame_server + DAY_TICKS + _network_frame_freq < _frame_counter)

   133

		lag += _frame_counter - (cs->last_frame_server + DAY_TICKS + _network_frame_freq);

   134

   135

	return lag;

   136

}

   137

   138

   139

// There was a non-recoverable error, drop back to the main menu with a nice

   140

//  error

   141

void NetworkError(StringID error_string)

   142

{

   143

	_switch_mode = SM_MENU;

   144

	_switch_mode_errorstr = error_string;

   145

}

   146

   147

void ClientStartError(char *error) {

   148

	DEBUG(net, 0)("[NET] Client could not start network: %s",error);

   149

	NetworkError(STR_NETWORK_ERR_CLIENT_START);

   150

}

   151

   152

void ServerStartError(char *error) {

   153

	DEBUG(net, 0)("[NET] Server could not start network: %s",error);

   154

	NetworkError(STR_NETWORK_ERR_SERVER_START);

   155

}

   156

   158

	// First, send a CLIENT_ERROR to the server, so he knows we are

   159

	//  disconnection (and why!)

   160

	NetworkErrorCode errorno;

   161

   162

	// We just want to close the connection..

   163

	if (res == NETWORK_RECV_STATUS_CLOSE_QUERY) {

   164

		cs->quited = true;

   166

		_networking = false;

   167

   168

		DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);

   169

		return;

   170

	}

   171

   172

	switch(res) {

   173

		case NETWORK_RECV_STATUS_DESYNC: errorno = NETWORK_ERROR_DESYNC; break;

   174

		case NETWORK_RECV_STATUS_SAVEGAME: errorno = NETWORK_ERROR_SAVEGAME_FAILED; break;

   175

		default: errorno = NETWORK_ERROR_GENERAL;

   176

	}

   177

	// This means we fucked up and the server closed the connection

   178

	if (res != NETWORK_RECV_STATUS_SERVER_ERROR && res != NETWORK_RECV_STATUS_SERVER_FULL) {

   179

		SEND_COMMAND(PACKET_CLIENT_ERROR)(errorno);

   180

   181

		// Dequeue all commands before closing the socket

   182

		NetworkSend_Packets(DEREF_CLIENT(0));

   183

	}

   184

   185

	_switch_mode = SM_MENU;

   187

	_networking = false;

   188

}

   189

   190

// Find all IP-aliases for this host

   192

{

   193

	int i, last;

   194

   195

#if defined(BEOS_NET_SERVER) /* doesn't have neither getifaddrs or net/if.h */

   196

	/* Based on Andrew Bachmann's netstat+.c. Big thanks to him! */

   197

	int _netstat(int fd, char **output, int verbose);

   198

   199

	int seek_past_header(char **pos, const char *header) {

   200

		char *new_pos = strstr(*pos, header);

   201

		if (new_pos == 0) {

   202

			return B_ERROR;

   203

		}

   204

		*pos += strlen(header) + new_pos - *pos + 1;

   205

		return B_OK;

   206

	}

   207

   208

	int output_length;

   209

	char *output_pointer = NULL;

   210

	char **output;

   211

	int sock = socket(AF_INET, SOCK_DGRAM, 0);

   212

	i = 0;

   213

   214

	// If something fails, make sure the list is empty

   215

	_network_ip_list[0] = 0;

   216

   217

	if (sock < 0) {

   218

		DEBUG(net, 0)("Error creating socket!");

   219

		return;

   220

	}

   221

   222

	output_length = _netstat(sock, &output_pointer, 1);

   223

	if (output_length < 0) {

   224

		DEBUG(net, 0)("Error running _netstat!");

   225

		return;

   226

	}

   227

   228

	output = &output_pointer;

   229

	if (seek_past_header(output, "IP Interfaces:") == B_OK) {

   230

		for (;;) {

   231

			uint32 n, fields, read;

   232

			uint8 i1, i2, i3, i4, j1, j2, j3, j4;

   233

			struct in_addr inaddr;

   234

			fields = sscanf(*output, "%u: %hhu.%hhu.%hhu.%hhu, netmask %hhu.%hhu.%hhu.%hhu%n",

   235

												&n, &i1,&i2,&i3,&i4, &j1,&j2,&j3,&j4, &read);

   236

			read += 1;

   237

			if (fields != 9) {

   238

				break;

   239

			}

   240

			inaddr.s_addr = htonl((uint32)i1 << 24 | (uint32)i2 << 16 | (uint32)i3 << 8 | (uint32)i4);

   241

			if (inaddr.s_addr != 0) {

   242

				_network_ip_list[i] = inaddr.s_addr;

   243

				i++;

   244

			}

   245

			if (read < 0) {

   246

				break;

   247

			}

   248

			*output += read;

   249

		}

   250

		/* XXX - Using either one of these crashes openttd heavily? - wber */

   251

		/*free(output_pointer);*/

   252

		/*free(output);*/

   253

		closesocket(sock);

   254

	}

   255

#elif defined(HAVE_GETIFADDRS)

   256

	struct ifaddrs *ifap, *ifa;

   257

   258

	// If something fails, make sure the list is empty

   259

	_network_ip_list[0] = 0;

   260

   261

	if (getifaddrs(&ifap) != 0)

   262

		return;

   263

   264

	i = 0;

   265

	for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {

   266

		if (ifa->ifa_addr == NULL || ifa->ifa_addr->sa_family != AF_INET)

   267

			continue;

   268

		_network_ip_list[i] = ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr;

   269

		i++;

   270

	}

   271

	freeifaddrs(ifap);

   272

   273

#else /* not HAVE_GETIFADDRS */

   274

   275

	unsigned long len = 0;

   276

	SOCKET sock;

   277

	IFREQ ifo[MAX_INTERFACES];

   278

   279

#ifndef WIN32

   280

	struct ifconf if_conf;

   281

#endif

   282

   283

	// If something fails, make sure the list is empty

   284

	_network_ip_list[0] = 0;

   285

   286

	if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {

   287

		return;

   288

	}

   289

   290

#ifdef WIN32

   291

	// On windows it is easy

   292

	memset(&ifo[0], 0, sizeof(ifo));

   293

	if ((WSAIoctl(sock, SIO_GET_INTERFACE_LIST, NULL, 0, &ifo[0], sizeof(ifo), &len, NULL, NULL)) != 0) {

   294

		closesocket(sock);

   295

		return;

   296

	}

   297

#else

   298

	// On linux a bit harder

   299

	if_conf.ifc_len = (sizeof (struct ifreq)) * MAX_INTERFACES;

   300

	if_conf.ifc_buf = (char *)&ifo[0];

   301

	if ((ioctl(sock, SIOCGIFCONF, &if_conf)) == -1) {

   302

		closesocket(sock);

   303

		return;

   304

	}

   305

	len = if_conf.ifc_len;

   306

#endif /* WIN32 */

   307

   308

	// Now walk through all IPs and list them

   309

	for (i = 0; i < (int)(len / sizeof(IFREQ)); i++) {

   310

		// Request IP for this interface

   311

#ifdef WIN32

   312

		_network_ip_list[i] = *(&ifo[i].iiAddress.AddressIn.sin_addr.s_addr);

   313

#else

   314

		if ((ioctl(sock, SIOCGIFADDR, &ifo[i])) != 0) {

   315

			closesocket(sock);

   316

			return;

   317

		}

   318

   319

		_network_ip_list[i] = ((struct sockaddr_in *)&ifo[i].ifr_addr)->sin_addr.s_addr;

   320

#endif

   321

	}

   322

   323

	closesocket(sock);

   324

   325

#endif /* not HAVE_GETIFADDRS */

   326

   327

	_network_ip_list[i] = 0;

   328

	last = i - 1;

   329

   330

	DEBUG(net, 3)("Detected IPs:");

   331

	// Now display to the debug all the detected ips

   332

	i = 0;

   333

	while (_network_ip_list[i] != 0) {

   334

		// Also check for non-used ips (127.0.0.1)

   335

		if (_network_ip_list[i] == inet_addr("127.0.0.1")) {

   336

			// If there is an ip after thisone, put him in here

   337

			if (last > i)

   338

				_network_ip_list[i] = _network_ip_list[last];

   339

			// Clear the last ip

   340

			_network_ip_list[last] = 0;

   341

			// And we have 1 ip less

   342

			last--;

   343

			continue;

   344

		}

   345

   346

		DEBUG(net, 3)(" %d) %s", i, inet_ntoa(*(struct in_addr *)&_network_ip_list[i]));//inet_ntoa(inaddr));

   347

		i++;

   348

	}

   349

}

   350

   351

// Resolve a hostname to a inet_addr

   352

unsigned long NetworkResolveHost(const char *hostname)

   353

{

   354

	in_addr_t ip;

   355

   356

	// First try: is it an ip address?

   357

	ip = inet_addr(hostname);

   358

   359

	// If not try to resolve the name

   360

	if (ip == INADDR_NONE) {

   361

		struct hostent *he = gethostbyname(hostname);

   362

		if (he == NULL) {

   363

			DEBUG(net, 0) ("[NET] Cannot resolve %s", hostname);

   364

		} else {

   365

			struct in_addr addr = *(struct in_addr *)he->h_addr_list[0];

   366

			DEBUG(net, 1) ("[NET] Resolved %s to %s", hostname, inet_ntoa(addr));

   367

			ip = addr.s_addr;

   368

		}

   369

	}

   370

	return ip;

   371

}

   372

   373

// Converts a string to ip/port/player

   374

//  Format: IP#player:port

   375

//

   376

// connection_string will be re-terminated to seperate out the hostname, and player and port will

   377

// be set to the player and port strings given by the user, inside the memory area originally

   378

// occupied by connection_string.

   379

void ParseConnectionString(const byte **player, const byte **port, byte *connection_string)

   380

{

   381

	byte *p;

   382

	for (p = connection_string; *p != '\0'; p++) {

   383

		if (*p == '#') {

   384

			*player = p + 1;

   385

			*p = '\0';

   386

		} else if (*p == ':') {

   387

			*port = p + 1;

   388

			*p = '\0';

   389

		}

   390

	}

   391

}

   392

   393

// Creates a new client from a socket

   394

//   Used both by the server and the client

   396

{

   398

	NetworkClientInfo *ci;

   399

	byte client_no;

   400

   401

	client_no = 0;

   402

   403

	if (_network_server) {

   404

		// Can we handle a new client?

   405

		if (_network_clients_connected >= MAX_CLIENTS)

   406

			return NULL;

   407

   408

		if (_network_game_info.clients_on >= _network_game_info.clients_max)

   409

			return NULL;

   410

   411

		// Register the login

   412

		client_no = _network_clients_connected++;

   413

	}

   414

   415

	cs = &_clients[client_no];

   416

	memset(cs, 0, sizeof(*cs));

   417

	cs->socket = s;

   418

	cs->last_frame = 0;

   419

	cs->quited = false;

   420

   421

	if (_network_server) {

   422

		ci = DEREF_CLIENT_INFO(cs);

   423

		memset(ci, 0, sizeof(*ci));

   424

   425

		cs->index = _network_client_index++;

   426

		ci->client_index = cs->index;

   427

		ci->join_date = _date;

   428

   429

		InvalidateWindow(WC_CLIENT_LIST, 0);

   430

	}

   431

   432

	return cs;

   433

}

   434

   435

// Close a connection

   437

{

   438

	NetworkClientInfo *ci;

   439

	// Socket is already dead

   440

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

   441

   442

	DEBUG(net, 1) ("[NET] Closed client connection");

   443

   444

	if (!cs->quited && _network_server && cs->status > STATUS_INACTIVE) {

   445

		// We did not receive a leave message from this client...

   446

		NetworkErrorCode errorno = NETWORK_ERROR_CONNECTION_LOST;

   447

		char str1[100], str2[100];

   448

		char client_name[NETWORK_NAME_LENGTH];

   450

   451

		NetworkGetClientName(client_name, sizeof(client_name), cs);

   452

   453

		GetString(str1, STR_NETWORK_ERR_LEFT);

   454

		GetString(str2, STR_NETWORK_ERR_CLIENT_GENERAL + errorno);

   455

   456

		NetworkTextMessage(NETWORK_ACTION_JOIN_LEAVE, 1, client_name, "%s (%s)", str1, str2);

   457

   458

		// Inform other clients of this... strange leaving ;)

   459

		FOR_ALL_CLIENTS(new_cs) {

   460

			if (new_cs->status > STATUS_AUTH && cs != new_cs) {

   461

				SEND_COMMAND(PACKET_SERVER_ERROR_QUIT)(new_cs, cs->index, errorno);

   462

			}

   463

		}

   464

	}

   465

   466

	closesocket(cs->socket);

   467

	cs->writable = false;

   468

   469

	// Free all pending and partially received packets

   470

	while (cs->packet_queue != NULL) {

   471

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

   472

		free(cs->packet_queue);

   473

		cs->packet_queue = p;

   474

	}

   475

	free(cs->packet_recv);

   476

	cs->packet_recv = NULL;

   477

   478

	while (cs->command_queue != NULL) {

   479

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

   480

		free(cs->command_queue);

   481

		cs->command_queue = p;

   482

	}

   483

   484

	// Close the gap in the client-list

   485

	ci = DEREF_CLIENT_INFO(cs);

   486

   487

	if (_network_server) {

   488

		// We just lost one client :(

   489

		if (cs->status > STATUS_INACTIVE)

   490

			_network_game_info.clients_on--;

   491

		_network_clients_connected--;

   492

   493