1

/* $Id$ */

     2

     3

/** @file win32.cpp Implementation of MS Windows system calls */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "saveload.h"

     9

#include "gfx_func.h"

    10

#include "textbuf_gui.h"

    11

#include "fileio_func.h"

    12

#include "fios.h"

    13

#include "rev.h"

    14

#include <windows.h>

    15

#include <winnt.h>

    16

#include <wininet.h>

    17

#include <io.h>

    18

#include <fcntl.h>

    19

#include <shlobj.h> // SHGetFolderPath

    20

#include "variables.h"

    21

#include "win32.h"

    22

#include "core/alloc_func.hpp"

    23

#include "functions.h"

    24

#include "core/random_func.hpp"

    25

#include "core/bitmath_func.hpp"

    26

#include "string_func.h"

    27

#include "gamelog.h"

    28

#include <ctype.h>

    29

#include <tchar.h>

    30

#include <errno.h>

    31

#include <sys/types.h>

    32

#include <sys/stat.h>

    33

#if defined(_MSC_VER) && !defined(WINCE)

    34

	#include <dbghelp.h>

    35

	#include "strings_func.h"

    36

#endif

    37

    38

static bool _has_console;

    39

    40

static bool cursor_visible = true;

    41

    42

bool MyShowCursor(bool show)

    43

{

    44

	if (cursor_visible == show) return show;

    45

    46

	cursor_visible = show;

    47

	ShowCursor(show);

    48

    49

	return !show;

    50

}

    51

    52

/** Helper function needed by dynamically loading libraries

    53

 * XXX: Hurray for MS only having an ANSI GetProcAddress function

    54

 * on normal windows and no Wide version except for in Windows Mobile/CE */

    55

bool LoadLibraryList(Function proc[], const char *dll)

    56

{

    57

	while (*dll != '\0') {

    58

		HMODULE lib;

    59

		lib = LoadLibrary(MB_TO_WIDE(dll));

    60

    61

		if (lib == NULL) return false;

    62

		for (;;) {

    63

			FARPROC p;

    64

    65

			while (*dll++ != '\0') { /* Nothing */ }

    66

			if (*dll == '\0') break;

    67

#if defined(WINCE)

    68

			p = GetProcAddress(lib, MB_TO_WIDE(dll));

    69

#else

    70

			p = GetProcAddress(lib, dll);

    71

#endif

    72

			if (p == NULL) return false;

    73

			*proc++ = (Function)p;

    74

		}

    75

		dll++;

    76

	}

    77

	return true;

    78

}

    79

    80

#ifdef _MSC_VER

    81

static const char *_exception_string = NULL;

    82

void SetExceptionString(const char *s, ...)

    83

{

    84

	va_list va;

    85

	char buf[512];

    86

    87

	va_start(va, s);

    88

	vsnprintf(buf, lengthof(buf), s, va);

    89

	va_end(va);

    90

    91

	_exception_string = strdup(buf);

    92

}

    93

#endif

    94

    95

void ShowOSErrorBox(const char *buf, bool system)

    96

{

    97

	MyShowCursor(true);

    98

	MessageBox(GetActiveWindow(), MB_TO_WIDE(buf), _T("Error!"), MB_ICONSTOP);

    99

   100

/* if exception tracker is enabled, we crash here to let the exception handler handle it. */

   101

#if defined(WIN32_EXCEPTION_TRACKER) && !defined(_DEBUG)

   102

	if (system) {

   103

		_exception_string = buf;

   104

		*(byte*)0 = 0;

   105

	}

   106

#endif

   107

}

   108

   109

#if defined(_MSC_VER) && !defined(WINCE)

   110

   111

static void *_safe_esp;

   112

static char *_crash_msg;

   113

static bool _expanded;

   114

static bool _did_emerg_save;

   115

static int _ident;

   116

   117

struct DebugFileInfo {

   118

	uint32 size;

   119

	uint32 crc32;

   120

	SYSTEMTIME file_time;

   121

};

   122

   123

static uint32 *_crc_table;

   124

   125

static void MakeCRCTable(uint32 *table)

   126

