1

#include "stdafx.h"

     2

#include "openttd.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

extern bool SafeSaveOrLoad(const char *filename, int mode, int newgm);

    48

extern void SwitchMode(int new_mode);

    49

    50

#ifdef UNIX

    51

/* We want to fork our dedicated server */

    52

void DedicatedFork(void)

    53

{

    54

	/* Fork the program */

    55

	pid_t pid = fork();

    56

	switch (pid) {

    57

		case -1:

    58

			perror("Unable to fork");

    59

			exit(1);

    60

		case 0:

    61

			// We're the child

    62

    63

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

    64

			_log_file_fd = fopen(_log_file, "a");

    65

			if (!_log_file_fd) {

    66

				perror("Unable to open logfile");

    67

				exit(1);

    68

			}

    69

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

    70

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

    71

				perror("Rerouting stdout");

    72

				exit(1);

    73

			}

    74

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

    75

				perror("Rerouting stderr");

    76

				exit(1);

    77

			}

    78

			break;

    79

		default:

    80

			// We're the parent

    81

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

    82

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

    83

			exit(0);

    84

	}

    85

}

    86

    87

/* Signal handlers */

    88

static void DedicatedSignalHandler(int sig)

    89

{

    90

	_exit_game = true;

    91

	signal(sig, DedicatedSignalHandler);

    92

}

    93

#endif

    94

    95

#ifdef WIN32

    96

#include <time.h>

    97

HANDLE hEvent;

    98

static HANDLE hThread; // Thread to close

    99

static char _win_console_thread_buffer[200];

   100

   101

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

   102

void WINAPI CheckForConsoleInput(void)

   103

{

   104

	while (true) {

   105

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

   106

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

   107

	}

   108

}

   109

   110

void CreateWindowsConsoleThread(void)

   111

{

   112

	static char tbuffer[9];

   113

	DWORD dwThreadId;

   114

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

   115

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

   116

	if (hEvent == NULL)

   117

		error("Cannot create console event!");

   118

   119

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

   120

	if (hThread == NULL)

   121

		error("Cannot create console thread!");

   122

   123

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

   124

}

   125

   126

void CloseWindowsConsoleThread(void)

   127

{

   128

	CloseHandle(hThread);

   129

	CloseHandle(hEvent);

   130

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

   131

}

   132

   133

#endif

   134

   135

static const char *DedicatedVideoStart(const char * const *parm)

   136

{

   137

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

   138

	_screen.height = _cur_resolution[1];

   139

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

   140

   141

	_debug_net_level = 6;

   142

	_debug_misc_level = 0;

   143

   144

#ifdef WIN32

   145

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

   146

	CreateConsole();

   147

	CreateWindowsConsoleThread();

   148

	SetConsoleTitle("OpenTTD Dedicated Server");

   149

#endif

   150

   151

#ifdef __OS2__

   152

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

   153

	OS2_SwitchToConsoleMode();

   154

#endif

   155

   156

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

   157

	return NULL;

   158

}

   159

   160

static void DedicatedVideoStop(void)

   161

{

   162

#ifdef WIN32

   163

	CloseWindowsConsoleThread();

   164

#endif

   165

	free(_dedicated_video_mem);

   166

}

   167

   168

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

   169

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

   170

static void DedicatedVideoFullScreen(bool fs) {}

   171

   172

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

   173

static bool InputWaiting(void)

   174

{

   175

	struct timeval tv;

   176

	fd_set readfds;

   177

	byte ret;

   178

   179

	tv.tv_sec = 0;

   180

	tv.tv_usec = 1;

   181

   182

	FD_ZERO(&readfds);

   183

	FD_SET(STDIN, &readfds);

   184

   185

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

   186

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

   187

   188

	if (ret > 0)

   189

		return true;

   190

   191

	return false;

   192

}

   193

#else

   194

static bool InputWaiting(void)

   195

{

   196

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

   197

		return true;

   198

   199

	return false;

   200

}

   201

#endif

   202

   203

static void DedicatedHandleKeyInput(void)

   204

