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>

    17

#include "variables.h"

    18

#include "win32.h"

    19

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

    20

#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__)

    29

	#include <stdint.h>

    30

#endif

    31

    32

static bool cursor_visible = true;

    33

    34

bool MyShowCursor(bool show)

    35

{

    36

	if (cursor_visible == show) return show;

    37

    38

	cursor_visible = show;

    39

	ShowCursor(show);

    40

    41

	return !show;

    42

}

    43

    48

{

    49

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

    52

    53

		if (lib == NULL) return false;

    54

		for (;;) {

    55

			FARPROC p;

    56

    57

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

    58

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

    62

			p = GetProcAddress(lib, dll);

    64

			if (p == NULL) return false;

    65

			*proc++ = (Function)p;

    66

		}

    67

		dll++;

    68

	}

    69

	return true;

    70

}

    71

    72

#ifdef _MSC_VER

    74

#endif

    75

    76

void ShowOSErrorBox(const char *buf)

    77

{

    78

	MyShowCursor(true);

    80

    81

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

    82

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

    83

	if (*buf == '!') {

    84

		_exception_string = buf;

    85

		*(byte*)0 = 0;

    86

	}

    87

#endif

    88

}

    89

    90

#ifdef _MSC_VER

    91

    92

static void *_safe_esp;

    93

static char *_crash_msg;

    94

static bool _expanded;

    95

static bool _did_emerg_save;

    96

static int _ident;

    97

    98

typedef struct DebugFileInfo {

    99

	uint32 size;

   100

	uint32 crc32;

   101

	SYSTEMTIME file_time;

   102

} DebugFileInfo;

   103

   104

static uint32 *_crc_table;

   105

   106

static void MakeCRCTable(uint32 *table) {

   107

	uint32 crc, poly = 0xEDB88320L;

   108

	int i;

   109

	int j;

   110

   111

	_crc_table = table;

   112

   113

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

   114

		crc = i;

   115

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

   116

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

   117

		}

   118

		table[i] = crc;

   119

	}

   120

}

   121

   122

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

   123

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

   124

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

   125

	}

   126

	return crc;

   127

}

   128

   130

{

   131

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

   132

   133

	{

   134

		HANDLE file;

   135

		byte buffer[1024];

   136

		DWORD numread;

   137

		uint32 filesize = 0;

   138

		FILETIME write_time;

   139

		uint32 crc = (uint32)-1;

   140

   141

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

   142

			OPEN_EXISTING, 0, 0);

   143

		if (file != INVALID_HANDLE_VALUE) {

   144

			for (;;) {

   145

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

   146

						numread == 0)

   147

					break;

   148

				filesize += numread;

   149

				crc = CalcCRC(buffer, numread, crc);

   150

			}

   151

			dfi->size = filesize;

   152

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

   153

   154

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

   155

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

   156

			}

   157

			CloseHandle(file);

   158

		}

   159

	}

   160

}

   161

   162

   163

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

   164

{

   166

	DebugFileInfo dfi;

   167

   168

	GetModuleFileName(mod, buffer, MAX_PATH);

   169

	GetFileInfo(&dfi, buffer);

   170

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

   172

		mod,

   173

		dfi.size,

   174

		dfi.crc32,

   175

		dfi.file_time.wYear,

   176

		dfi.file_time.wMonth,

   177

		dfi.file_time.wDay,

   178

		dfi.file_time.wHour,

   179

		dfi.file_time.wMinute,

   180

		dfi.file_time.wSecond

   181

	);

   182

	return output;

   183

}

   184

   185

static char *PrintModuleList(char *output)

   186

{

   187

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

   188

	HANDLE proc;

   189

	HMODULE modules[100];

   190

	DWORD needed;

   191

	BOOL res;

   192

	int count,i;

   193

   195

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

   196

		if (proc) {

   197

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

   198

			CloseHandle(proc);

   199

			if (res) {

   200

				count =

   201

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

   202

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

   203

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

   204

				return output;

   205

			}

   206

		}

   207

	}

   208

	output = PrintModuleInfo(output, NULL);

   209

	return output;

   210

}

   211

   218

   223

   224

static bool EmergencySave(void)

   225

{

   226

	SaveOrLoad("crash.sav", SL_SAVE);

   227

	return true;

   228

}

   229

   230

typedef struct {

   235

	BOOL (WINAPI *InternetCloseHandle)(HINTERNET);

   236

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

   237

} WinInetProcs;

   238

   239

#define M(x) x "\0"

   245

static const char wininet_files[] =

   246

	M("wininet.dll")

   251

	M("InternetCloseHandle")

   253

	M("");

   255

#undef M

   256

   257

static WinInetProcs _wininet;

   258

   259

   261

{

   262

	HINTERNET inet, conn, http;

   264

	DWORD code, len;

   267

   269

   272

   275

   282

   283

	len = sizeof(code);

   285

   286

	if (code != 200) {

   288

		len = sizeof(buf) - l;

   289

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

   290

		err = buf;

   291

	}

   292

   293

error4:

   294

	_wininet.InternetCloseHandle(http);

   295

error3:

   296

	_wininet.InternetCloseHandle(conn);

   297

error2:

   298

	_wininet.InternetCloseHandle(inet);

   299

error1:

   300

	return err;

   301

}

   302

   304

