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 "table/strings.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

    21

#include "driver.h"

    22

    23

#include "music/dmusic.h"

    24

#include "music/null_m.h"

    25

#include "music/win32_m.h"

    26

    27

#include "sound/null_s.h"

    28

#include "sound/sdl_s.h"

    29

#include "sound/win32_s.h"

    30

    31

#include "video/dedicated_v.h"

    32

#include "video/null_v.h"

    33

#include "video/sdl_v.h"

    34

#include "video/win32_v.h"

    35

    36

static bool _has_console;

    37

    38

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

    39

	#define __TIMESTAMP__   __DATE__ __TIME__

    40

#endif

    41

    42

    43

static bool cursor_visible = true;

    44

    45

bool MyShowCursor(bool show)

    46

{

    48

    50

	ShowCursor(show);

    51

    52

	return !show;

    53

}

    54

    55

    56

// Helper function needed by dynamically loading SDL

    57

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

    58

{

    59

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

    60

		HMODULE lib = LoadLibrary(dll);

    61

    62

		if (lib == NULL) return false;

    63

		while (true) {

    64

		  	FARPROC p;

    65

    66

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

    67

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

    68

			p = GetProcAddress(lib, dll);

    69

			if (p == NULL) return false;

    70

			*proc++ = (Function)p;

    71

		}

    72

		dll++;

    73

	}

    74

	return true;

    75

}

    76

    77

#ifdef _MSC_VER

    78

    79

static const char *_exception_string;

    80

static void *_safe_esp;

    81

static char *_crash_msg;

    82

static bool _expanded;

    83

static bool _did_emerg_save;

    84

static int _ident;

    85

    86

void ShowOSErrorBox(const char *buf)

    87

{

    88

	MyShowCursor(true);

    89

	MessageBoxA(GetActiveWindow(), buf, "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

typedef struct DebugFileInfo {

   101

	uint32 size;

   102

	uint32 crc32;

   103

	SYSTEMTIME file_time;

   104

} DebugFileInfo;

   105

   106

static uint32 *_crc_table;

   107

   108

static void MakeCRCTable(uint32 *table) {

   109

	uint32 crc, poly = 0xEDB88320L;

   110

	int i;

   111

	int j;

   112

   113

	_crc_table = table;

   114

   115

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

   116

		crc = i;

   117

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

   118

			if (crc & 1)

   119

				crc = (crc >> 1) ^ poly;

   120

			else

   121

				crc >>= 1;

   122

		}

   123

		table[i] = crc;

   124

	}

   125

}

   126

   127

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

   128

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

   129

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

   130

	}

   131

	return crc;

   132

}

   133

   134

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

   135

{

   136

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

   137

   138

	{

   139

		HANDLE file;

   140

		byte buffer[1024];

   141

		DWORD numread;

   142

		uint32 filesize = 0;

   143

		FILETIME write_time;

   144

		uint32 crc = (uint32)-1;

   145

   146

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

   147

			OPEN_EXISTING, 0, 0);

   148

		if (file != INVALID_HANDLE_VALUE) {

   149

			while(true) {

   150

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

   151

						numread == 0)

   152

					break;

   153

				filesize += numread;

   154

				crc = CalcCRC(buffer, numread, crc);

   155

			}

   156

			dfi->size = filesize;

   157

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

   158

   159

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

   160

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

   161

			}

   162

			CloseHandle(file);

   163

		}

   164

	}

   165

}

   166

   167

   168

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

   169

{

   170

	char buffer[MAX_PATH];

   171

	DebugFileInfo dfi;

   172

   173

	GetModuleFileName(mod, buffer, MAX_PATH);

   174

	GetFileInfo(&dfi, buffer);

   175

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

   176

		buffer,

   177

		mod,

   178

		dfi.size,

   179

		dfi.crc32,

   180

		dfi.file_time.wYear,

   181

		dfi.file_time.wMonth,

   182

		dfi.file_time.wDay,

   183

		dfi.file_time.wHour,

   184

		dfi.file_time.wMinute,

   185

		dfi.file_time.wSecond

   186

	);

   187

	return output;

   188

}

   189

   190