{

   127

	uint32 crc, poly = 0xEDB88320L;

   128

	int i;

   129

	int j;

   130

   131

	_crc_table = table;

   132

   133

	for (i = 0; i != 256; i++) {

   134

		crc = i;

   135

		for (j = 8; j != 0; j--) {

   136

			crc = (crc & 1 ? (crc >> 1) ^ poly : crc >> 1);

   137

		}

   138

		table[i] = crc;

   139

	}

   140

}

   141

   142

static uint32 CalcCRC(byte *data, uint size, uint32 crc)

   143

{

   144

	for (; size > 0; size--) {

   145

		crc = ((crc >> 8) & 0x00FFFFFF) ^ _crc_table[(crc ^ *data++) & 0xFF];

   146

	}

   147

	return crc;

   148

}

   149

   150

static void GetFileInfo(DebugFileInfo *dfi, const TCHAR *filename)

   151

{

   152

	HANDLE file;

   153

	memset(dfi, 0, sizeof(dfi));

   154

   155

	file = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);

   156

	if (file != INVALID_HANDLE_VALUE) {

   157

		byte buffer[1024];

   158

		DWORD numread;

   159

		uint32 filesize = 0;

   160

		FILETIME write_time;

   161

		uint32 crc = (uint32)-1;

   162

   163

		for (;;) {

   164

			if (ReadFile(file, buffer, sizeof(buffer), &numread, NULL) == 0 || numread == 0)

   165

				break;

   166

			filesize += numread;

   167

			crc = CalcCRC(buffer, numread, crc);

   168

		}

   169

		dfi->size = filesize;

   170

		dfi->crc32 = crc ^ (uint32)-1;

   171

   172

		if (GetFileTime(file, NULL, NULL, &write_time)) {

   173

			FileTimeToSystemTime(&write_time, &dfi->file_time);

   174

		}

   175

		CloseHandle(file);

   176

	}

   177

}

   178

   179

   180

static char *PrintModuleInfo(char *output, const char *last, HMODULE mod)

   181

{

   182

	TCHAR buffer[MAX_PATH];

   183

	DebugFileInfo dfi;

   184

   185

	GetModuleFileName(mod, buffer, MAX_PATH);

   186

	GetFileInfo(&dfi, buffer);

   187

	output += seprintf(output, last, " %-20s handle: %p size: %d crc: %.8X date: %d-%.2d-%.2d %.2d:%.2d:%.2d\r\n",

   188

		WIDE_TO_MB(buffer),

   189

		mod,

   190

		dfi.size,

   191

		dfi.crc32,

   192

		dfi.file_time.wYear,

   193

		dfi.file_time.wMonth,

   194

		dfi.file_time.wDay,

   195

		dfi.file_time.wHour,

   196

		dfi.file_time.wMinute,

   197

		dfi.file_time.wSecond

   198

	);

   199

	return output;

   200

}

   201

   202

static char *PrintModuleList(char *output, const char *last)

   203

{

   204

	BOOL (WINAPI *EnumProcessModules)(HANDLE, HMODULE*, DWORD, LPDWORD);

   205

   206

	if (LoadLibraryList((Function*)&EnumProcessModules, "psapi.dll\0EnumProcessModules\0\0")) {

   207

		HMODULE modules[100];

   208

		DWORD needed;

   209

		BOOL res;

   210

   211

		HANDLE proc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, GetCurrentProcessId());

   212

		if (proc != NULL) {

   213

			res = EnumProcessModules(proc, modules, sizeof(modules), &needed);

   214

			CloseHandle(proc);

   215

			if (res) {

   216

				size_t count = min(needed / sizeof(HMODULE), lengthof(modules));

   217

   218

				for (size_t i = 0; i != count; i++) output = PrintModuleInfo(output, last, modules[i]);

   219

				return output;

   220

			}

   221

		}

   222

	}

   223

	output = PrintModuleInfo(output, last, NULL);

   224

	return output;

   225

}

   226

   227

