1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "network.h"

     4

#include "hal.h"

     5

     6

#ifdef ENABLE_NETWORK

     7

     8

#include "gfx.h"

     9

#include "window.h"

    10

#include "command.h"

    11

#include "console.h"

    12

#ifdef WIN32

    13

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

    14

#	include <conio.h>

    15

#endif

    16

    17

#ifdef __OS2__

    18

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

    19

#	include <sys/types.h>

    20

#	include <unistd.h>

    21

#	include <conio.h>

    22

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

    23

    24

	extern void OS2_SwitchToConsoleMode();

    25

#endif

    26

    27

#ifdef UNIX

    28

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

    29

#	include <sys/types.h>

    30

#	include <unistd.h>

    31

#	include <signal.h>

    32

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

    33

#endif

    34

#ifdef __MORPHOS__

    35

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

    36

 *  doesn't support forking (could only implemented with lots of code changes here).

    37

 */

    38

int morphos_dummy_fork() { return -1; }

    39

#define fork morphos_dummy_fork

    40

#endif

    41

    42

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

    43

    44

static void *_dedicated_video_mem;

    45

    46

#ifdef UNIX

    47

/* We want to fork our dedicated server */

    48

void DedicatedFork(void)

    49

{

    50

	/* Fork the program */

    51

	_dedicated_pid = fork();

    52

	switch (_dedicated_pid) {

    53

		case -1:

    54

			perror("Unable to fork");

    55

			exit(1);

    56

		case 0:

    57

			// We're the child

    58

    59

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

    60

			_log_file_fd = fopen(_log_file, "a");

    61

			if (!_log_file_fd) {

    62

				perror("Unable to open logfile");

    63

				exit(1);

    64

			}

    65

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

    66

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

    67

				perror("Re-routing stdout");

    68

				exit(1);

    69

			}

    70

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

    71

				perror("Re-routing stderr");

    72

				exit(1);

    73

			}

    74

			break;

    75

		default:

    76

			// We're the parent

    77

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

    78

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

    79

			exit(0);

    80

	}

    81

}

    82

    83

/* Signal handlers */

    84

static void DedicatedSignalHandler(int sig)

    85

{

    86

	_exit_game = true;

    87

	signal(sig, DedicatedSignalHandler);

    88

}

    89

#endif

    90

    91

#ifdef WIN32

    92

HANDLE hEvent;

    93

static HANDLE hThread; // Thread to close

    94

static char _win_console_thread_buffer[200];

    95

    96

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

    97

void WINAPI CheckForConsoleInput(void)

    98

{

    99

	while (true) {

   100

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

   101

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

   102

	}

   103

}

   104

   105

void CreateWindowsConsoleThread(void)

   106

{

   107

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

   108

	hEvent = CreateEvent(NULL, false, false, "keyboard input");    

   109

   110

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

   111

	if (hThread == NULL)

   112

		error("Cannot create console thread!");

   113

   114

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

   115

}

   116

   117

void CloseWindowsConsoleThread(void)

   118

{

   119

	CloseHandle(hThread);

   120

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

   121

}

   122

   123

#endif

   124

   125

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

   126

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

   127

	_screen.height = _cur_resolution[1];

   128

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

   129

   130

	_debug_net_level = 6;

   131

	_debug_misc_level = 0;

   132

   133

#ifdef WIN32

   134

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

   135

	CreateConsole();

   136

	CreateWindowsConsoleThread();

   137

	SetConsoleTitle("OpenTTD Dedicated Server");

   138

#endif

   139

   140

#ifdef __OS2__

   141

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

   142

	OS2_SwitchToConsoleMode();

   143

#endif

   144

   145

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

   146

	return NULL;

   147

}

   148

   149

static void DedicatedVideoStop(void)

   150

{

   151

#ifdef WIN32

   152

	CloseWindowsConsoleThread();

   153

#endif

   154

	free(_dedicated_video_mem); 

   155

}

   156

   157

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

   158

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

   159

   161

static bool InputWaiting(void)

   162

