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 "functions.h"

     9

#include "macros.h"

    10

#include "helpers.hpp"

    11

#include "saveload.h"

    12

#include "string.h"

    13

#include "gfx.h"

    14

#include "window.h"

    15

#include "fileio.h"

    16

#include <windows.h>

    17

#include <winnt.h>

    18

#include <wininet.h>

    19

#include <io.h>

    20

#include <fcntl.h>

    21

#include <shlobj.h> // SHGetFolderPath

    22

#include "variables.h"

    23

#include "win32.h"

    24

#include "fios.h" // opendir/readdir/closedir

    25

#include "fileio.h"

    26

#include <ctype.h>

    27

#include <tchar.h>

    28

#include <errno.h>

    29

#include <sys/types.h>

    30

#include <sys/stat.h>

    31

#include <shlobj.h>

    32

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

    33

	#include <dbghelp.h>

    34

#endif

    35

    36

static bool _has_console;

    37

    38

#if defined(__MINGW32__)

    39

	#include <stdint.h>

    40

#endif

    41

    42

static bool cursor_visible = true;

    43

    44

bool MyShowCursor(bool show)

    45

{

    46

	if (cursor_visible == show) return show;

    47

    48

	cursor_visible = show;

    49

	ShowCursor(show);

    50

    51

	return !show;

    52

}

    53

    54

