1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "macros.h"

     8

#include "saveload.h"

     9

#include "string.h"

    10

#include "gfx.h"

    11

#include "window.h"

    12

#include <windows.h>

    13

#include <winnt.h>

    14

#include <wininet.h>

    15

#include <io.h>

    16

#include <fcntl.h>

    18

#include "variables.h"

    19

#include "win32.h"

    20

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

    21

#include <ctype.h>

    22

#include <tchar.h>

    23

#include <errno.h>

    24

#include <sys/types.h>

    25

#include <sys/stat.h>

    26

    27

static bool _has_console;

    28

    29

#if defined(__MINGW32__)

    30

	#include <stdint.h>

    31

#endif

    32

    33

static bool cursor_visible = true;

    34

    35

bool MyShowCursor(bool show)

    36

{

    37

	if (cursor_visible == show) return show;

    38

    39

	cursor_visible = show;

    40

	ShowCursor(show);

    41

    42

	return !show;

    43

}

    44

    45

/** Helper function needed by dynamically loading libraries

    46

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

    47

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

    48

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

    49

{

    50

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

    51

		HMODULE lib;

    52

		lib = LoadLibrary(MB_TO_WIDE(dll));

    53

    54

		if (lib == NULL) return false;

    55

		for (;;) {

    56

			FARPROC p;

    57

    58

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

    59

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

    60

#if defined(WINCE)

    61

			p = GetProcAddress(lib, MB_TO_WIDE(dll);

    62

#else

    63

			p = GetProcAddress(lib, dll);

    64

#endif

    65

			if (p == NULL) return false;

    66

			*proc++ = (Function)p;

    67

		}

    68

		dll++;

    69

	}

    70

	return true;

    71

}

    72

    73

#ifdef _MSC_VER

    74

static const char *_exception_string = NULL;

    75

#endif

    76

    77

void ShowOSErrorBox(const char *buf)

    78

{

    79

	MyShowCursor(true);

    80

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

    81

    82

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

    83

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

    84

	if (*buf == '!') {

    85

		_exception_string = buf;

    86

		*(byte*)0 = 0;

    87

	}

    88

#endif

    89

}

    90

    91

#ifdef _MSC_VER

    92

    93

static void *_safe_esp;

    94

static char *_crash_msg;

    95

static bool _expanded;

    96

static bool _did_emerg_save;

    97

static int _ident;

    98

    99

typedef struct DebugFileInfo {

   100

	uint32 size;

   101

	uint32 crc32;

   102

	SYSTEMTIME file_time;

   103

} DebugFileInfo;

   104

   105

static uint32 *_crc_table;

   106

   107

static void MakeCRCTable(uint32 *table) {

   108

	uint32 crc, poly = 0xEDB88320L;

   109

	int i;

   110

	int j;

   111

   112

	_crc_table = table;

   113

   114

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

   115

		crc = i;

   116

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

   117

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

   118

		}

   119

		table[i] = crc;

   120

	}

   121

}

   122

   123

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

   124

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

   125

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

   126

	}

   127

	return crc;

   128

}

   129

   130

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

   131

{

   132

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

   133

   134

	{

   135

		HANDLE file;

   136

		byte buffer[1024];

   137

		DWORD numread;

   138

		uint32 filesize = 0;

   139

		FILETIME write_time;

   140

		uint32 crc = (uint32)-1;

   141

   142

		file = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,

   143

			OPEN_EXISTING, 0, 0);

   144

		if (file != INVALID_HANDLE_VALUE) {

   145

			for (;;) {

   146

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

   147

						numread == 0)

   148

					break;

   149

				filesize += numread;

   150

				crc = CalcCRC(buffer, numread, crc);

   151

			}

   152

			dfi->size = filesize;

   153

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

   154

   155

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

   156

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

   157

			}

   158

			CloseHandle(file);

   159

		}

   160

	}

   161

}

   162

   163

   164

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

   165

{

   166

	TCHAR buffer[MAX_PATH];

   167

	DebugFileInfo dfi;

   168

   169

	GetModuleFileName(mod, buffer, MAX_PATH);

   170

	GetFileInfo(&dfi, buffer);

   171

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

   172

		WIDE_TO_MB(buffer),

   173

		mod,

   174

		dfi.size,

   175

		dfi.crc32,

   176

		dfi.file_time.wYear,

   177

		dfi.file_time.wMonth,

   178

		dfi.file_time.wDay,

   179

		dfi.file_time.wHour,

   180

		dfi.file_time.wMinute,

   181

		dfi.file_time.wSecond

   182

	);

   183

	return output;

   184

}

   185

   186

static char *PrintModuleList(char *output)

   187

{

   188

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

   189

	HANDLE proc;

   190

	HMODULE modules[100];

   191

	DWORD needed;

   192

	BOOL res;

   193

	int count,i;

   194

   195

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

   196

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

   197

		if (proc) {

   198

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

   199

			CloseHandle(proc);

   200

			if (res) {

   201

				count =

   202

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

   203

				for (i = 0; i != count; i++)

   204

					output = PrintModuleInfo(output, modules[i]);

   205

				return output;

   206

			}

   207

		}

   208

	}

   209

	output = PrintModuleInfo(output, NULL);

   210

	return output;

   211

}

   212

   213

static const TCHAR _crash_desc[] =

   214

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

   215

	_T("Press \"Submit report\" to send crash information to the developers. ")

   216

	_T("This will greatly help debugging. ")

   217

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

   218

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

   219

   220

static const TCHAR _save_succeeded[] =

   221

	_T("Emergency save succeeded.\n")

   222

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

   223

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

   224

   225

static bool EmergencySave(void)

   226

{

   227

	SaveOrLoad("crash.sav", SL_SAVE);

   228

	return true;

   229

}

   230

   231

typedef struct {

   232

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

   233

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

   234

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

   235

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

   236

	BOOL (WINAPI *InternetCloseHandle)(HINTERNET);

   237

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

   238

} WinInetProcs;

   239

   240

#define M(x) x "\0"

   241

#if defined(UNICODE)

   242

# define W(x) x "W"

   243

#else

   244

# define W(x) x "A"

   245

#endif

   246

static const char wininet_files[] =

   247

	M("wininet.dll")

   248

	M(W("InternetOpen"))

   249

	M(W("InternetConnect"))

   250

	M(W("HttpOpenRequest"))

   251

	M(W("HttpSendRequest"))

   252

	M("InternetCloseHandle")

   253

	M(W("HttpQueryInfo"))

   254

	M("");

   255

#undef W

   256

#undef M

   257

   258

static WinInetProcs _wininet;

   259

   260

   261

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

   262

{

   263

	HINTERNET inet, conn, http;

   264

	const TCHAR *err = NULL;

   265

	DWORD code, len;

   266

	static TCHAR buf[100];

   267

	TCHAR buff[100];

   268

   269

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

   270

   271

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

   272

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

   273

   274

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

   275

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

   276

   277

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

   278

   279

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

   280

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

   281

   282

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

   283

   284

	len = sizeof(code);

   285

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

   286

   287

	if (code != 200) {

   288

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

   289

		len = sizeof(buf) - l;

   290

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

   291

		err = buf;

   292

	}

   293

   294

error4:

   295

	_wininet.InternetCloseHandle(http);

   296

error3:

   297

	_wininet.InternetCloseHandle(conn);

   298

error2:

   299

	_wininet.InternetCloseHandle(inet);

   300

error1:

   301

	return err;

   302

}

   303

   304

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

   305

{

   306

	HANDLE h;

   307

	unsigned long size;

   308

	unsigned long read;

   309

	void *mem;

   310

   311

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

   312

	if (h == NULL) return;

   313

   314

	size = GetFileSize(h, NULL);

   315

	if (size > 500000) goto error1;

   316

   317

	mem = malloc(size);

   318

	if (mem == NULL) goto error1;

   319

   320

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

   321

   322

	SubmitCrashReport(wnd, mem, size, file);

   323

   324

error2:

   325

	free(mem);

   326

error1:

   327

	CloseHandle(h);

   328

}

   329

   330

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

   331

   332

static void SetWndSize(HWND wnd, int mode)

   333

{

   334

	RECT r,r2;

   335

	int offs;

   336

   337

	GetWindowRect(wnd, &r);

   338

   339

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

   340

   341

	if (mode >= 0) {

   342

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

   343

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

   344

		if (!mode) offs = -offs;

   345

		SetWindowPos(wnd, HWND_TOPMOST, 0, 0,

   346

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

   347

	} else {

   348

		SetWindowPos(wnd, HWND_TOPMOST,

   349

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

   350

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

   351

			0, 0, SWP_NOSIZE);

   352

	}

   353

}

   354

   355

static bool DoEmergencySave(HWND wnd)

   356

{

   357

	bool b = false;

   358

   359

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

   360

	_did_emerg_save = true;

   361

	__try {

   362

		b = EmergencySave();

   363

	} __except (1) {}

   364

	return b;

   365

}

   366

   367

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

   368

{

   369

	switch (msg) {

   370

	case WM_INITDIALOG: {

   371

#if defined(UNICODE)

   372

		wchar_t crash_msgW[8096];

   373

#endif

   374

		SetDlgItemText(wnd, 10, _crash_desc);

   375

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

   376

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

   377

		SetWndSize(wnd, -1);

   378

	} return TRUE;

   379

	case WM_COMMAND:

   380

		switch (wParam) {

   381

		case 12: // Close

   382

			ExitProcess(0);

   383

		case 13: { // Emergency save

   384

			if (DoEmergencySave(wnd)) {

   385

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

   386

			} else {

   387

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

   388

			}

   389

			break;

   390

		}

   391

		case 14: { // Submit crash report

   392

			const TCHAR *s;

   393

   394

			SetCursor(LoadCursor(NULL, IDC_WAIT));

   395

   396

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

   397

			if (s != NULL) {

   398

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

   399

				break;

   400

			}

   401

   402

			// try to submit emergency savegame

   403

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

   404

   405

			// try to submit the autosaved game

   406

			if (_opt.autosave) {

   407

				TCHAR buf[40];

   408

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

   409

				SubmitFile(wnd, buf);

   410

			}

   411

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

   412

			SetCursor(LoadCursor(NULL, IDC_ARROW));

   413

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

   414

			break;

   415

		}

   416

		case 15: // Expand

   417

			_expanded ^= 1;

   418

			SetWndSize(wnd, _expanded);

   419

			break;

   420

		}

   421

		return TRUE;

   422

	case WM_CLOSE:

   423

		ExitProcess(0);

   424

	}

   425

   426

	return FALSE;

   427

}

   428

   429

static void Handler2(void)

   430

{

   431

	ShowCursor(TRUE);

   432

	ShowWindow(GetActiveWindow(), FALSE);

   433

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

   434

}

   435

   436

extern bool CloseConsoleLogIfActive(void);

   437

   438

static LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS *ep)

   439

{

   440

	extern const char _openttd_revision[];

   441

	char *output;

   442

	static bool had_exception = false;

   443

   444

	if (had_exception) ExitProcess(0);

   445

	had_exception = true;

   446

   447

	_ident = GetTickCount(); // something pretty unique

   448

   449

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

   450

	_crash_msg = output = LocalAlloc(LMEM_FIXED, 8192);

   451

   452

	{

   453

		SYSTEMTIME time;

   454

		GetLocalTime(&time);

   455

		output += sprintf(output,

   456

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

   457

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

   458

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

   459

			time.wYear,

   460

			time.wMonth,

   461

			time.wDay,

   462

			time.wHour,

   463

			time.wMinute,

   464

			time.wSecond,

   465

			_openttd_revision

   466

		);

   467

	}

   468

   469

	if (_exception_string)

   470

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

   471

   472

#ifdef _M_AMD64

   473

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

   474

		"Registers:\r\n"

   475

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

   476

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

   477

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

   478

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

   479

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

   480

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

   481

		ep->ExceptionRecord->ExceptionCode,

   482

		ep->ExceptionRecord->ExceptionAddress,

   483

		ep->ContextRecord->Rax,

   484

		ep->ContextRecord->Rbx,

   485

		ep->ContextRecord->Rcx,

   486

		ep->ContextRecord->Rdx,

   487

		ep->ContextRecord->Rsi,

   488

		ep->ContextRecord->Rdi,

   489

		ep->ContextRecord->Rbp,

   490

		ep->ContextRecord->Rsp,

   491

		ep->ContextRecord->R8,

   492

		ep->ContextRecord->R9,

   493

		ep->ContextRecord->R10,

   494

		ep->ContextRecord->R11,

   495

		ep->ContextRecord->R12,

   496

		ep->ContextRecord->R13,

   497

		ep->ContextRecord->R14,

   498

		ep->ContextRecord->R15,

   499

		ep->ContextRecord->Rip,

   500

		ep->ContextRecord->EFlags

   501

	);

   502

#else

   503