{

   205

	static char input_line[200] = "";

   206

   207

	if (!InputWaiting())

   208

		return;

   209

   210

	if (_exit_game)

   211

		return;

   212

   213

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

   214

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

   215

#else

   216

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

   217

#endif

   218

   219

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

   220

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

   221

	{ /* Remove any special control characters */

   222

		uint i;

   223

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

   224

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

   225

				input_line[i] = '\0';

   226

   227

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

   228

				break;

   229

   230

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

   231

				input_line[i] = ' ';

   232

		}

   233

	}

   234

   235

	IConsoleCmdExec(input_line); // execute command

   236

}

   237

   238

static int DedicatedVideoMainLoop(void)

   239

{

   240

#ifndef WIN32

   241

	struct timeval tim;

   242

#endif

   243

	uint32 next_tick;

   244

	uint32 cur_ticks;

   245

   246

#ifdef WIN32

   247

	next_tick = GetTickCount() + 30;

   248

#else

   249

	gettimeofday(&tim, NULL);

   250

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

   251

#endif

   252

   253

	/* Signal handlers */

   254

#ifdef UNIX

   255

	signal(SIGTERM, DedicatedSignalHandler);

   256

	signal(SIGINT, DedicatedSignalHandler);

   257

	signal(SIGQUIT, DedicatedSignalHandler);

   258

#endif

   259

   260

	// Load the dedicated server stuff

   261

	_is_network_server = true;

   262

	_network_dedicated = true;

   263

	_network_playas = OWNER_SPECTATOR;

   264

	_local_player = OWNER_SPECTATOR;

   265

   266

	/* If SwitchMode is SM_LOAD, it means that the user used the '-g' options */

   267

	if (_switch_mode != SM_LOAD) {

   268

		_switch_mode = SM_NONE;

   269

		GenRandomNewGame(Random(), InteractiveRandom());

   270

	} else {

   271

		_switch_mode = SM_NONE;

   272

		/* First we need to test if the savegame can be loaded, else we will end up playing the

   273

		 *  intro game... */

   274

		if (!SafeSaveOrLoad(_file_to_saveload.name, _file_to_saveload.mode, GM_NORMAL)) {

   275

			/* Loading failed, pop out.. */

   276

			DEBUG(net, 0)("Loading requested map failed. Aborting.");

   277

			_networking = false;

   278

		} else {

   279

			/* We can load this game, so go ahead */

   280

			SwitchMode(SM_LOAD);

   281

		}

   282

	}

   283

   284

	// Done loading, start game!

   285

   286

	if (!_networking) {

   287

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

   288

		return ML_QUIT;

   289

	}

   290

   291

	while (true) {

   292

		InteractiveRandom(); // randomness

   293

   294

		if (_exit_game) return ML_QUIT;

   295

   296

		if (!_dedicated_forks)

   297

			DedicatedHandleKeyInput();

   298

   299

#ifdef WIN32

   300

		cur_ticks = GetTickCount();

   301

#else

   302

		gettimeofday(&tim, NULL);

   303

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

   304

#endif

   305

   306

		if (cur_ticks >= next_tick) {

   307

			next_tick += 30;

   308

   309

			GameLoop();

   310

			_screen.dst_ptr = _dedicated_video_mem;

   311

			UpdateWindows();

   312

		}

   313

		CSleep(1);

   314

	}

   315

}

   316

   317

   318

const HalVideoDriver _dedicated_video_driver = {

   319

	DedicatedVideoStart,

   320

	DedicatedVideoStop,

   321

	DedicatedVideoMakeDirty,

   322

	DedicatedVideoMainLoop,

   323

	DedicatedVideoChangeRes,

   324

	DedicatedVideoFullScreen,

   325

};

   326

   327

#else

   328

   329

static void *_dedicated_video_mem;

   330

   331

static const char *DedicatedVideoStart(const char * const *parm)

   332

{

   333

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

   334

   335

	return NULL;

   336

}

   337

   338

void DedicatedFork(void) {}

   339

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

   340

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

   341

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

   342

static void DedicatedVideoFullScreen(bool fs) {}

   343

static int DedicatedVideoMainLoop(void) { return ML_QUIT; }

   344

   345

const HalVideoDriver _dedicated_video_driver = {

   346

	DedicatedVideoStart,

   347

	DedicatedVideoStop,

   348

	DedicatedVideoMakeDirty,

   349

	DedicatedVideoMainLoop,

   350

	DedicatedVideoChangeRes,

   351

	DedicatedVideoFullScreen,

   352

};

   353

   354

#endif /* ENABLE_NETWORK */