static const TCHAR _crash_desc[] =

   228

	_T("A serious fault condition occured in the game. The game will shut down.\n")

   229

	_T("Please send the crash information and the crash.dmp file (if any) to the developers.\n")

   230

	_T("This will greatly help debugging. The correct place to do this is http://bugs.openttd.org. ")

   231

	_T("The information contained in the report is displayed below.\n")

   232

	_T("Press \"Emergency save\" to attempt saving the game.");

   233

   234

static const TCHAR _save_succeeded[] =

   235

	_T("Emergency save succeeded.\n")

   236

	_T("Be aware that critical parts of the internal game state may have become ")

   237

	_T("corrupted. The saved game is not guaranteed to work.");

   238

   239

static bool EmergencySave()

   240

{

   241

	SaveOrLoad("crash.sav", SL_SAVE, BASE_DIR);

   242

	return true;

   243

}

   244

   245

/* Disable the crash-save submit code as it's not used */

   246

#if 0

   247

   248

struct WinInetProcs {

   249

	HINTERNET (WINAPI *InternetOpen)(LPCTSTR, DWORD, LPCTSTR, LPCTSTR, DWORD);

   250

	HINTERNET (WINAPI *InternetConnect)(HINTERNET, LPCTSTR, INTERNET_PORT, LPCTSTR, LPCTSTR, DWORD, DWORD, DWORD);

   251

	HINTERNET (WINAPI *HttpOpenRequest)(HINTERNET, LPCTSTR, LPCTSTR, LPCTSTR, LPCTSTR, LPCTSTR *, DWORD, DWORD);

   252

	BOOL (WINAPI *HttpSendRequest)(HINTERNET, LPCTSTR, DWORD, LPVOID, DWORD);

   253

	BOOL (WINAPI *InternetCloseHandle)(HINTERNET);

   254

	BOOL (WINAPI *HttpQueryInfo)(HINTERNET, DWORD, LPVOID, LPDWORD, LPDWORD);

   255

};

   256

   257

#define M(x) x "\0"

   258

#if defined(UNICODE)

   259

# define W(x) x "W"

   260

#else

   261

# define W(x) x "A"

   262

#endif

   263

static const char wininet_files[] =

   264

	M("wininet.dll")

   265

	M(W("InternetOpen"))

   266

	M(W("InternetConnect"))

   267

	M(W("HttpOpenRequest"))

   268

	M(W("HttpSendRequest"))

   269

	M("InternetCloseHandle")

   270

	M(W("HttpQueryInfo"))

   271

	M("");

   272

#undef W

   273

#undef M

   274

   275

static WinInetProcs _wininet;

   276

   277

static const TCHAR *SubmitCrashReport(HWND wnd, void *msg, size_t msglen, const TCHAR *arg)

   278

{

   279

	HINTERNET inet, conn, http;

   280

	const TCHAR *err = NULL;

   281

	DWORD code, len;

   282

	static TCHAR buf[100];

   283

	TCHAR buff[100];

   284

   285

	if (_wininet.InternetOpen == NULL && !LoadLibraryList((Function*)&_wininet, wininet_files)) return _T("can't load wininet.dll");

   286

   287

	inet = _wininet.InternetOpen(_T("OTTD"), INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0 );

   288

	if (inet == NULL) { err = _T("internetopen failed"); goto error1; }

   289

   290

	conn = _wininet.InternetConnect(inet, _T("www.openttd.org"), INTERNET_DEFAULT_HTTP_PORT, _T(""), _T(""), INTERNET_SERVICE_HTTP, 0, 0);

   291

	if (conn == NULL) { err = _T("internetconnect failed"); goto error2; }

   292

   293

	_sntprintf(buff, lengthof(buff), _T("/crash.php?file=%s&ident=%d"), arg, _ident);

   294

   295

	http = _wininet.HttpOpenRequest(conn, _T("POST"), buff, NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE , 0);

   296

	if (http == NULL) { err = _T("httpopenrequest failed"); goto error3; }

   297

   298

	if (!_wininet.HttpSendRequest(http, _T("Content-type: application/binary"), -1, msg, (DWORD)msglen)) { err = _T("httpsendrequest failed"); goto error4; }

   299

   300

	len = sizeof(code);

   301

	if (!_wininet.HttpQueryInfo(http, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &code, &len, 0)) { err = _T("httpqueryinfo failed"); goto error4; }

   302

   303

	if (code != 200) {

   304

		int l = _sntprintf(buf, lengthof(buf), _T("Server said: %d "), code);

   305

		len = sizeof(buf) - l;

   306

		_wininet.HttpQueryInfo(http, HTTP_QUERY_STATUS_TEXT, buf + l, &len, 0);

   307

		err = buf;

   308

	}

   309

   310

error4:

   311

	_wininet.InternetCloseHandle(http);

   312

error3:

   313

	_wininet.InternetCloseHandle(conn);

   314

error2:

   315

	_wininet.InternetCloseHandle(inet);

   316

error1:

   317

	return err;

   318

}

   319

   320