{

   163

	struct timeval tv;

   164

	fd_set readfds;

   165

	byte ret;

   166

   167

	tv.tv_sec = 0;

   168

	tv.tv_usec = 1;

   169

   170

	FD_ZERO(&readfds);

   171

	FD_SET(STDIN, &readfds);

   172

   173

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

   174

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

   175

   176

	if (ret > 0)

   177

		return true;

   178

   179

	return false;

   180

}

   181

#else

   182

static bool InputWaiting(void)

   183

{

   184

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

   185

		return true;

   186

   187

	return false;

   188

}

   189

#endif

   190

   191

static void DedicatedHandleKeyInput(void)

   192

{

   193

	static char input_line[200] = "";

   194

   195

	if (!InputWaiting())

   196

		return;

   197

   198

	if (_exit_game)

   199

		return;

   200

   201

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

   202

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

   203

#else

   204

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

   205

#endif

   206

   207

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

   208

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

   209

	{ /* Remove any special control characters */

   210

		uint i;

   211

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

   212

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

   213

				input_line[i] = '\0';

   214

   215

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

   216

				break;

   217

   218

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

   219

				input_line[i] = ' ';

   220

		}

   221

	}

   222

   223

	IConsoleCmdExec(input_line); // execute command

   224

}

   225

   226

static int DedicatedVideoMainLoop(void)

   227

{

   228

#ifndef WIN32

   229

	struct timeval tim;

   230

#endif

   231

	uint32 next_tick;

   232

	uint32 cur_ticks;

   233

   234

#ifdef WIN32

   235

	next_tick = GetTickCount() + 30;

   236

#else

   237

	gettimeofday(&tim, NULL);

   238

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

   239

#endif

   240

   241

	/* Signal handlers */

   242

#ifdef UNIX

   243

	signal(SIGTERM, DedicatedSignalHandler);

   244

	signal(SIGINT, DedicatedSignalHandler);

   245

	signal(SIGQUIT, DedicatedSignalHandler);

   246

#endif

   247

   248

	// Load the dedicated server stuff

   249

	_is_network_server = true;

   250

	_network_dedicated = true;

   251

	_switch_mode = SM_NONE;

   252

	_network_playas = OWNER_SPECTATOR;

   253

	_local_player = OWNER_SPECTATOR;

   254

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

   255

	// Done loading, start game!

   256

   257

	if (!_networking) {

   258

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

   259

		return ML_QUIT;

   260

	}

   261

   262

	while (true) {

   263

		InteractiveRandom(); // randomness

   264

   265

		if (_exit_game) return ML_QUIT;

   266

   267

		if (!_dedicated_forks)

   268

			DedicatedHandleKeyInput();

   269

   270

#ifdef WIN32

   271

		cur_ticks = GetTickCount();

   272

#else

   273

		gettimeofday(&tim, NULL);

   274

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

   275

#endif

   276

   277

		if (cur_ticks >= next_tick) {

   278

			next_tick += 30;

   279

   280

			GameLoop();

   281

			_screen.dst_ptr = _dedicated_video_mem;

   282

			UpdateWindows();

   283

		}

   284

		CSleep(1);

   285

	}

   286

   287

	return ML_QUIT;

   288

}

   289

   290

   291

const HalVideoDriver _dedicated_video_driver = {

   292

	DedicatedVideoStart,

   293

	DedicatedVideoStop,

   294

	DedicatedVideoMakeDirty,

   295

	DedicatedVideoMainLoop,

   296

	DedicatedVideoChangeRes,

   297

};

   298

   299

#else

   300

   301

static void *_dedicated_video_mem;

   302

   303

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

   304

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

   305

   306

	return NULL;

   307

}

   308

   309

void DedicatedFork(void) {}

   310

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

   311

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

   312

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

   313

static int DedicatedVideoMainLoop(void) { return ML_QUIT; }

   314

   315

const HalVideoDriver _dedicated_video_driver = {

   316

	DedicatedVideoStart,

   317

	DedicatedVideoStop,

   318

	DedicatedVideoMakeDirty,

   319

	DedicatedVideoMainLoop,

   320

	DedicatedVideoChangeRes,

   321

};

   322

   323

#endif /* ENABLE_NETWORK */