1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "network.h"

     5

#include "hal.h"

     6

     7

#ifdef ENABLE_NETWORK

     8

     9

#include "gfx.h"

    10

#include "window.h"

    11

#include "command.h"

    12

#include "console.h"

    13

#ifdef WIN32

    14

#	include <windows.h> /* GetTickCount */

    15

#	include <conio.h>

    16

#endif

    17

    18

#ifdef __OS2__

    19

#	include <sys/time.h> /* gettimeofday */

    20

#	include <sys/types.h>

    21

#	include <unistd.h>

    22

#	include <conio.h>

    23

#	define STDIN 0  /* file descriptor for standard input */

    24

    25

	extern void OS2_SwitchToConsoleMode();

    26

#endif

    27

    28

#ifdef UNIX

    29

#	include <sys/time.h> /* gettimeofday */

    30

#	include <sys/types.h>

    31

#	include <unistd.h>

    32

#	include <signal.h>

    33

#	define STDIN 0  /* file descriptor for standard input */

    34

#endif

    35

#ifdef __MORPHOS__

    36

/* Voids the fork, option will be disabled for MorphOS build anyway, because

    37

 * MorphOS doesn't support forking (could only implemented with lots of code

    38

 * changes here). */

    39

int fork(void) { return -1; }

    40

int dup2(int oldd, int newd) { return -1; }

    41

#endif

    42

    43

// This file handles all dedicated-server in- and outputs

    44

    45

static void *_dedicated_video_mem;

    46

    47

#ifdef UNIX

    48

/* We want to fork our dedicated server */

    49

void DedicatedFork(void)

    50

{

    51

	/* Fork the program */

    52

	_dedicated_pid = fork();

    53

	switch (_dedicated_pid) {

    54

		case -1:

    55

			perror("Unable to fork");

    56

			exit(1);

    57

		case 0:

    58

			// We're the child

    59

    60

			/* Open the log-file to log all stuff too */

    61

			_log_file_fd = fopen(_log_file, "a");

    62

			if (!_log_file_fd) {

    63

				perror("Unable to open logfile");

    64

				exit(1);

    65

			}

    66

			/* Redirect stdout and stderr to log-file */

    67

			if (dup2(fileno(_log_file_fd), fileno(stdout)) == -1) {

    68

				perror("Re-routing stdout");

    69

				exit(1);

    70

			}

    71

			if (dup2(fileno(_log_file_fd), fileno(stderr)) == -1) {

    72

				perror("Re-routing stderr");

    73

				exit(1);

    74

			}

    75

			break;

    76

		default:

    77

			// We're the parent

    78

			printf("Loading dedicated server...\n");

    79

			printf("  - Forked to background with pid %d\n", _dedicated_pid);

    80

			exit(0);

    81

	}

    82

}

    83

    84

/* Signal handlers */

    85

static void DedicatedSignalHandler(int sig)

    86

{

    87

	_exit_game = true;

    88

	signal(sig, DedicatedSignalHandler);

    89

}

    90

#endif

    91

    92

#ifdef WIN32

    93

#include <time.h>

    94

HANDLE hEvent;

    95

static HANDLE hThread; // Thread to close

    96

static char _win_console_thread_buffer[200];

    97

    98

/* Windows Console thread. Just loop and signal when input has been received */

    99

void WINAPI CheckForConsoleInput(void)

   100

{

   101

	while (true) {

   102

		fgets(_win_console_thread_buffer, lengthof(_win_console_thread_buffer), stdin);

   103

		SetEvent(hEvent); // signal input waiting that the line is ready

   104

	}

   105

}

   106

   107

void CreateWindowsConsoleThread(void)

   108

{

   109

	static char tbuffer[9];

   110

	/* Create event to signal when console input is ready */

   111

	hEvent = CreateEvent(NULL, false, false, _strtime(tbuffer));

   112

	if (hEvent == NULL)

   113

		error("Cannot create console event!");

   114

   115

	hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)CheckForConsoleInput, 0, 0, NULL);

   116

	if (hThread == NULL)

   117

		error("Cannot create console thread!");

   118

   119

	DEBUG(misc, 0) ("Windows console thread started...");

   120

}

   121

   122

void CloseWindowsConsoleThread(void)

   123

{

   124

	CloseHandle(hThread);

   125

	CloseHandle(hEvent);

   126

	DEBUG(misc, 0) ("Windows console thread shut down...");

   127

}

   128

   129

#endif

   130

   133

	_screen.width = _screen.pitch = _cur_resolution[0];

   134

	_screen.height = _cur_resolution[1];

   135

	_dedicated_video_mem = malloc(_cur_resolution[0]*_cur_resolution[1]);

   136

   137

	_debug_net_level = 6;

   138

	_debug_misc_level = 0;

   139

   140

#ifdef WIN32

   141

	// For win32 we need to allocate an console (debug mode does the same)

   142

	CreateConsole();

   143

	CreateWindowsConsoleThread();

   144

	SetConsoleTitle("OpenTTD Dedicated Server");

   145

#endif

   146

   147

#ifdef __OS2__

   148

	// For OS/2 we also need to switch to console mode instead of PM mode

   149

	OS2_SwitchToConsoleMode();

   150

#endif

   151

   152

	DEBUG(misc,0)("Loading dedicated server...");

   153

	return NULL;

   154

}

   155

   156

static void DedicatedVideoStop(void)

   157

{

   158

#ifdef WIN32

   159

	CloseWindowsConsoleThread();

   160

#endif

   161

	free(_dedicated_video_mem);

   162

}

   163

   164

static void DedicatedVideoMakeDirty(int left, int top, int width, int height) {}

   165

static bool DedicatedVideoChangeRes(int w, int h) { return false; }

   166

   167