static void SubmitFile(HWND wnd, const TCHAR *file)

   321

{

   322

	HANDLE h;

   323

	unsigned long size;

   324

	unsigned long read;

   325

	void *mem;

   326

   327

	h = CreateFile(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);

   328

	if (h == NULL) return;

   329

   330

	size = GetFileSize(h, NULL);

   331

	if (size > 500000) goto error1;

   332

   333

	mem = MallocT<byte>(size);

   334

	if (mem == NULL) goto error1;

   335

   336

	if (!ReadFile(h, mem, size, &read, NULL) || read != size) goto error2;

   337

   338

	SubmitCrashReport(wnd, mem, size, file);

   339

   340

error2:

   341

	free(mem);

   342

error1:

   343

	CloseHandle(h);

   344

}

   345

   346

#endif /* Disabled crash-submit procedures */

   347

   348

static const TCHAR * const _expand_texts[] = {_T("S&how report >>"), _T("&Hide report <<") };

   349

   350

static void SetWndSize(HWND wnd, int mode)

   351

{

   352

	RECT r, r2;

   353

	int offs;

   354

   355

	GetWindowRect(wnd, &r);

   356

   357

	SetDlgItemText(wnd, 15, _expand_texts[mode == 1]);

   358

   359

	if (mode >= 0) {

   360

		GetWindowRect(GetDlgItem(wnd, 11), &r2);

   361

		offs = r2.bottom - r2.top + 10;

   362

		if (!mode) offs = -offs;

   363

		SetWindowPos(wnd, HWND_TOPMOST, 0, 0,

   364

			r.right - r.left, r.bottom - r.top + offs, SWP_NOMOVE | SWP_NOZORDER);

   365

	} else {

   366

		SetWindowPos(wnd, HWND_TOPMOST,

   367

			(GetSystemMetrics(SM_CXSCREEN) - (r.right - r.left)) / 2,

   368

			(GetSystemMetrics(SM_CYSCREEN) - (r.bottom - r.top)) / 2,

   369

			0, 0, SWP_NOSIZE);

   370

	}

   371

}

   372

   373

static bool DoEmergencySave(HWND wnd)

   374

{

   375

	bool b = false;

   376

   377

	EnableWindow(GetDlgItem(wnd, 13), FALSE);

   378

	_did_emerg_save = true;

   379

	__try {

   380

		b = EmergencySave();

   381

	} __except (1) {}

   382

	return b;

   383

}

   384

   385

static INT_PTR CALLBACK CrashDialogFunc(HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam)

   386

