1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "debug.h"

     4

#include "functions.h"

     6

#include "saveload.h"

     7

#include "string.h"

     8

#include "table/strings.h"

     9

#include "gfx.h"

    10

#include "window.h"

    11

#include <windows.h>

    12

#include <winnt.h>

    13

#include <wininet.h>

    14

#include <io.h>

    15

#include <fcntl.h>

    16

#include "variables.h"

    17

    19

    23

    30

static bool _has_console;

    31

    32

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

    33

	#define __TIMESTAMP__   __DATE__ __TIME__

    34

#endif

    35

    36

    37

// Helper function needed by dynamically loading SDL

    38

bool LoadLibraryList(void **proc, const char *dll)

    39

{

    40

	HMODULE lib;

    41

	void *p;

    42

    43

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

    44

		lib = LoadLibrary(dll);

    45

		if (lib == NULL)

    46

			return false;

    47

		while (true) {

    48

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

    49

			if (*dll == '\0')

    50

				break;

    51

			p = GetProcAddress(lib, dll);

    52

			if (p == NULL)

    53

				return false;

    54

			*proc++ = p;

    55

		}

    56

		dll++;

    57

	}

    58

	return true;

    59

}

    60

    61

#ifdef _MSC_VER

    62

    63

static const char *_exception_string;

    64

static void *_safe_esp;

    65

static char *_crash_msg;

    66

static bool _expanded;

    67

static bool _did_emerg_save;

    68

static int _ident;

    69

    70

void ShowOSErrorBox(const char *buf)

    71

{

    72

	MyShowCursor(true);

    73

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

    74

    75

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

    76

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

    77

	if (*buf == '!') {

    78

		_exception_string = buf;

    79

		*(byte*)0 = 0;

    80

	}

    81

#endif

    82

}

    83

    84

typedef struct DebugFileInfo {

    85

	uint32 size;

    86

	uint32 crc32;

    87

	SYSTEMTIME file_time;

    88

} DebugFileInfo;

    89

    90

static uint32 *_crc_table;

    91

    92

static void MakeCRCTable(uint32 *table) {

    93

	uint32 crc, poly = 0xEDB88320L;

    94

	int i;

    95

	int j;

    96

    97

	_crc_table = table;

    98

    99

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

   100

		crc = i;

   101

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

   102

			if (crc & 1)

   103

				crc = (crc >> 1) ^ poly;

   104

			else

   105

				crc >>= 1;

   106

		}

   107

		table[i] = crc;

   108

	}

   109

}

   110

   111

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

   112

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

   113

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

   114

	}

   115

	return crc;

   116

}

   117

   118

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

   119

{

   120

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

   121

   122

	{

   123

		HANDLE file;

   124

		byte buffer[1024];

   125

		DWORD numread;

   126

		uint32 filesize = 0;

   127

		FILETIME write_time;

   128

		uint32 crc = (uint32)-1;

   129

   130

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

   131

			OPEN_EXISTING, 0, 0);

   132

		if (file != INVALID_HANDLE_VALUE) {

   133

			while(true) {

   134

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

   135

						numread == 0)

   136

					break;

   137

				filesize += numread;

   138

				crc = CalcCRC(buffer, numread, crc);

   139

			}

   140

			dfi->size = filesize;

   141

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

   142

   143

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

   144

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

   145

			}

   146

			CloseHandle(file);

   147

		}

   148

	}

   149

}

   150

   151

   152

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

   153

{

   154

	char buffer[MAX_PATH];

   155

	DebugFileInfo dfi;

   156

   157

	GetModuleFileName(mod, buffer, MAX_PATH);

   158

	GetFileInfo(&dfi, buffer);

   159

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

   160

		buffer,

   161

		mod,

   162

		dfi.size,

   163

		dfi.crc32,

   164

		dfi.file_time.wYear,

   165

		dfi.file_time.wMonth,

   166

		dfi.file_time.wDay,

   167

		dfi.file_time.wHour,

   168

		dfi.file_time.wMinute,

   169

		dfi.file_time.wSecond

   170

	);

   171

	return output;

   172

}

   173

   174

static char *PrintModuleList(char *output)

   175

{

   176

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

   177

	HANDLE proc;

   178

	HMODULE modules[100];

   179

	DWORD needed;

   180

	BOOL res;

   181

	int count,i;

   182

   183

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

   184

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

   185

		if (proc) {

   186

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

   187

			CloseHandle(proc);

   188

			if (res) {

   189

				count =

   190

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

   191

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

   192

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

   193

				return output;

   194

			}

   195

		}

   196

	}

   197

	output = PrintModuleInfo(output, NULL);

   198

	return output;

   199

}

   200

   201

