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

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("Re-routing stdout");

    72

				exit(1);

    73

			}

    74

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

    75

				perror("Re-routing 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

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

   114

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

   115

	if (hEvent == NULL)

   116

		error("Cannot create console event!");

   117

   118

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

   119

	if (hThread == NULL)

   120

		error("Cannot create console thread!");

   121

   122

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

   123

}

   124

   125

void CloseWindowsConsoleThread(void)

   126

{

   127

	CloseHandle(hThread);

   128

	CloseHandle(hEvent);

   129

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

   130

}

   131

   132

#endif

   133

   134

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

   135

{

   136

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

   137

	_screen.height = _cur_resolution[1];

   138

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

   139

   140

	_debug_net_level = 6;

   141

	_debug_misc_level = 0;

   142

   143

#ifdef WIN32

   144

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

   145

	CreateConsole();

   146

	CreateWindowsConsoleThread();

   147

	SetConsoleTitle("OpenTTD Dedicated Server");

   148

#endif

   149

   150

#ifdef __OS2__

   151

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

   152

	OS2_SwitchToConsoleMode();

   153

#endif

   154

   155

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

   156

	return NULL;

   157

}

   158

   159

static void DedicatedVideoStop(void)

   160

{

   161

#ifdef WIN32

   162

	CloseWindowsConsoleThread();

   163

#endif

   164

	free(_dedicated_video_mem);

   165

}

   166

   167

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

   168

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

   169

   170

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

   171

static bool InputWaiting(void)

   172

{

   173

	struct timeval tv;

   174

	fd_set readfds;

   175

	byte ret;

   176

   177

	tv.tv_sec = 0;

   178

	tv.tv_usec = 1;

   179

   180

	FD_ZERO(&readfds);

   181

	FD_SET(STDIN, &readfds);

   182

   183

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

   184

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

   185

   186

	if (ret > 0)

   187

		return true;

   188

   189

	return false;

   190

}

   191

#else

   192

static bool InputWaiting(void)

   193

{

   194

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

   195

		return true;

   196

   197

	return false;

   198

}

   199

#endif

   200

   201

static void DedicatedHandleKeyInput(void)

   202

{

   203

	static char input_line[200] = "";

   204

   205

	if (!InputWaiting())

   206

		return;

   207

   208

	if (_exit_game)

   209

		return;

   210

   211

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

   212

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

   213

#else

   214

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

   215

#endif

   216

   217

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

   218

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

   219

	{ /* Remove any special control characters */

   220

		uint i;

   221

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

   222

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

   223

				input_line[i] = '\0';

   224

   225

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

   226

				break;

   227

   228

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

   229

				input_line[i] = ' ';

   230

		}

   231

	}

   232

   233

	IConsoleCmdExec(input_line); // execute command

   234

}

   235

   236

static int DedicatedVideoMainLoop(void)

   237

{

   238

#ifndef WIN32

   239

	struct timeval tim;

   240

#endif

   241

	uint32 next_tick;

   242

	uint32 cur_ticks;

   243

   244

#ifdef WIN32

   245

	next_tick = GetTickCount() + 30;

   246

#else

   247

	gettimeofday(&tim, NULL);

   248

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

   249

#endif

   250

   251

	/* Signal handlers */

   252

#ifdef UNIX

   253

	signal(SIGTERM, DedicatedSignalHandler);

   254

	signal(SIGINT, DedicatedSignalHandler);

   255

	signal(SIGQUIT, DedicatedSignalHandler);

   256

#endif

   257

   258

	// Load the dedicated server stuff

   259

	_is_network_server = true;

   260

	_network_dedicated = true;

   261

	_network_playas = OWNER_SPECTATOR;

   262

	_local_player = OWNER_SPECTATOR;

   263

   264

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

   265

	if (_switch_mode != SM_LOAD) {

   266

		_switch_mode = SM_NONE;

   267

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

   268

	} else {

   269

		_switch_mode = SM_NONE;

   270

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

   271

		 *  intro game... */

   272

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

   273

			/* Loading failed, pop out.. */

   274

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

   275

			_networking = false;

   276

		} else {

   277

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

   278

			SwitchMode(SM_LOAD);

   279

		}

   280

	}

   281

   282

	// Done loading, start game!

   283

   284

	if (!_networking) {

   285

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

   286

		return ML_QUIT;

   287

	}

   288

   289

	while (true) {

   290

		InteractiveRandom(); // randomness

   291

   292

		if (_exit_game) return ML_QUIT;

   293

   294

		if (!_dedicated_forks)

   295

			DedicatedHandleKeyInput();

   296

   297

#ifdef WIN32

   298

		cur_ticks = GetTickCount();

   299

#else

   300

		gettimeofday(&tim, NULL);

   301

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

   302

#endif

   303

   304

		if (cur_ticks >= next_tick) {

   306

   307

			GameLoop();

   308

			_screen.dst_ptr = _dedicated_video_mem;

   309

			UpdateWindows();

   310

		}

   311

		CSleep(1);

   312

	}

   313

   314

	return ML_QUIT;

   315

}

   316

   317

   318

const HalVideoDriver _dedicated_video_driver = {

   319

	DedicatedVideoStart,

   320

	DedicatedVideoStop,

   321

	DedicatedVideoMakeDirty,

   322

	DedicatedVideoMainLoop,

   323

	DedicatedVideoChangeRes,

   324

};

   325

   326

#else

   327

   328

static void *_dedicated_video_mem;

   329

   330

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

   331

{

   332

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

   333

   334

	return NULL;

   335

}

   336

   337

void DedicatedFork(void) {}

   338

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

   339

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

   340

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

   341

static int DedicatedVideoMainLoop(void) { return ML_QUIT; }

   342

   343

const HalVideoDriver _dedicated_video_driver = {

   344

	DedicatedVideoStart,

   345

	DedicatedVideoStop,

   346

	DedicatedVideoMakeDirty,

   347

	DedicatedVideoMainLoop,

   348

	DedicatedVideoChangeRes,

   349

};

   350

   351

#endif /* ENABLE_NETWORK */