/** Helper function needed by dynamically loading libraries

    55

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

    56

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

    57

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

    58

{

    59

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

    60

		HMODULE lib;

    61

		lib = LoadLibrary(MB_TO_WIDE(dll));

    62

    63

		if (lib == NULL) return false;

    64

		for (;;) {

    65

			FARPROC p;

    66

    67

			while (*dll++ != '\0');

    68

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

    69

#if defined(WINCE)

    70

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

    71

#else

    72

			p = GetProcAddress(lib, dll);

    73

#endif

    74

			if (p == NULL) return false;

    75

			*proc++ = (Function)p;

    76

		}

    77

		dll++;

    78

	}

    79

	return true;

    80

}

    81

    82

#ifdef _MSC_VER

    83

static const char *_exception_string = NULL;

    84

#endif

    85

    86

void ShowOSErrorBox(const char *buf)

    87

{

    88

	MyShowCursor(true);

    89

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

    90

    91

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

    92

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

    93

	if (*buf == '!') {

    94

		_exception_string = buf;

    95

		*(byte*)0 = 0;

    96

	}

    97

#endif

    98

}

    99

   100

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

   101

   102

static void *_safe_esp;

   103

static char *_crash_msg;

   104

static bool _expanded;

   105

static bool _did_emerg_save;

   106

static int _ident;

   107

   108

struct DebugFileInfo {

   109

	uint32 size;

   110

	uint32 crc32;

   111

	SYSTEMTIME file_time;

   112

};

   113

   114

static uint32 *_crc_table;

   115

   116

static void MakeCRCTable(uint32 *table)

   117

{

   118

	uint32 crc, poly = 0xEDB88320L;

   119

	int i;

   120

	int j;

   121

   122

	_crc_table = table;

   123

   124

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

   125

		crc = i;

   126

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

   127

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

   128

		}

   129

		table[i] = crc;

   130

	}

   131

}

   132

   133

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

   134

{

   135

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

   136

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

   137

	}

   138

	return crc;

   139

}

   140

   141

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

   142

{

   143

	HANDLE file;

   144

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

   145

   146

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

   147

	if (file != INVALID_HANDLE_VALUE) {

   148

		byte buffer[1024];

   149

		DWORD numread;

   150

		uint32 filesize = 0;

   151

		FILETIME write_time;

   152

		uint32 crc = (uint32)-1;

   153

   154

		for (;;) {

   155

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

   156

				break;

   157

			filesize += numread;

   158

			crc = CalcCRC(buffer, numread, crc);

   159

		}

   160

		dfi->size = filesize;

   161

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

   162

   163

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

   164

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

   165

		}

   166

		CloseHandle(file);

   167

	}

   168

}

   169

   170

   171

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

   172

{

   173

	TCHAR buffer[MAX_PATH];

   174

	DebugFileInfo dfi;

   175

   176

	GetModuleFileName(mod, buffer, MAX_PATH);

   177

	GetFileInfo(&dfi, buffer);

   178

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

   179

		WIDE_TO_MB(buffer),

   180

		mod,

   181

		dfi.size,

   182

		dfi.crc32,

   183

		dfi.file_time.wYear,

   184

		dfi.file_time.wMonth,

   185

		dfi.file_time.wDay,

   186

		dfi.file_time.wHour,

   187

		dfi.file_time.wMinute,

   188

		dfi.file_time.wSecond

   189

	);

   190

	return output;

   191

}

   192

   193

static char *PrintModuleList(char *output)

   194

{

   195

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

   196

   197

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

   198

		HMODULE modules[100];

   199

		DWORD needed;

   200

		BOOL res;

   201

		int count, i;

   202

   203

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

   204

		if (proc != NULL) {

   205

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

   206

			CloseHandle(proc);

   207

			if (res) {

   208

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

   209

   210

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

   211

				return output;

   212

			}

   213

		}

   214

	}

   215

	output = PrintModuleInfo(output, NULL);

   216

	return output;

   217

}

   218

   219

static const TCHAR _crash_desc[] =

   220

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

   221

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

   222

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

   223

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

   224

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

   225

   226

static const TCHAR _save_succeeded[] =

   227

	_T("Emergency save succeeded.\n")

   228

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

   229

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

   230

   231

static bool EmergencySave()

   232

{

   233

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

   234

	return true;

   235

}

   236

   237

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

   238

#if 0

   239

   240

struct WinInetProcs {

   241

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

   242

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

   243

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

   244

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

   245

	BOOL (WINAPI *InternetCloseHandle)(HINTERNET);

   246

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

   247

};

   248

   249

#define M(x) x "\0"

   250

#if defined(UNICODE)

   251

# define W(x) x "W"

   252

#else

   253

# define W(x) x "A"

   254

#endif

   255

static const char wininet_files[] =

   256

	M("wininet.dll")

   257

	M(W("InternetOpen"))

   258

	M(W("InternetConnect"))

   259

	M(W("HttpOpenRequest"))

   260

	M(W("HttpSendRequest"))

   261

	M("InternetCloseHandle")

   262

	M(W("HttpQueryInfo"))

   263

	M("");

   264

#undef W

   265

#undef M

   266

   267

static WinInetProcs _wininet;

   268

   269

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

   270

{

   271

	HINTERNET inet, conn, http;

   272

	const TCHAR *err = NULL;

   273

	DWORD code, len;

   274

	static TCHAR buf[100];

   275

	TCHAR buff[100];

   276

   277

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

   278

   279

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

   280

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

   281

   282

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

   283

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

   284

   285

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

   286

   287

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

   288

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

   289

   290

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

   291

   292

	len = sizeof(code);

   293

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

   294

   295

	if (code != 200) {

   296

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

   297

		len = sizeof(buf) - l;

   298

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

   299

		err = buf;

   300

	}

   301

   302

error4:

   303

	_wininet.InternetCloseHandle(http);

   304

error3:

   305

	_wininet.InternetCloseHandle(conn);

   306

error2:

   307

	_wininet.InternetCloseHandle(inet);

   308

error1:

   309

	return err;

   310

}

   311

   312

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

   313

{

   314

	HANDLE h;

   315

	unsigned long size;

   316

	unsigned long read;

   317

	void *mem;

   318

   319

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

   320

	if (h == NULL) return;

   321

   322

	size = GetFileSize(h, NULL);

   323

	if (size > 500000) goto error1;

   324

   325

	mem = malloc(size);

   326

	if (mem == NULL) goto error1;

   327

   328

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

   329

   330

	SubmitCrashReport(wnd, mem, size, file);

   331

   332

error2:

   333

	free(mem);

   334

error1:

   335

	CloseHandle(h);

   336

}

   337

   338

#endif /* Disabled crash-submit procedures */

   339

   340

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

   341

   342

static void SetWndSize(HWND wnd, int mode)

   343