static const char _crash_desc[] =

   202

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

   203

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

   204

	"This will greatly help debugging. "

   205

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

   206

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

   207

   208

static const char _save_succeeded[] =

   209

	"Emergency save succeeded.\n"

   210

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

   211

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

   212

   213

static bool EmergencySave(void)

   214

{

   215

	SaveOrLoad("crash.sav", SL_SAVE);

   216

	return true;

   217

}

   218

   219

typedef struct {

   220

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

   221

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

   222

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

   223

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

   224

	BOOL (WINAPI *InternetCloseHandle)(HINTERNET);

   225

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

   226

} WinInetProcs;

   227

   228

#define M(x) x "\0"

   229

static const char wininet_files[] =

   230

	M("wininet.dll")

   231

	M("InternetOpenA")

   232

	M("InternetConnectA")

   233

	M("HttpOpenRequestA")

   234

	M("HttpSendRequestA")

   235

	M("InternetCloseHandle")

   236

	M("HttpQueryInfoA")

   237

	M("");

   238

#undef M

   239

   240

static WinInetProcs _wininet;

   241

   242

   243

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

   244

{

   245

	HINTERNET inet, conn, http;

   246

	char *err = NULL;

   247

	DWORD code, len;

   248

	static char buf[100];

   249

	char buff[100];

   250

   251

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

   252

   253

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

   254

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

   255

   256

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

   257

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

   258

   259

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

   260

   261

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

   262

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

   263

   264

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

   265

   266

	len = sizeof(code);

   267

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

   268

   269

	if (code != 200) {

   270

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

   271

		len = sizeof(buf) - l;

   272

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

   273

		err = buf;

   274

	}

   275

   276

error4:

   277

	_wininet.InternetCloseHandle(http);

   278

error3:

   279

	_wininet.InternetCloseHandle(conn);

   280

error2:

   281

	_wininet.InternetCloseHandle(inet);

   282

error1:

   283

	return err;

   284

}

   285

   286

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

   287

{

   288

	HANDLE h;

   289

	unsigned long size;

   290

	unsigned long read;

   291

	void *mem;

   292

   293

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

   294

	if (h == NULL) return;

   295

   296

	size = GetFileSize(h, NULL);

   297

	if (size > 500000) goto error1;

   298

   299

	mem = malloc(size);

   300

	if (mem == NULL) goto error1;

   301

   302

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

   303

   304

	SubmitCrashReport(wnd, mem, size, file);

   305

   306

error2:

   307

	free(mem);

   308

error1:

   309

	CloseHandle(h);

   310

}

   311

   312

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

   313

   314

static void SetWndSize(HWND wnd, int mode)

   315

{

   316

	RECT r,r2;

   317

	int offs;

   318

   319

	GetWindowRect(wnd, &r);

   320

   321

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

   322

   323

	if (mode >= 0) {

   324

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

   325

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

   326

		if (!mode) offs = -offs;

   327

		SetWindowPos(wnd, HWND_TOPMOST, 0, 0,

   328

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

   329

	} else {

   330

		SetWindowPos(wnd, HWND_TOPMOST,

   331

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

   332

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

   333

			0, 0, SWP_NOSIZE);

   334

	}

   335

}

   336

   337

static bool DoEmergencySave(HWND wnd)

   338

{

   339

	bool b = false;

   340

   341

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

   342

	_did_emerg_save = true;

   343

	__try {

   344

		b = EmergencySave();

   345

	} __except (1) {}

   346

	return b;

   347

}

   348

   349

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

   350

{

   351

	switch(msg) {

   352

	case WM_INITDIALOG:

   353

		SetDlgItemText(wnd, 10, _crash_desc);

   354

		SetDlgItemText(wnd, 11, _crash_msg);

   355

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

   356

		SetWndSize(wnd, -1);

   357

		return TRUE;

   358

	case WM_COMMAND:

   359

		switch(wParam) {

   360

		case 12: // Close

   361

			ExitProcess(0);

   362

		case 13: { // Emergency save

   363

			if (DoEmergencySave(wnd))

   364

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

   365

			else

   366

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

   367

			break;

   368

		}

   369

		case 14: { // Submit crash report

   370

			char *s;

   371

   372

			SetCursor(LoadCursor(NULL, IDC_WAIT));

   373

   374

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

   375

			if (s) {

   376

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

   377

				break;

   378

			}

   379

   380

			// try to submit emergency savegame

   381

			if (_did_emerg_save || DoEmergencySave(wnd)) {

   382

				SubmitFile(wnd, "crash.sav");

   383

			}

   384

			// try to submit the autosaved game

   385

			if (_opt.autosave) {

   386

				char buf[40];

   387

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

   388

				SubmitFile(wnd, buf);

   389

			}

   390

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

   391

			SetCursor(LoadCursor(NULL, IDC_ARROW));

   392

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

   393

			break;

   394

		}

   395

		case 15: // Expand

   396

			_expanded ^= 1;

   397

			SetWndSize(wnd, _expanded);

   398

			break;

   399

		}

   400

		return TRUE;

   401

	case WM_CLOSE:

   402

		ExitProcess(0);

   403

	}

   404

   405

	return FALSE;

   406

}

   407

   408

static void Handler2(void)

   409

{

   410

	ShowCursor(TRUE);

   411

	ShowWindow(GetActiveWindow(), FALSE);

   412

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

   413

}

   414

   415

extern bool CloseConsoleLogIfActive(void);

   416

   417

static LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS *ep)

   418

