00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "stdafx.h"
00013 #include "crashlog.h"
00014 #include "gamelog.h"
00015 #include "map_func.h"
00016 #include "rev.h"
00017 #include "strings_func.h"
00018 #include "blitter/factory.hpp"
00019 #include "base_media_base.h"
00020 #include "music/music_driver.hpp"
00021 #include "sound/sound_driver.hpp"
00022 #include "video/video_driver.hpp"
00023 #include "saveload/saveload.h"
00024 #include "screenshot.h"
00025 #include "gfx_func.h"
00026
00027 #include <squirrel.h>
00028 #include "ai/ai_info.hpp"
00029 #include "company_base.h"
00030
00031 #include <time.h>
00032
00033 const char *CrashLog::message = NULL;
00034 char *CrashLog::gamelog_buffer = NULL;
00035 const char *CrashLog::gamelog_last = NULL;
00036
00037 char *CrashLog::LogRegisters(char *buffer, const char *last) const
00038 {
00039
00040 return buffer;
00041 }
00042
00043 char *CrashLog::LogModules(char *buffer, const char *last) const
00044 {
00045
00046 return buffer;
00047 }
00048
00049 char *CrashLog::LogOpenTTDVersion(char *buffer, const char *last) const
00050 {
00051 return buffer + seprintf(buffer, last,
00052 "OpenTTD version:\n"
00053 " Version: %s (%d)\n"
00054 " NewGRF ver: %08x\n"
00055 " Bits: %d\n"
00056 " Endian: %s\n"
00057 " Dedicated: %s\n"
00058 " Build date: %s\n\n",
00059 _openttd_revision,
00060 _openttd_revision_modified,
00061 _openttd_newgrf_version,
00062 #ifdef _SQ64
00063 64,
00064 #else
00065 32,
00066 #endif
00067 #if (TTD_ENDIAN == TTD_LITTLE_ENDIAN)
00068 "little",
00069 #else
00070 "big",
00071 #endif
00072 #ifdef DEDICATED
00073 "yes",
00074 #else
00075 "no",
00076 #endif
00077 _openttd_build_date
00078 );
00079 }
00080
00081 char *CrashLog::LogConfiguration(char *buffer, const char *last) const
00082 {
00083 buffer += seprintf(buffer, last,
00084 "Configuration:\n"
00085 " Blitter: %s\n"
00086 " Graphics set: %s\n"
00087 " Language: %s\n"
00088 " Music driver: %s\n"
00089 " Music set: %s\n"
00090 " Sound driver: %s\n"
00091 " Sound set: %s\n"
00092 " Video driver: %s\n\n",
00093 BlitterFactoryBase::GetCurrentBlitter() == NULL ? "none" : BlitterFactoryBase::GetCurrentBlitter()->GetName(),
00094 BaseGraphics::GetUsedSet() == NULL ? "none" : BaseGraphics::GetUsedSet()->name,
00095 StrEmpty(_dynlang.curr_file) ? "none" : _dynlang.curr_file,
00096 _music_driver == NULL ? "none" : _music_driver->GetName(),
00097 BaseMusic::GetUsedSet() == NULL ? "none" : BaseMusic::GetUsedSet()->name,
00098 _sound_driver == NULL ? "none" : _sound_driver->GetName(),
00099 BaseSounds::GetUsedSet() == NULL ? "none" : BaseSounds::GetUsedSet()->name,
00100 _video_driver == NULL ? "none" : _video_driver->GetName()
00101 );
00102
00103 buffer += seprintf(buffer, last, "AI Configuration:\n");
00104 const Company *c;
00105 FOR_ALL_COMPANIES(c) {
00106 if (c->ai_info == NULL) {
00107 buffer += seprintf(buffer, last, " %2i: Human\n", (int)c->index);
00108 } else {
00109 buffer += seprintf(buffer, last, " %2i: %s (v%d)\n", (int)c->index, c->ai_info->GetName(), c->ai_info->GetVersion());
00110 }
00111 }
00112 buffer += seprintf(buffer, last, "\n");
00113
00114 return buffer;
00115 }
00116
00117
00118 #ifdef WITH_ALLEGRO
00119 # include <allegro.h>
00120 #endif
00121 #ifdef WITH_FONTCONFIG
00122 # include <fontconfig/fontconfig.h>
00123 #endif
00124 #ifdef WITH_PNG
00125
00126
00127 # include <png.h>
00128 #endif
00129 #ifdef WITH_FREETYPE
00130 # include <ft2build.h>
00131 # include FT_FREETYPE_H
00132 #endif
00133 #ifdef WITH_ICU
00134 # include <unicode/uversion.h>
00135 #endif
00136 #ifdef WITH_SDL
00137 # include "sdl.h"
00138 # include <SDL.h>
00139 #endif
00140
00141 char *CrashLog::LogLibraries(char *buffer, const char *last) const
00142 {
00143 buffer += seprintf(buffer, last, "Libraries:\n");
00144
00145 #ifdef WITH_ALLEGRO
00146 buffer += seprintf(buffer, last, " Allegro: %s\n", allegro_id);
00147 #endif
00148
00149 #ifdef WITH_FONTCONFIG
00150 int version = FcGetVersion();
00151 buffer += seprintf(buffer, last, " FontConfig: %d.%d.%d\n", version / 10000, (version / 100) % 100, version % 100);
00152 #endif
00153
00154 #ifdef WITH_FREETYPE
00155 FT_Library library;
00156 int major, minor, patch;
00157 FT_Init_FreeType(&library);
00158 FT_Library_Version(library, &major, &minor, &patch);
00159 FT_Done_FreeType(library);
00160 buffer += seprintf(buffer, last, " FreeType: %d.%d.%d\n", major, minor, patch);
00161 #endif
00162
00163 #ifdef WITH_ICU
00164
00165 char buf[4 * 3 + 3 + 1];
00166 UVersionInfo ver;
00167 u_getVersion(ver);
00168 u_versionToString(ver, buf);
00169 buffer += seprintf(buffer, last, " ICU: %s\n", buf);
00170 #endif
00171
00172 #ifdef WITH_PNG
00173 buffer += seprintf(buffer, last, " PNG: %s\n", png_get_libpng_ver(NULL));
00174 #endif
00175
00176 #ifdef WITH_SDL
00177 #ifdef DYNAMICALLY_LOADED_SDL
00178 if (SDL_CALL SDL_Linked_Version != NULL) {
00179 #else
00180 {
00181 #endif
00182 const SDL_version *v = SDL_CALL SDL_Linked_Version();
00183 buffer += seprintf(buffer, last, " SDL: %d.%d.%d\n", v->major, v->minor, v->patch);
00184 }
00185 #endif
00186
00187 buffer += seprintf(buffer, last, "\n");
00188 return buffer;
00189 }
00190
00191 void CrashLog::GamelogFillCrashLog(const char *s)
00192 {
00193 CrashLog::gamelog_buffer += seprintf(CrashLog::gamelog_buffer, CrashLog::gamelog_last, "%s\n", s);
00194 }
00195
00196 char *CrashLog::LogGamelog(char *buffer, const char *last) const
00197 {
00198 CrashLog::gamelog_buffer = buffer;
00199 CrashLog::gamelog_last = last;
00200 GamelogPrint(&CrashLog::GamelogFillCrashLog);
00201 return CrashLog::gamelog_buffer + seprintf(CrashLog::gamelog_buffer, last, "\n");
00202 }
00203
00204 char *CrashLog::FillCrashLog(char *buffer, const char *last) const
00205 {
00206 time_t cur_time = time(NULL);
00207 buffer += seprintf(buffer, last, "*** OpenTTD Crash Report ***\n\n");
00208 buffer += seprintf(buffer, last, "Crash at: %s\n", asctime(gmtime(&cur_time)));
00209
00210 buffer = this->LogError(buffer, last, CrashLog::message);
00211 buffer = this->LogOpenTTDVersion(buffer, last);
00212 buffer = this->LogRegisters(buffer, last);
00213 buffer = this->LogStacktrace(buffer, last);
00214 buffer = this->LogOSVersion(buffer, last);
00215 buffer = this->LogConfiguration(buffer, last);
00216 buffer = this->LogLibraries(buffer, last);
00217 buffer = this->LogModules(buffer, last);
00218 buffer = this->LogGamelog(buffer, last);
00219
00220 buffer += seprintf(buffer, last, "*** End of OpenTTD Crash Report ***\n");
00221 return buffer;
00222 }
00223
00224 bool CrashLog::WriteCrashLog(const char *buffer, char *filename, const char *filename_last) const
00225 {
00226 seprintf(filename, filename_last, "%scrash.log", _personal_dir);
00227
00228 FILE *file = FioFOpenFile(filename, "w", NO_DIRECTORY);
00229 if (file == NULL) return false;
00230
00231 size_t len = strlen(buffer);
00232 size_t written = fwrite(buffer, 1, len, file);
00233
00234 FioFCloseFile(file);
00235 return len == written;
00236 }
00237
00238 int CrashLog::WriteCrashDump(char *filename, const char *filename_last) const
00239 {
00240
00241 return 0;
00242 }
00243
00244 bool CrashLog::WriteSavegame(char *filename, const char *filename_last) const
00245 {
00246
00247
00248 if (_m == NULL) return false;
00249
00250 try {
00251 GamelogEmergency();
00252
00253 seprintf(filename, filename_last, "%scrash.sav", _personal_dir);
00254
00255
00256 return SaveOrLoad(filename, SL_SAVE, NO_DIRECTORY, false) == SL_OK;
00257 } catch (...) {
00258 return false;
00259 }
00260 }
00261
00262 bool CrashLog::WriteScreenshot(char *filename, const char *filename_last) const
00263 {
00264
00265 if (_screen.width < 1 || _screen.height < 1 || _screen.dst_ptr == NULL) return false;
00266
00267 bool res = MakeScreenshot(SC_RAW, "crash");
00268 if (res) strecpy(filename, _full_screenshot_name, filename_last);
00269 return res;
00270 }
00271
00272 bool CrashLog::MakeCrashLog() const
00273 {
00274
00275 static bool crashlogged = false;
00276 if (crashlogged) return false;
00277 crashlogged = true;
00278
00279 char filename[MAX_PATH];
00280 char buffer[65536];
00281 bool ret = true;
00282
00283 printf("Crash encountered, generating crash log...\n");
00284 this->FillCrashLog(buffer, lastof(buffer));
00285 printf("%s\n", buffer);
00286 printf("Crash log generated.\n\n");
00287
00288 printf("Writing crash log to disk...\n");
00289 bool bret = this->WriteCrashLog(buffer, filename, lastof(filename));
00290 if (bret) {
00291 printf("Crash log written to %s. Please add this file to any bug reports.\n\n", filename);
00292 } else {
00293 printf("Writing crash log failed. Please attach the output above to any bug reports.\n\n");
00294 ret = false;
00295 }
00296
00297
00298 int dret = this->WriteCrashDump(filename, lastof(filename));
00299 if (dret < 0) {
00300 printf("Writing crash dump failed.\n\n");
00301 ret = false;
00302 } else if (dret > 0) {
00303 printf("Crash dump written to %s. Please add this file to any bug reports.\n\n", filename);
00304 }
00305
00306 printf("Writing crash savegame...\n");
00307 bret = this->WriteSavegame(filename, lastof(filename));
00308 if (bret) {
00309 printf("Crash savegame written to %s. Please add this file and the last (auto)save to any bug reports.\n\n", filename);
00310 } else {
00311 ret = false;
00312 printf("Writing crash savegame failed. Please attach the last (auto)save to any bug reports.\n\n");
00313 }
00314
00315 printf("Writing crash screenshot...\n");
00316 bret = this->WriteScreenshot(filename, lastof(filename));
00317 if (bret) {
00318 printf("Crash screenshot written to %s. Please add this file to any bug reports.\n\n", filename);
00319 } else {
00320 ret = false;
00321 printf("Writing crash screenshot failed.\n\n");
00322 }
00323
00324 return ret;
00325 }
00326
00327 void CrashLog::SetErrorMessage(const char *message)
00328 {
00329 CrashLog::message = message;
00330 }
00331
00332 void CrashLog::AfterCrashLogCleanup()
00333 {
00334 if (_music_driver != NULL) _music_driver->Stop();
00335 if (_sound_driver != NULL) _sound_driver->Stop();
00336 if (_video_driver != NULL) _video_driver->Stop();
00337 }