static char *PrintModuleList(char *output)

   191

{

   192

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

   193

	HANDLE proc;

   194

	HMODULE modules[100];

   195

	DWORD needed;

   196

	BOOL res;

   197

	int count,i;

   198

   199

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

   200

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

   201

		if (proc) {

   202

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

   203

			CloseHandle(proc);

   204

			if (res) {

   205

				count =

   206

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

   207

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

   208

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

   209

				return output;

   210

			}

   211

		}

   212

	}

   213

	output = PrintModuleInfo(output, NULL);

   214

	return output;

   215

}

   216

   217

static const char _crash_desc[] =

   218

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

   219

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

   220

	"This will greatly help debugging. "

   221

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

   222

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

   223

   224

static const char _save_succeeded[] =

   225

	"Emergency save succeeded.\n"

   226

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

   227

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

   228

   229

static bool EmergencySave(void)

   230

{

   231

	SaveOrLoad("crash.sav", SL_SAVE);

   232

	return true;

   233

}

   234

   235

typedef struct {

   236

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

   237

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

   238

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

   239

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

   240

	BOOL (WINAPI *InternetCloseHandle)(HINTERNET);

   241

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

   242

} WinInetProcs;

   243

   244

#define M(x) x "\0"

   245

static const char wininet_files[] =

   246

	M("wininet.dll")

   247

	M("InternetOpenA")

   248

	M("InternetConnectA")

   249

	M("HttpOpenRequestA")

   250

	M("HttpSendRequestA")

   251

	M("InternetCloseHandle")

   252

	M("HttpQueryInfoA")

   253

	M("");

   254

#undef M

   255

   256

static WinInetProcs _wininet;

   257

   258

   259

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

   260

{

   261

	HINTERNET inet, conn, http;

   262

	const char *err = NULL;

   263

	DWORD code, len;

   264

	static char buf[100];

   265

	char buff[100];

   266

   267

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

   268

   269

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

   270

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

   271

   272

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

   273

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

   274

   275

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

   276

   277

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

   278

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

   279

   280

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

   281

   282

	len = sizeof(code);

   283

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

   284

   285

	if (code != 200) {

   286

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

   287

		len = sizeof(buf) - l;

   288

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

   289

		err = buf;

   290

	}

   291

   292

error4:

   293

	_wininet.InternetCloseHandle(http);

   294

error3:

   295

	_wininet.InternetCloseHandle(conn);

   296

error2:

   297

	_wininet.InternetCloseHandle(inet);

   298

error1:

   299

	return err;

   300

}

   301

   302

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

   303

{

   304

	HANDLE h;

   305

	unsigned long size;

   306

	unsigned long read;

   307

	void *mem;

   308

   309

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

   310

	if (h == NULL) return;

   311

   312

	size = GetFileSize(h, NULL);

   313

	if (size > 500000) goto error1;

   314

   315

	mem = malloc(size);

   316

	if (mem == NULL) goto error1;

   317

   318

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

   319

   320

	SubmitCrashReport(wnd, mem, size, file);

   321

   322

error2:

   323

	free(mem);

   324

error1:

   325

	CloseHandle(h);

   326

}

   327

   328

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

   329

   330

static void SetWndSize(HWND wnd, int mode)

   331