{

   419

	char *output;

   420

	static bool had_exception;

   421

   422

	if (had_exception) ExitProcess(0);

   423

	had_exception = true;

   424

   425

	_ident = GetTickCount(); // something pretty unique

   426

   427

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

   428

	_crash_msg = output = LocalAlloc(LMEM_FIXED, 8192);

   429

   430

	{

   431

		SYSTEMTIME time;

   432

		GetLocalTime(&time);

   433

		output += sprintf(output,

   434

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

   435

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

   436

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

   437

			time.wYear,

   438

			time.wMonth,

   439

			time.wDay,

   440

			time.wHour,

   441

			time.wMinute,

   442

			time.wSecond,

   443

			"???"

   444

		);

   445

	}

   446

   447

	if (_exception_string)

   448

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

   449

   450

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

   451

		"Registers:\r\n"

   452

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

   453

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

   454

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

   455

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

   456

		ep->ExceptionRecord->ExceptionCode,

   457

		ep->ExceptionRecord->ExceptionAddress,

   458

		ep->ContextRecord->Eax,

   459

		ep->ContextRecord->Ebx,

   460

		ep->ContextRecord->Ecx,

   461

		ep->ContextRecord->Edx,

   462

		ep->ContextRecord->Esi,

   463

		ep->ContextRecord->Edi,

   464

		ep->ContextRecord->Ebp,

   465

		ep->ContextRecord->Esp,

   466

		ep->ContextRecord->Eip,

   467

		ep->ContextRecord->EFlags

   468

	);

   469

   470

	{

   471

		byte *b = (byte*)ep->ContextRecord->Eip;

   472

		int i;

   473

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

   474

			if (IsBadReadPtr(b, 1)) {

   475

				output += sprintf(output, " ??"); // OCR: WAS: , 0);

   476

			} else {

   477

				output += sprintf(output, " %.2X", *b);

   478

			}

   479

			b++;

   480

		}

   481

		output += sprintf(output,

   482

			"\r\n"

   483

			"\r\nStack trace: \r\n"

   484

		);

   485

	}

   486

   487

	{

   488

		int i,j;

   489

		uint32 *b = (uint32*)ep->ContextRecord->Esp;

   490

		for (j = 0; j != 24; j++) {

   491

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

   492

				if (IsBadReadPtr(b,sizeof(uint32))) {

   493

					output += sprintf(output, " ????????"); //OCR: WAS - , 0);

   494

				} else {

   495

					output += sprintf(output, " %.8X", *b);

   496

				}

   497

				b++;

   498

			}

   499

			output += sprintf(output, "\r\n");

   500

		}

   501

	}

   502

   503

	output += sprintf(output, "\r\nModule information:\r\n");

   504

	output = PrintModuleList(output);

   505

   506

	{

   507

		OSVERSIONINFO os;

   508

		os.dwOSVersionInfoSize = sizeof(os);

   509

		GetVersionEx(&os);

   510

		output += sprintf(output, "\r\nSystem information:\r\n"

   511

			" Windows version %d.%d %d %s\r\n",

   512

			os.dwMajorVersion, os.dwMinorVersion, os.dwBuildNumber, os.szCSDVersion);

   513

	}

   514

   515

	{

   516

		HANDLE file = CreateFile("crash.log", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, 0);

   517

		DWORD num_written;