{

   305

	HANDLE h;

   306

	unsigned long size;

   307

	unsigned long read;

   308

	void *mem;

   309

   310

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

   311

	if (h == NULL) return;

   312

   313

	size = GetFileSize(h, NULL);

   314

	if (size > 500000) goto error1;

   315

   316

	mem = malloc(size);

   317

	if (mem == NULL) goto error1;

   318

   319

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

   320

   321

	SubmitCrashReport(wnd, mem, size, file);

   322

   323

error2:

   324

	free(mem);

   325

error1:

   326

	CloseHandle(h);

   327

}

   328

   330

   331

static void SetWndSize(HWND wnd, int mode)

   332

{

   333

	RECT r,r2;

   334

	int offs;

   335

   336

	GetWindowRect(wnd, &r);

   337

   338

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

   339

   340

	if (mode >= 0) {

   341

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

   342

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

   343

		if (!mode) offs = -offs;

   344

		SetWindowPos(wnd, HWND_TOPMOST, 0, 0,

   345

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

   346

	} else {

   347

		SetWindowPos(wnd, HWND_TOPMOST,

   348

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

   349

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

   350

			0, 0, SWP_NOSIZE);

   351

	}

   352

}

   353

   354

static bool DoEmergencySave(HWND wnd)

   355

{

   356

	bool b = false;

   357

   358

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

   359

	_did_emerg_save = true;

   360

	__try {

   361

		b = EmergencySave();

   362

	} __except (1) {}

   363

	return b;

   364

}

   365

   366

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

   367

{

   368

	switch (msg) {

   377

		SetDlgItemText(wnd, 10, _crash_desc);

   379

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

   380

		SetWndSize(wnd, -1);

   382

	case WM_COMMAND:

   383

		switch (wParam) {

   384

		case 12: // Close

   385

			ExitProcess(0);

   386

		case 13: { // Emergency save

   387

			if (DoEmergencySave(wnd)) {

   389

			} else {

   391

			}

   392

			break;

   393

		}

   394

		case 14: { // Submit crash report

   396

   397

			SetCursor(LoadCursor(NULL, IDC_WAIT));

   398

   402

				break;

   403

			}

   404

   405

			// try to submit emergency savegame

   408

			// try to submit the autosaved game

   409

			if (_opt.autosave) {

   412

				SubmitFile(wnd, buf);

   413

			}

   414

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

   415

			SetCursor(LoadCursor(NULL, IDC_ARROW));

   417

			break;

   418

		}

   419

		case 15: // Expand

   420

			_expanded ^= 1;

   421

			SetWndSize(wnd, _expanded);

   422

			break;

   423

		}

   424

		return TRUE;

   425

	case WM_CLOSE:

   426

		ExitProcess(0);

   427

	}

   428

   429

	return FALSE;

   430

}

   431

   432

static void Handler2(void)

   433

{

   434

	ShowCursor(TRUE);

   435

	ShowWindow(GetActiveWindow(), FALSE);

   436

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

   437

}

   438

   439

extern bool CloseConsoleLogIfActive(void);

   440

   441

static LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS *ep)

   442

{

   443

	extern const char _openttd_revision[];

   444

	char *output;

   446

   447

	if (had_exception) ExitProcess(0);

   448

	had_exception = true;

   449

   450

	_ident = GetTickCount(); // something pretty unique

   451

   452

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

   453

	_crash_msg = output = LocalAlloc(LMEM_FIXED, 8192);

   454

   455

	{

   456

		SYSTEMTIME time;

   457

		GetLocalTime(&time);

   459

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

   460

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

   461

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

   462

			time.wYear,

   463

			time.wMonth,

   464

			time.wDay,

   465

			time.wHour,

   466

			time.wMinute,

   467

			time.wSecond,

   468

			_openttd_revision

   469

		);

   470

	}

   471

   472

	if (_exception_string)

   473

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

   474

   475

#ifdef _M_AMD64

   476

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

   477

		"Registers:\r\n"

   478

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

   479

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

   480

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

   481

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

   482

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

   483

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

   484

		ep->ExceptionRecord->ExceptionCode,

   485

		ep->ExceptionRecord->ExceptionAddress,

   486

		ep->ContextRecord->Rax,

   487

		ep->ContextRecord->Rbx,

   488

		ep->ContextRecord->Rcx,

   489

		ep->ContextRecord->Rdx,

   490

		ep->ContextRecord->Rsi,

   491

		ep->ContextRecord->Rdi,

   492

		ep->ContextRecord->Rbp,

   493

		ep->ContextRecord->Rsp,

   494

		ep->ContextRecord->R8,

   495

		ep->ContextRecord->R9,

   496

		ep->ContextRecord->R10,

   497

		ep->ContextRecord->R11,

   498

		ep->ContextRecord->R12,

   499

		ep->ContextRecord->R13,

   500

		ep->ContextRecord->R14,

   501

		ep->ContextRecord->R15,

   502

		ep->ContextRecord->Rip,

   503

		ep->ContextRecord->EFlags