#if defined(UNIX) || defined(__OS2__)

   168

static bool InputWaiting(void)

   169

{

   170

	struct timeval tv;

   171

	fd_set readfds;

   172

	byte ret;

   173

   174

	tv.tv_sec = 0;

   175

	tv.tv_usec = 1;

   176

   177

	FD_ZERO(&readfds);

   178

	FD_SET(STDIN, &readfds);

   179

   180

	/* don't care about writefds and exceptfds: */

   181

	ret = select(STDIN + 1, &readfds, NULL, NULL, &tv);

   182

   183

	if (ret > 0)

   184

		return true;

   185

   186

	return false;

   187

}

   188

#else

   189

static bool InputWaiting(void)

   190

{

   191

	if (WaitForSingleObject(hEvent, 1) == WAIT_OBJECT_0)

   192

		return true;

   193

   194

	return false;

   195

}

   196

#endif

   197

   198

static void DedicatedHandleKeyInput(void)

   199

{

   200

	static char input_line[200] = "";

   201

   202

	if (!InputWaiting())

   203

		return;

   204

   205

	if (_exit_game)

   206

		return;

   207

   208

#if defined(UNIX) || defined(__OS2__)

   209

		fgets(input_line, lengthof(input_line), stdin);

   210

#else

   211

		strncpy(input_line, _win_console_thread_buffer, lengthof(input_line));

   212

#endif

   213

   214

	/* XXX - strtok() does not 'forget' \n\r if it is the first character! */

   215

	strtok(input_line, "\r\n"); // Forget about the final \n (or \r)

   216

	{ /* Remove any special control characters */

   217

		uint i;

   218

		for (i = 0; i < lengthof(input_line); i++) {

   219

			if (input_line[i] == '\n' || input_line[i] == '\r') // cut missed beginning '\0'

   220

				input_line[i] = '\0';

   221

   222

			if (input_line[i] == '\0')

   223

				break;

   224

   225

			if (!IS_INT_INSIDE(input_line[i], ' ', 256))

   226

				input_line[i] = ' ';

   227

		}

   228

	}

   229

   230

	IConsoleCmdExec(input_line); // execute command

   231

}

   232

   233

static int DedicatedVideoMainLoop(void)

   234

{

   235

#ifndef WIN32

   236

	struct timeval tim;

   237

#endif

   238

	uint32 next_tick;

   239

	uint32 cur_ticks;

   240

   241

#ifdef WIN32

   242

	next_tick = GetTickCount() + 30;

   243

#else

   244

	gettimeofday(&tim, NULL);

   245

	next_tick = (tim.tv_usec / 1000) + 30 + (tim.tv_sec * 1000);

   246

#endif

   247

   248

	/* Signal handlers */

   249

#ifdef UNIX

   250

	signal(SIGTERM, DedicatedSignalHandler);

   251

	signal(SIGINT, DedicatedSignalHandler);

   252

	signal(SIGQUIT, DedicatedSignalHandler);

   253

#endif

   254

   255

	// Load the dedicated server stuff

   256

	_is_network_server = true;

   257

	_network_dedicated = true;

   258

	_switch_mode = SM_NONE;

   259

	_network_playas = OWNER_SPECTATOR;

   260

	_local_player = OWNER_SPECTATOR;

   261

	DoCommandP(0, Random(), InteractiveRandom(), NULL, CMD_GEN_RANDOM_NEW_GAME);

   262

	// Done loading, start game!

   263

   264

	if (!_networking) {

   265

		DEBUG(net, 1)("Dedicated server could not be launced. Aborting..");

   266

		return ML_QUIT;

   267

	}

   268

   269

	while (true) {

   270

		InteractiveRandom(); // randomness

   271

   272

		if (_exit_game) return ML_QUIT;

   273

   274

		if (!_dedicated_forks)

   275

			DedicatedHandleKeyInput();

   276

   277

#ifdef WIN32

   278

		cur_ticks = GetTickCount();

   279

#else

   280

		gettimeofday(&tim, NULL);

   281

		cur_ticks = (tim.tv_usec / 1000) + (tim.tv_sec * 1000);

   282

#endif

   283

   284

		if (cur_ticks >= next_tick) {

   285

			next_tick += 30;

   286

   287

			GameLoop();

   288

			_screen.dst_ptr = _dedicated_video_mem;

   289

			UpdateWindows();

   290

		}

   291

		CSleep(1);

   292

	}

   293

   294

	return ML_QUIT;

   295

}

   296

   297

   298

const HalVideoDriver _dedicated_video_driver = {

   299

	DedicatedVideoStart,

   300

	DedicatedVideoStop,

   301

	DedicatedVideoMakeDirty,

   302

	DedicatedVideoMainLoop,

   303

	DedicatedVideoChangeRes,

   304

};

   305

   306

#else

   307

   308

static void *_dedicated_video_mem;

   309

   312

	DEBUG(misc,0)("OpenTTD compiled without network-support, quiting...");

   313

   314

	return NULL;

   315

}

   316

   317

void DedicatedFork(void) {}

   318

static void DedicatedVideoStop(void) { free(_dedicated_video_mem); }

   319

static void DedicatedVideoMakeDirty(int left, int top, int width, int height) {}

   320

static bool DedicatedVideoChangeRes(int w, int h) { return false; }

   321

static int DedicatedVideoMainLoop(void) { return ML_QUIT; }

   322

   323

const HalVideoDriver _dedicated_video_driver = {

   324

	DedicatedVideoStart,

   325

	DedicatedVideoStop,

   326

	DedicatedVideoMakeDirty,

   327

	DedicatedVideoMainLoop,

   328

	DedicatedVideoChangeRes,

   329

};

   330

   331

#endif /* ENABLE_NETWORK */