1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "hal.h"

     8

#include "macros.h"

     9

#include "saveload.h"

    10

#include "string.h"

    11

#include "gfx.h"

    12

#include "window.h"

    13

#include <windows.h>

    14

#include <winnt.h>

    15

#include <wininet.h>

    16

#include <io.h>

    17

#include <fcntl.h>

    18

#include "variables.h"

    19

#include "win32.h"

    20

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

    21

#include <ctype.h>

    22

#include <errno.h>

    23

#include <sys/types.h>

    24

#include <sys/stat.h>

    25

    26

static bool _has_console;

    27

    28

#if defined(__MINGW32__) || defined(__CYGWIN__)

    29

	#define __TIMESTAMP__   __DATE__ __TIME__

    30

#endif

    31

    32

#if defined(__MINGW32__)

    33

	#include <stdint.h>

    34

#endif

    35

    36

static bool cursor_visible = true;

    37

    38

bool MyShowCursor(bool show)

    39

{

    40

	if (cursor_visible == show) return show;

    41

    42

	cursor_visible = show;

    43

	ShowCursor(show);

    44

    45

	return !show;

    46

}

    47

    48

    49

// Helper function needed by dynamically loading SDL

    50

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

    51

{

    52

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

    53

		HMODULE lib = LoadLibrary(dll);

    54

    55

		if (lib == NULL) return false;

    56

		for (;;) {

    57

			FARPROC p;

    58

    59

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

    60

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

    61

			p = GetProcAddress(lib, dll);

    62

			if (p == NULL) return false;

    63

			*proc++ = (Function)p;

    64

		}

    65

		dll++;

    66

	}

    67

	return true;

    68

}

    69

    70

#ifdef _MSC_VER

    71

static const char *_exception_string;

    72

#endif

    73

    74

void ShowOSErrorBox(const char *buf)

    75

{

    76

	MyShowCursor(true);

    77

	MessageBoxA(GetActiveWindow(), buf, "Error!", MB_ICONSTOP);

    78

    79

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

    80

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

    81

	if (*buf == '!') {

    82

		_exception_string = buf;

    83

		*(byte*)0 = 0;

    84

	}

    85

#endif

    86

}

    87

    88

#ifdef _MSC_VER

    89

    90

static void *_safe_esp;

    91

static char *_crash_msg;

    92

static bool _expanded;

    93

static bool _did_emerg_save;

    94

static int _ident;

    95

    96

typedef struct DebugFileInfo {

    97

	uint32 size;

    98

	uint32 crc32;

    99

	SYSTEMTIME file_time;

   100

} DebugFileInfo;

   101

   102

static uint32 *_crc_table;

   103

   104

static void MakeCRCTable(uint32 *table) {

   105

	uint32 crc, poly = 0xEDB88320L;

   106

	int i;

   107

	int j;

   108

   109

	_crc_table = table;

   110

   111

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

   112

		crc = i;

   113

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

   114

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

   115

		}

   116

		table[i] = crc;

   117

	}

   118

}

   119

   120

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

   121

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

   122

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

   123

	}

   124

	return crc;

   125

}

   126

   127

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

   128

{

   129

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

   130

   131

	{

   132

		HANDLE file;

   133

		byte buffer[1024];

   134

		DWORD numread;

   135

		uint32 filesize = 0;

   136

		FILETIME write_time;

   137

		uint32 crc = (uint32)-1;

   138

   139

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

   140

			OPEN_EXISTING, 0, 0);

   141

		if (file != INVALID_HANDLE_VALUE) {

   142

			for (;;) {

   143

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

   144

						numread == 0)

   145

					break;

   146

				filesize += numread;

   147

				crc = CalcCRC(buffer, numread, crc);

   148

			}

   149

			dfi->size = filesize;

   150

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

   151

   152

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

   153

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

   154

			}

   155

			CloseHandle(file);

   156

		}

   157

	}

   158

}

   159

   160

   161

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

   162

{

   163

	char buffer[MAX_PATH];

   164

	DebugFileInfo dfi;

   165

   166

	GetModuleFileName(mod, buffer, MAX_PATH);

   167

	GetFileInfo(&dfi, buffer);

   168

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

   169

		buffer,

   170

		mod,

   171

		dfi.size,

   172

		dfi.crc32,

   173

		dfi.file_time.wYear,

   174

		dfi.file_time.wMonth,

   175

		dfi.file_time.wDay,

   176

		dfi.file_time.wHour,

   177

		dfi.file_time.wMinute,

   178

		dfi.file_time.wSecond

   179

	);

   180

	return output;

   181

}

   182

   183

static char *PrintModuleList(char *output)

   184

{

   185

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

   186

	HANDLE proc;

   187

	HMODULE modules[100];

   188

	DWORD needed;

   189

	BOOL res;

   190

	int count,i;

   191

   192

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

   193

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

   194

		if (proc) {

   195

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

   196

			CloseHandle(proc);

   197

			if (res) {

   198

				count =

   199

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

   200

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

   201

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

   202

				return output;

   203

			}

   204

		}

   205

	}

   206

	output = PrintModuleInfo(output, NULL);

   207

	return output;

   208

}

   209

   210