{

   332

	RECT r,r2;

   333

	int offs;

   334

   335

	GetWindowRect(wnd, &r);

   336

   337

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

   338

   339

	if (mode >= 0) {

   340

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

   341

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

   342

		if (!mode) offs = -offs;

   343

		SetWindowPos(wnd, HWND_TOPMOST, 0, 0,

   344

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

   345

	} else {

   346

		SetWindowPos(wnd, HWND_TOPMOST,

   347

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

   348

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

   349

			0, 0, SWP_NOSIZE);

   350

	}

   351

}

   352

   353

static bool DoEmergencySave(HWND wnd)

   354

{

   355

	bool b = false;

   356

   357

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

   358

	_did_emerg_save = true;

   359

	__try {

   360

		b = EmergencySave();

   361

	} __except (1) {}

   362

	return b;

   363

}

   364

   365

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

   366

{

   367

	switch(msg) {

   368

	case WM_INITDIALOG:

   369

		SetDlgItemText(wnd, 10, _crash_desc);

   370

		SetDlgItemText(wnd, 11, _crash_msg);

   371

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

   372

		SetWndSize(wnd, -1);

   373

		return TRUE;

   374

	case WM_COMMAND:

   375

		switch(wParam) {

   376

		case 12: // Close

   377

			ExitProcess(0);

   378

		case 13: { // Emergency save

   379

			if (DoEmergencySave(wnd))

   380

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

   381

			else

   382

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

   383

			break;

   384

		}

   385

		case 14: { // Submit crash report

   386

			const char *s;

   387

   388

			SetCursor(LoadCursor(NULL, IDC_WAIT));

   389

   390

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

   391

			if (s) {

   392

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

   393

				break;

   394

			}

   395

   396

			// try to submit emergency savegame

   397

			if (_did_emerg_save || DoEmergencySave(wnd)) {

   398

				SubmitFile(wnd, "crash.sav");

   399

			}

   400

			// try to submit the autosaved game

   401

			if (_opt.autosave) {

   402

				char buf[40];

   403

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

   404

				SubmitFile(wnd, buf);

   405

			}

   406

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

   407

			SetCursor(LoadCursor(NULL, IDC_ARROW));

   408

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

   409

			break;

   410

		}

   411

		case 15: // Expand

   412

			_expanded ^= 1;

   413

			SetWndSize(wnd, _expanded);

   414

			break;

   415

		}

   416

		return TRUE;

   417

	case WM_CLOSE:

   418

		ExitProcess(0);

   419

	}

   420

   421

	return FALSE;

   422

}

   423

   424

static void Handler2(void)

   425

{

   426

	ShowCursor(TRUE);

   427

	ShowWindow(GetActiveWindow(), FALSE);

   428

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

   429

}

   430

   431

extern bool CloseConsoleLogIfActive(void);

   432

   433

static LONG WINAPI ExceptionHandler(EXCEPTION_POINTERS *ep)

   434

{

   435

	char *output;

   436

	static bool had_exception;

   437

   438

	if (had_exception) ExitProcess(0);

   439

	had_exception = true;

   440

   441

	_ident = GetTickCount(); // something pretty unique

   442

   443

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

   444

	_crash_msg = output = LocalAlloc(LMEM_FIXED, 8192);

   445

   446

	{

   447

		SYSTEMTIME time;

   448

		GetLocalTime(&time);

   449

		output += sprintf(output,

   450

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

   451

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

   452

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

   453

			time.wYear,

   454

			time.wMonth,

   455

			time.wDay,

   456

			time.wHour,

   457

			time.wMinute,

   458

			time.wSecond,

   459

			"???"

   460

		);

   461

	}

   462

   463

	if (_exception_string)

   464

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

   465

   466

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

   467

		"Registers:\r\n"

   468

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

   469

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

   470

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

   471

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

   472

		ep->ExceptionRecord->ExceptionCode,

   473

		ep->ExceptionRecord->ExceptionAddress,

   474

		ep->ContextRecord->Eax,

   475

		ep->ContextRecord->Ebx,

   476

		ep->ContextRecord->Ecx,

   477

		ep->ContextRecord->Edx,

   478

		ep->ContextRecord->Esi,

   479

		ep->ContextRecord->Edi,

   480

		ep->ContextRecord->Ebp,

   481

		ep->ContextRecord->Esp,

   482

		ep->ContextRecord->Eip,

   483

		ep->ContextRecord->EFlags

   484

	);

   485

   486

	{

   487

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

   488

		int i;

   489

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

   490

			if (IsBadReadPtr(b, 1)) {

   491

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

   492

			} else {

   493

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

   494

			}

   495

			b++;

   496

		}

   497

		output += sprintf(output,

   498

			"\r\n"

   499

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

   500

		);

   501

	}

   502

   503

	{

   504

		int i,j;

   505

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

   506

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

   507

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

   508

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

   509

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

   510

				} else {

   511

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

   512

				}

   513

				b++;