{

   344

	RECT r, r2;

   345

	int offs;

   346

   347

	GetWindowRect(wnd, &r);

   348

   349

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

   350

   351

	if (mode >= 0) {

   352

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

   353

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

   354

		if (!mode) offs = -offs;

   355

		SetWindowPos(wnd, HWND_TOPMOST, 0, 0,

   356

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

   357

	} else {

   358

		SetWindowPos(wnd, HWND_TOPMOST,

   359

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

   360

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

   361

			0, 0, SWP_NOSIZE);

   362

	}

   363

}

   364

   365

static bool DoEmergencySave(HWND wnd)

   366

{

   367

	bool b = false;

   368

   369

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

   370

	_did_emerg_save = true;

   371

	__try {

   372

		b = EmergencySave();

   373

	} __except (1) {}

   374

	return b;

   375

}

   376

   377

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

   378

{

   379

	switch (msg) {

   380

		case WM_INITDIALOG: {

   381

#if defined(UNICODE)

   382

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

   383

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

   384

			wchar_t crash_msgW[8096];

   385

#endif

   386

			SetDlgItemText(wnd, 10, _crash_desc);

   387

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

   388

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

   389

			SetWndSize(wnd, -1);

   390

		} return TRUE;

   391

		case WM_COMMAND:

   392

			switch (wParam) {

   393

				case 12: /* Close */

   394

					ExitProcess(0);

   395

				case 13: /* Emergency save */

   396

					if (DoEmergencySave(wnd)) {

   397

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

   398

					} else {

   399

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

   400

					}

   401

					break;

   402

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

   403

#if 0

   404

				case 14: { /* Submit crash report */

   405

					const TCHAR *s;

   406

   407

					SetCursor(LoadCursor(NULL, IDC_WAIT));

   408

   409

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

   410

					if (s != NULL) {

   411

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

   412

						break;

   413

					}

   414

   415

					// try to submit emergency savegame

   416

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

   417

   418

					// try to submit the autosaved game

   419

					if (_opt.autosave) {

   420

						TCHAR buf[40];

   421

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

   422

						SubmitFile(wnd, buf);

   423

					}

   424

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

   425

					SetCursor(LoadCursor(NULL, IDC_ARROW));

   426

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

   427

				} break;

   428

#endif /* Disabled crash-submit procedures */

   429

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

   430

					_expanded ^= 1;

   431

					SetWndSize(wnd, _expanded);

   432

					break;

   433

			}

   434

			return TRUE;

   435

		case WM_CLOSE: ExitProcess(0);

   436

	}

   437

   438

	return FALSE;

   439

}

   440

   441

static void Handler2()

   442

{

   443

	ShowCursor(TRUE);

   444

	ShowWindow(GetActiveWindow(), FALSE);

   445

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

   446

}

   447

   448

extern bool CloseConsoleLogIfActive();

   449

   450

static LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS *ep)

   451

{

   452

	extern const char _openttd_revision[];

   453

	char *output;

   454

	static bool had_exception = false;

   455

   456

	if (had_exception) ExitProcess(0);

   457

	had_exception = true;

   458

   459

	_ident = GetTickCount(); // something pretty unique

   460

   461

	MakeCRCTable((uint32*)alloca(256 * sizeof(uint32)));

   462

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

   463

   464

	{

   465

		SYSTEMTIME time;

   466

		GetLocalTime(&time);

   467

		output += sprintf(output,

   468

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

   469

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

   470

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

   471

			time.wYear,

   472

			time.wMonth,

   473

			time.wDay,

   474

			time.wHour,

   475

			time.wMinute,

   476

			time.wSecond,

   477

			_openttd_revision

   478

		);

   479

	}

   480

   481

	if (_exception_string)

   482

		output += sprintf(output, "Reason: %s\r\n", _exception_string);

   483

   484

#ifdef _M_AMD64

   485

	output += sprintf(output, "Exception %.8X at %.16IX\r\n"

   486

		"Registers:\r\n"

   487

		"RAX: %.16llX RBX: %.16llX RCX: %.16llX RDX: %.16llX\r\n"

   488

		"RSI: %.16llX RDI: %.16llX RBP: %.16llX RSP: %.16llX\r\n"

   489

		"R8:  %.16llX R9:  %.16llX R10: %.16llX R11: %.16llX\r\n"

   490

		"R12: %.16llX R13: %.16llX R14: %.16llX R15: %.16llX\r\n"

   491

		"RIP: %.16llX EFLAGS: %.8X\r\n"

   492

		"\r\nBytes at CS:RIP:\r\n",

   493

		ep->ExceptionRecord->ExceptionCode,

   494

		ep->ExceptionRecord->ExceptionAddress,

   495

		ep->ContextRecord->Rax,

   496

		ep->ContextRecord->Rbx,

   497

		ep->ContextRecord->Rcx,