static const char _crash_desc[] =

   211

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

   212

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

   213

	"This will greatly help debugging. "

   214

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

   215

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

   216

   217

static const char _save_succeeded[] =

   218

	"Emergency save succeeded.\n"

   219

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

   220

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

   221

   222

static bool EmergencySave(void)

   223

{

   224

	SaveOrLoad("crash.sav", SL_SAVE);

   225

	return true;

   226

}

   227

   228

typedef struct {

   229

	HINTERNET (WINAPI *InternetOpenA)(LPCSTR,DWORD, LPCSTR, LPCSTR, DWORD);

   230

	HINTERNET (WINAPI *InternetConnectA)(HINTERNET, LPCSTR, INTERNET_PORT, LPCSTR, LPCSTR, DWORD, DWORD, DWORD);

   231

	HINTERNET (WINAPI *HttpOpenRequestA)(HINTERNET, LPCSTR, LPCSTR, LPCSTR, LPCSTR, LPCSTR *, DWORD, DWORD);

   232

	BOOL (WINAPI *HttpSendRequestA)(HINTERNET, LPCSTR, DWORD, LPVOID, DWORD);

   233

	BOOL (WINAPI *InternetCloseHandle)(HINTERNET);

   234

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

   235

} WinInetProcs;

   236

   237

#define M(x) x "\0"

   238

static const char wininet_files[] =

   239

	M("wininet.dll")

   240

	M("InternetOpenA")

   241

	M("InternetConnectA")

   242

	M("HttpOpenRequestA")

   243

	M("HttpSendRequestA")

   244

	M("InternetCloseHandle")

   245

	M("HttpQueryInfoA")

   246

	M("");

   247

#undef M

   248

   249

static WinInetProcs _wininet;

   250

   251

   252

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

   253

{

   254

	HINTERNET inet, conn, http;

   255

	const char *err = NULL;

   256

	DWORD code, len;

   257

	static char buf[100];

   258

	char buff[100];

   259

   260

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

   261

   262

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

   263

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

   264

   265

	conn = _wininet.InternetConnect(inet, "openttd.com", INTERNET_DEFAULT_HTTP_PORT, "", "", INTERNET_SERVICE_HTTP, 0, 0);

   266

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

   267

   268

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

   269

   270

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

   271

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

   272

   273

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

   274

   275

	len = sizeof(code);

   276

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

   277

   278

	if (code != 200) {

   279

		int l = sprintf(buf, "Server said: %d ", code);

   280

		len = sizeof(buf) - l;

   281

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

   282

		err = buf;

   283

	}

   284

   285

error4:

   286

	_wininet.InternetCloseHandle(http);

   287

error3:

   288

	_wininet.InternetCloseHandle(conn);

   289

error2:

   290

	_wininet.InternetCloseHandle(inet);

   291

error1:

   292

	return err;

   293

}

   294

   295

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

   296

{

   297

	HANDLE h;

   298

	unsigned long size;

   299

	unsigned long read;

   300

	void *mem;

   301

   302

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

   303

	if (h == NULL) return;

   304

   305

	size = GetFileSize(h, NULL);

   306

	if (size > 500000) goto error1;

   307

   308

	mem = malloc(size);

   309

	if (mem == NULL) goto error1;

   310

   311

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

   312

   313

	SubmitCrashReport(wnd, mem, size, file);

   314

   315

error2:

   316

	free(mem);

   317

error1:

   318

	CloseHandle(h);

   319

}

   320

   321

static const char * const _expand_texts[] = {"S&how report >>", "&Hide report <<" };

   322

   323

static void SetWndSize(HWND wnd, int mode)

   324