{

   387

	switch (msg) {

   388

		case WM_INITDIALOG: {

   389

#if defined(UNICODE)

   390

			/* We need to put the crash-log in a seperate buffer because the default

   391

			 * buffer in MB_TO_WIDE is not large enough (512 chars) */

   392

			wchar_t crash_msgW[8096];

   393

#endif

   394

			SetDlgItemText(wnd, 10, _crash_desc);

   395

			SetDlgItemText(wnd, 11, MB_TO_WIDE_BUFFER(_crash_msg, crash_msgW, lengthof(crash_msgW)));

   396

			SendDlgItemMessage(wnd, 11, WM_SETFONT, (WPARAM)GetStockObject(ANSI_FIXED_FONT), FALSE);

   397

			SetWndSize(wnd, -1);

   398

		} return TRUE;

   399

		case WM_COMMAND:

   400

			switch (wParam) {

   401

				case 12: /* Close */

   402

					ExitProcess(0);

   403

				case 13: /* Emergency save */

   404

					if (DoEmergencySave(wnd)) {

   405

						MessageBox(wnd, _save_succeeded, _T("Save successful"), MB_ICONINFORMATION);

   406

					} else {

   407

						MessageBox(wnd, _T("Save failed"), _T("Save failed"), MB_ICONINFORMATION);

   408

					}

   409

					break;

   410

/* Disable the crash-save submit code as it's not used */

   411

#if 0

   412

				case 14: { /* Submit crash report */

   413

					const TCHAR *s;

   414

   415

					SetCursor(LoadCursor(NULL, IDC_WAIT));

   416

   417

					s = SubmitCrashReport(wnd, _crash_msg, strlen(_crash_msg), _T(""));

   418

					if (s != NULL) {

   419

						MessageBox(wnd, s, _T("Error"), MB_ICONSTOP);

   420

						break;

   421

					}

   422

   423

					// try to submit emergency savegame

   424

					if (_did_emerg_save || DoEmergencySave(wnd)) SubmitFile(wnd, _T("crash.sav"));

   425

   426

					// try to submit the autosaved game

   427

					if (_opt.autosave) {

   428

						TCHAR buf[40];

   429

						_sntprintf(buf, lengthof(buf), _T("autosave%d.sav"), (_autosave_ctr - 1) & 3);

   430

						SubmitFile(wnd, buf);

   431

					}

   432

					EnableWindow(GetDlgItem(wnd, 14), FALSE);

   433

					SetCursor(LoadCursor(NULL, IDC_ARROW));

   434

					MessageBox(wnd, _T("Crash report submitted. Thank you."), _T("Crash Report"), MB_ICONINFORMATION);

   435

				} break;

   436

#endif /* Disabled crash-submit procedures */

   437

				case 15: /* Expand window to show crash-message */

   438

					_expanded ^= 1;

   439

					SetWndSize(wnd, _expanded);

   440

					break;

   441

			}

   442

			return TRUE;

   443

		case WM_CLOSE: ExitProcess(0);

   444

	}

   445

   446

	return FALSE;

   447

}

   448

   449

static void Handler2()

   450

{

   451

	ShowCursor(TRUE);

   452

	ShowWindow(GetActiveWindow(), FALSE);

   453

	DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(100), NULL, CrashDialogFunc);

   454

}

   455

   456

extern bool CloseConsoleLogIfActive();

   457

   458

static HANDLE _file_crash_log;

   459

   460

static void GamelogPrintCrashLogProc(const char *s)

   461

{

   462

	DWORD num_written;

   463

	WriteFile(_file_crash_log, s, (DWORD)strlen(s), &num_written, NULL);

   464

	WriteFile(_file_crash_log, "\r\n", (DWORD)strlen("\r\n"), &num_written, NULL);

   465

}

   466

   467

/** Amount of output for the execption handler. */

   468

static const int EXCEPTION_OUTPUT_SIZE = 8192;

   469

   470

static LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS *ep)

   471

{

   472

	char *output;

   473

	static bool had_exception = false;

   474

   475

	if (had_exception) ExitProcess(0);

   476

	had_exception = true;

   477

   478

	_ident = GetTickCount(); // something pretty unique

   479

   480

	MakeCRCTable(AllocaM(uint32, 256));

   481

	_crash_msg = output = (char*)LocalAlloc(LMEM_FIXED, EXCEPTION_OUTPUT_SIZE);

   482

	const char *last = output + EXCEPTION_OUTPUT_SIZE - 1;

   483

   484

	{

   485

		SYSTEMTIME time;

   486

		GetLocalTime(&time);

   487

		output += seprintf(output, last,

   488

			"*** OpenTTD Crash Report ***\r\n"

   489

			"Date: %d-%.2d-%.2d %.2d:%.2d:%.2d\r\n"

   490

			"Build: %s built on " __DATE__ " " __TIME__ "\r\n",

   491

			time.wYear,

   492

			time.wMonth,

   493

			time.wDay,

   494

			time.wHour,

   495

			time.wMinute,