{

   325

	RECT r,r2;

   326

	int offs;

   327

   328

	GetWindowRect(wnd, &r);

   329

   330

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

   331

   332

	if (mode >= 0) {

   333

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

   334

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

   335

		if (!mode) offs = -offs;

   336

		SetWindowPos(wnd, HWND_TOPMOST, 0, 0,

   337

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

   338

	} else {

   339

		SetWindowPos(wnd, HWND_TOPMOST,

   340

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

   341

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

   342

			0, 0, SWP_NOSIZE);

   343

	}

   344

}

   345

   346

static bool DoEmergencySave(HWND wnd)

   347

{

   348

	bool b = false;

   349

   350

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

   351

	_did_emerg_save = true;

   352

	__try {

   353

		b = EmergencySave();

   354

	} __except (1) {}

   355

	return b;

   356

}

   357

   358

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

   359

{

   360

	switch (msg) {

   361

	case WM_INITDIALOG:

   362

		SetDlgItemText(wnd, 10, _crash_desc);

   363

		SetDlgItemText(wnd, 11, _crash_msg);

   364

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

   365

		SetWndSize(wnd, -1);

   366

		return TRUE;

   367

	case WM_COMMAND:

   368

		switch (wParam) {

   369

		case 12: // Close

   370

			ExitProcess(0);

   371

		case 13: { // Emergency save

   372

			if (DoEmergencySave(wnd)) {

   373

				MessageBoxA(wnd, _save_succeeded, "Save successful", MB_ICONINFORMATION);

   374

			} else {

   375

				MessageBoxA(wnd, "Save failed", "Save failed", MB_ICONINFORMATION);

   376

			}

   377

			break;

   378

		}

   379

		case 14: { // Submit crash report

   380

			const char *s;

   381

   382

			SetCursor(LoadCursor(NULL, IDC_WAIT));

   383

   384

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

   385

			if (s) {

   386

				MessageBoxA(wnd, s, "Error", MB_ICONSTOP);

   387

				break;

   388

			}

   389

   390

			// try to submit emergency savegame

   391

			if (_did_emerg_save || DoEmergencySave(wnd)) {

   392

				SubmitFile(wnd, "crash.sav");

   393

			}

   394

			// try to submit the autosaved game

   395

			if (_opt.autosave) {

   396

				char buf[40];

   397

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

   398

				SubmitFile(wnd, buf);

   399

			}

   400

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

   401

			SetCursor(LoadCursor(NULL, IDC_ARROW));

   402

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

   403

			break;

   404

		}

   405

		case 15: // Expand

   406

			_expanded ^= 1;

   407

			SetWndSize(wnd, _expanded);

   408

			break;

   409

		}

   410

		return TRUE;

   411

	case WM_CLOSE:

   412

		ExitProcess(0);

   413

	}

   414

   415

	return FALSE;

   416

}

   417

   418

static void Handler2(void)

   419

{

   420

	ShowCursor(TRUE);

   421

	ShowWindow(GetActiveWindow(), FALSE);

   422

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

   423

}

   424

   425

extern bool CloseConsoleLogIfActive(void);

   426

   427

static LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS *ep)

   428

{

   429

	extern const char _openttd_revision[];

   430

	char *output;

   431

	static bool had_exception;

   432

   433

	if (had_exception) ExitProcess(0);

   434

	had_exception = true;

   435

   436

	_ident = GetTickCount(); // something pretty unique

   437

   438

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

   439

	_crash_msg = output = LocalAlloc(LMEM_FIXED, 8192);

   440

   441

	{

   442

		SYSTEMTIME time;

   443

		GetLocalTime(&time);

   444

		output += sprintf(output,

   445

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

   446

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

   447

			"Build: %s built on " __TIMESTAMP__ "\r\n",

   448

			time.wYear,

   449

			time.wMonth,

   450

			time.wDay,

   451

			time.wHour,

   452

			time.wMinute,

   453

			time.wSecond,

   454

			_openttd_revision

   455

		);

   456

	}

   457

   458

	if (_exception_string)

   459

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

   460

   461

#ifdef _M_AMD64

   462

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

   463

		"Registers:\r\n"

   464

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

   465

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

   466

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

   467

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

   468

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

   469

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

   470

		ep->ExceptionRecord->ExceptionCode,

   471

		ep->ExceptionRecord->ExceptionAddress,

   472

		ep->ContextRecord->Rax,

   473

		ep->ContextRecord->Rbx,

   474

		ep->ContextRecord->Rcx,

   475

		ep->ContextRecord->Rdx,

   476

		ep->ContextRecord->Rsi,

   477

		ep->ContextRecord->Rdi,

   478

		ep->ContextRecord->Rbp,

   479

		ep->ContextRecord->Rsp,

   480

		ep->ContextRecord->R8,

   481

		ep->ContextRecord->R9,

   482

		ep->ContextRecord->R10,

   483

		ep->ContextRecord->R11,

   484

		ep->ContextRecord->R12,

   485

		ep->ContextRecord->R13,

   486

		ep->ContextRecord->R14,

   487

		ep->ContextRecord->R15,

   488

		ep->ContextRecord->Rip,

   489

		ep->ContextRecord->EFlags

   490

	);

   491

#else

   492

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

   493

		"Registers:\r\n"

   494

		" EAX: %.8X EBX: %.8X ECX: %.8X EDX: %.8X\r\n"

   495

		" ESI: %.8X EDI: %.8X EBP: %.8X ESP: %.8X\r\n"

   496

		" EIP: %.8X EFLAGS: %.8X\r\n"

   497

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

   498

		ep->ExceptionRecord->ExceptionCode,

   499

		ep->ExceptionRecord->ExceptionAddress,

   500

		ep->ContextRecord->Eax,

   501

		ep->ContextRecord->Ebx,

   502

		ep->ContextRecord->Ecx,

   503

		ep->ContextRecord->Edx,

   504

		ep->ContextRecord->Esi,

   505

		ep->ContextRecord->Edi,

   506

		ep->ContextRecord->Ebp,

   507

		ep->ContextRecord->Esp,

   508

		ep->ContextRecord->Eip,

   509

		ep->ContextRecord->EFlags

   510

	);