desktop/source/app/crashreport.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <desktop/crashreport.hxx>
  11 #include <rtl/bootstrap.hxx>
  12 #include <osl/file.hxx>
  13 #include <comphelper/processfactory.hxx>
  14 #include <ucbhelper/proxydecider.hxx>
  15 #include <unotools/bootstrap.hxx>
  16 #include <o3tl/char16_t2wchar_t.hxx>
  17 #include <desktop/minidump.hxx>
  18 #include <rtl/ustrbuf.hxx>
  19
  20 #include <config_version.h>
  21 #include <config_folders.h>
  22
  23 #include <string>
  24 #include <regex>
  25
  26
  27 #if HAVE_FEATURE_BREAKPAD
  28
  29 #include <fstream>
  30 #if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID
  31 #include <client/linux/handler/exception_handler.h>
  32 #elif defined _WIN32
  33 #if defined __clang__
  34 #pragma clang diagnostic push
  35 #pragma clang diagnostic ignored "-Wmicrosoft-enum-value"
  36 #endif
  37 #include <client/windows/handler/exception_handler.h>
  38 #if defined __clang__
  39 #pragma clang diagnostic pop
  40 #endif
  41 #include <locale>
  42 #include <codecvt>
  43 #endif
  44
  45 osl::Mutex CrashReporter::maMutex;
  46 osl::Mutex CrashReporter::maActiveSfxObjectNameMutex;
  47 osl::Mutex CrashReporter::maUnoLogCmdMutex;
  48 std::unique_ptr<google_breakpad::ExceptionHandler> CrashReporter::mpExceptionHandler;
  49 bool CrashReporter::mbInit = false;
  50 CrashReporter::vmaKeyValues CrashReporter::maKeyValues;
  51 CrashReporter::vmaloggedUnoCommands CrashReporter::maloggedUnoCommands;
  52 OUString CrashReporter::msActiveSfxObjectName;
  53
  54
  55 #if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID
  56 static bool dumpCallback(const google_breakpad::MinidumpDescriptor& descriptor, void* /*context*/, bool succeeded)
  57 {
  58     CrashReporter::addKeyValue("Active-SfxObject",CrashReporter::getActiveSfxObjectName(),CrashReporter::AddItem);
  59     CrashReporter::addKeyValue("Last-4-Uno-Commands",CrashReporter::getLoggedUnoCommands(),CrashReporter::AddItem);
  60     CrashReporter::addKeyValue("DumpFile", OStringToOUString(descriptor.path(), RTL_TEXTENCODING_UTF8), CrashReporter::Write);
  61     SAL_WARN("desktop", "minidump generated: " << descriptor.path());
  62
  63     return succeeded;
  64 }
  65 #elif defined _WIN32
  66 static bool dumpCallback(const wchar_t* path, const wchar_t* id,
  67     void* /*context*/, EXCEPTION_POINTERS* /*exinfo*/,
  68     MDRawAssertionInfo* /*assertion*/,
  69     bool succeeded)
  70 {
  71     // TODO: moggi: can we avoid this conversion
  72 #ifdef _MSC_VER
  73 #pragma warning (disable: 4996)
  74 #endif
  75     std::wstring_convert<std::codecvt_utf8<wchar_t>> conv1;
  76     std::string aPath = conv1.to_bytes(std::wstring(path)) + conv1.to_bytes(std::wstring(id)) + ".dmp";
  77     CrashReporter::addKeyValue("Active-SfxObject",CrashReporter::getActiveSfxObjectName(),CrashReporter::AddItem);
  78     CrashReporter::addKeyValue("Last-4-Uno-Commands",CrashReporter::getLoggedUnoCommands(),CrashReporter::AddItem);
  79     CrashReporter::addKeyValue("DumpFile", OStringToOUString(aPath.c_str(), RTL_TEXTENCODING_UTF8), CrashReporter::AddItem);
  80     CrashReporter::addKeyValue("GDIHandles", OUString::number(::GetGuiResources(::GetCurrentProcess(), GR_GDIOBJECTS)), CrashReporter::Write);
  81     SAL_WARN("desktop", "minidump generated: " << aPath);
  82     return succeeded;
  83 }
  84 #endif
  85
  86
  87 void CrashReporter::writeToFile(std::ios_base::openmode Openmode)
  88 {
  89 #if defined _WIN32
  90     const std::string iniPath = getIniFileName();
  91     std::wstring iniPathW;
  92     const int nChars = MultiByteToWideChar(CP_UTF8, 0, iniPath.c_str(), -1, nullptr, 0);
  93     auto buf = std::make_unique<wchar_t[]>(nChars);
  94     if (MultiByteToWideChar(CP_UTF8, 0, iniPath.c_str(), -1, buf.get(), nChars) != 0)
  95         iniPathW = buf.get();
  96
  97     std::ofstream ini_file
  98         = iniPathW.empty() ? std::ofstream(iniPath, Openmode) : std::ofstream(iniPathW, Openmode);
  99 #else
 100     std::ofstream ini_file(getIniFileName(), Openmode);
 101 #endif
 102
 103     for (auto& keyValue : maKeyValues)
 104     {
 105         ini_file << OUStringToOString(keyValue.first, RTL_TEXTENCODING_UTF8) << "=";
 106         ini_file << OUStringToOString(keyValue.second, RTL_TEXTENCODING_UTF8) << "\n";
 107     }
 108
 109     maKeyValues.clear();
 110     ini_file.close();
 111 }
 112
 113 void CrashReporter::addKeyValue(const OUString& rKey, const OUString& rValue, tAddKeyHandling AddKeyHandling)
 114 {
 115     osl::MutexGuard aGuard(maMutex);
 116
 117     if (IsDumpEnable())
 118     {
 119         if (!rKey.isEmpty())
 120             maKeyValues.push_back(mpair(rKey, rValue));
 121
 122         if (AddKeyHandling != AddItem)
 123         {
 124             if (mbInit)
 125                 writeToFile(std::ios_base::app);
 126             else if (AddKeyHandling == Create)
 127                 writeCommonInfo();
 128         }
 129     }
 130 }
 131
 132 void CrashReporter::writeCommonInfo()
 133 {
 134     writeSystemInfo();
 135
 136     ucbhelper::InternetProxyDecider proxy_decider(::comphelper::getProcessComponentContext());
 137
 138     static const OUStringLiteral protocol = u"https";
 139     static const OUStringLiteral url = u"crashreport.libreoffice.org";
 140     const sal_Int32 port = 443;
 141
 142     const ucbhelper::InternetProxyServer proxy_server = proxy_decider.getProxy(protocol, url, port);
 143
 144     // save the new Keys
 145     vmaKeyValues atlast = maKeyValues;
 146     // clear the keys, the following Keys should be at the begin
 147     maKeyValues.clear();
 148
 149     // limit the amount of code that needs to be executed before the crash reporting
 150     addKeyValue("ProductName", "LibreOffice", AddItem);
 151     addKeyValue("Version", LIBO_VERSION_DOTTED, AddItem);
 152     addKeyValue("BuildID", utl::Bootstrap::getBuildIdData(""), AddItem);
 153     addKeyValue("URL", protocol + "://" + url + "/submit/", AddItem);
 154
 155     if (!proxy_server.aName.isEmpty())
 156     {
 157         addKeyValue("Proxy", proxy_server.aName + ":" + OUString::number(proxy_server.nPort), AddItem);
 158     }
 159
 160     // write the new keys at the end
 161     maKeyValues.insert(maKeyValues.end(), atlast.begin(), atlast.end());
 162
 163     mbInit = true;
 164
 165     writeToFile(std::ios_base::trunc);
 166
 167     updateMinidumpLocation();
 168 }
 169
 170 void CrashReporter::setActiveSfxObjectName(const OUString& rActiveSfxObjectName)
 171 {
 172     osl::MutexGuard aGuard(maActiveSfxObjectNameMutex);
 173     msActiveSfxObjectName = rActiveSfxObjectName;
 174 }
 175
 176 OUString CrashReporter::getActiveSfxObjectName()
 177 {
 178     osl::MutexGuard aGuard(maActiveSfxObjectNameMutex);
 179     return msActiveSfxObjectName;
 180 }
 181
 182 void CrashReporter::logUnoCommand(const OUString& rUnoCommand)
 183 {
 184     osl::MutexGuard aGuard(maUnoLogCmdMutex);
 185
 186     if( maloggedUnoCommands.size() == 4 )
 187         maloggedUnoCommands.pop_front();
 188
 189     maloggedUnoCommands.push_back(rUnoCommand);
 190 }
 191
 192 OUString CrashReporter::getLoggedUnoCommands()
 193 {
 194     osl::MutexGuard aGuard(maUnoLogCmdMutex);
 195
 196     OUString aCommandSeperator="";
 197     OUStringBuffer aUnoCommandBuffer;
 198
 199     for( auto& unocommand: maloggedUnoCommands)
 200     {
 201         aUnoCommandBuffer.append(aCommandSeperator + unocommand);
 202         aCommandSeperator=",";
 203     }
 204     return aUnoCommandBuffer.makeStringAndClear();
 205 }
 206
 207 namespace {
 208
 209 OUString getCrashDirectory()
 210 {
 211     OUString aCrashURL;
 212     rtl::Bootstrap::get("CrashDirectory", aCrashURL);
 213     // Need to convert to URL in case of user-defined path
 214     osl::FileBase::getFileURLFromSystemPath(aCrashURL, aCrashURL);
 215
 216     if (aCrashURL.isEmpty()) { // Fall back to user profile
 217         aCrashURL = "${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap") ":UserInstallation}/crash/";
 218         rtl::Bootstrap::expandMacros(aCrashURL);
 219     }
 220
 221     if (!aCrashURL.endsWith("/"))
 222         aCrashURL += "/";
 223
 224     osl::Directory::create(aCrashURL);
 225     OUString aCrashPath;
 226     osl::FileBase::getSystemPathFromFileURL(aCrashURL, aCrashPath);
 227     return aCrashPath;
 228 }
 229
 230 }
 231
 232 void CrashReporter::updateMinidumpLocation()
 233 {
 234 #if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID
 235     OUString aURL = getCrashDirectory();
 236     OString aOStringUrl = OUStringToOString(aURL, RTL_TEXTENCODING_UTF8);
 237     google_breakpad::MinidumpDescriptor descriptor(std::string{aOStringUrl});
 238     mpExceptionHandler->set_minidump_descriptor(descriptor);
 239 #elif defined _WIN32
 240     OUString aURL = getCrashDirectory();
 241     mpExceptionHandler->set_dump_path(o3tl::toW(aURL.getStr()));
 242 #endif
 243 }
 244
 245 bool CrashReporter::crashReportInfoExists()
 246 {
 247     static const bool InfoExist = crashreport::readConfig(CrashReporter::getIniFileName(), nullptr);
 248     return InfoExist;
 249 }
 250
 251 bool CrashReporter::readSendConfig(std::string& response)
 252 {
 253     return crashreport::readConfig(CrashReporter::getIniFileName(), &response);
 254 }
 255
 256 void CrashReporter::installExceptionHandler()
 257 {
 258     if (!IsDumpEnable())
 259         return;
 260 #if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID
 261     google_breakpad::MinidumpDescriptor descriptor("/tmp");
 262     mpExceptionHandler = std::make_unique<google_breakpad::ExceptionHandler>(descriptor, nullptr, dumpCallback, nullptr, true, -1);
 263 #elif defined _WIN32
 264     mpExceptionHandler = std::make_unique<google_breakpad::ExceptionHandler>(L".", nullptr, dumpCallback, nullptr, google_breakpad::ExceptionHandler::HANDLER_ALL);
 265 #endif
 266 }
 267
 268 void CrashReporter::removeExceptionHandler()
 269 {
 270     mpExceptionHandler.reset();
 271 }
 272
 273
 274
 275 bool CrashReporter::IsDumpEnable()
 276 {
 277     auto const env = std::getenv("CRASH_DUMP_ENABLE");
 278     if (env != nullptr && env[0] != '\0') {
 279         return true;
 280     }
 281     // read configuration item 'CrashDumpEnable' -> bool on/off
 282     OUString sToken;
 283     if (rtl::Bootstrap::get("CrashDumpEnable", sToken))
 284     {
 285         return sToken.toBoolean();
 286     }
 287     return true; // default, always on
 288 }
 289
 290
 291 std::string CrashReporter::getIniFileName()
 292 {
 293     OUString url = getCrashDirectory() + "dump.ini";
 294     OString aUrl = OUStringToOString(url, RTL_TEXTENCODING_UTF8);
 295     std::string aRet(aUrl);
 296     return aRet;
 297 }
 298
 299 // Write system-specific information such as the CPU name and features.
 300 // This may allow us to get some statistics for decisions (such as when
 301 // deciding whether SSE2 can be made a hard-requirement for Windows).
 302 // Breakpad provides this information poorly or not at all.
 303 #if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID
 304 void CrashReporter::writeSystemInfo()
 305 {
 306     // Get 'model name' and 'flags' from /proc/cpuinfo.
 307     if( std::ifstream cpuinfo( "/proc/cpuinfo" ); cpuinfo )
 308     {
 309         bool haveModel = false;
 310         bool haveFlags = false;
 311         std::regex modelRegex( "^model name[ \t]*:[ \t]*(.*)$" );
 312         std::regex flagsRegex( "^flags[ \t]*:[ \t]*(.*)$" );
 313         for( std::string line; std::getline( cpuinfo, line ); )
 314         {
 315             std::smatch match;
 316             if( !haveModel && std::regex_match( line, match, modelRegex ) && match.size() == 2)
 317             {
 318                 addKeyValue("CPUModelName", OUString::fromUtf8( match[ 1 ].str()), AddItem);
 319                 haveModel = true;
 320             }
 321             if( !haveFlags && std::regex_match( line, match, flagsRegex ) && match.size() == 2)
 322             {
 323                 addKeyValue("CPUFlags", OUString::fromUtf8( match[ 1 ].str()), AddItem);
 324                 haveFlags = true;
 325             }
 326             if( haveModel && haveFlags )
 327                 break;
 328         }
 329     }
 330     // Get 'MemTotal' from /proc/meminfo.
 331     if( std::ifstream meminfo( "/proc/meminfo" ); meminfo )
 332     {
 333         std::regex memTotalRegex( "^MemTotal[ \t]*:[ \t]*(.*)$" );
 334         for( std::string line; std::getline( meminfo, line ); )
 335         {
 336             std::smatch match;
 337             if( std::regex_match( line, match, memTotalRegex ) && match.size() == 2)
 338             {
 339                 addKeyValue("MemoryTotal", OUString::fromUtf8( match[ 1 ].str()), AddItem);
 340                 break;
 341             }
 342         }
 343     }
 344 }
 345 #elif defined _WIN32
 346 void CrashReporter::writeSystemInfo()
 347 {
 348 #if !defined(_ARM64_)
 349     // Get CPU model name and flags.
 350     // See https://docs.microsoft.com/en-us/cpp/intrinsics/cpuid-cpuidex
 351     // and https://en.wikipedia.org/wiki/CPUID .
 352     int cpui[ 4 ];
 353     __cpuid( cpui, 0x80000000 ); // Get the highest extended ID.
 354     unsigned int exIds = cpui[ 0 ];
 355     if( exIds >= 0x80000004 )
 356     {
 357         int brand[ 16 ];
 358         __cpuidex( brand, 0x80000002, 0 );
 359         __cpuidex( brand + 4, 0x80000003, 0 );
 360         __cpuidex( brand + 8, 0x80000004, 0 );
 361         brand[ 12 ] = 0;;
 362         addKeyValue( "CPUModelName", OUString::fromUtf8( reinterpret_cast< const char* >( brand )),
 363             AddItem );
 364     }
 365     __cpuid( cpui, 0 ); // Get the highest ID.
 366     int ids = cpui[ 0 ];
 367     unsigned int ecx1 = 0, edx1 = 0, ebx7 = 0, ecx7 = 0, ecx81 = 0, edx81 = 0;
 368     if( ids >= 0x1 )
 369     {
 370         __cpuidex( cpui, 0x1, 0 );
 371         ecx1 = cpui[ 2 ];
 372         edx1 = cpui[ 3 ];
 373     }
 374     if( ids >= 0x7 )
 375     {
 376         __cpuidex( cpui, 0x7, 0 );
 377         ebx7 = cpui[ 1 ];
 378         ecx7 = cpui[ 2 ];
 379     }
 380     if( exIds >= 0x80000001 )
 381     {
 382         __cpuidex( cpui, 0x80000001, 0 );
 383         ecx81 = cpui[ 2 ];
 384         edx81 = cpui[ 3 ];
 385     }
 386     struct FlagItem
 387     {
 388         unsigned int* reg;
 389         int bit;
 390         const char* name;
 391     };
 392     const FlagItem flagItems[] =
 393     {
 394         { &ecx1, 0, "sse3" },
 395         { &ecx1, 1, "pclmulqdq" },
 396         { &ecx1, 3, "monitor" },
 397         { &ecx1, 9, "ssse3" },
 398         { &ecx1, 12, "fma" },
 399         { &ecx1, 13, "cpmxch16b" },
 400         { &ecx1, 19, "sse41" },
 401         { &ecx1, 20, "sse42" },
 402         { &ecx1, 22, "movbe" },
 403         { &ecx1, 23, "popcnt" },
 404         { &ecx1, 25, "aes" },
 405         { &ecx1, 26, "xsave" },
 406         { &ecx1, 27, "osxsave" },
 407         { &ecx1, 28, "avx" },
 408         { &ecx1, 29, "f16c" },
 409         { &ecx1, 30, "rdrand" },
 410         { &edx1, 5, "msr" },
 411         { &edx1, 8, "cx8" },
 412         { &edx1, 11, "sep" },
 413         { &edx1, 15, "cmov" },
 414         { &edx1, 19, "clfsh" },
 415         { &edx1, 23, "mmx" },
 416         { &edx1, 24, "fxsr" },
 417         { &edx1, 25, "sse" },
 418         { &edx1, 26, "sse2" },
 419         { &edx1, 28, "ht" },
 420         { &ebx7, 0, "fsgsbase" },
 421         { &ebx7, 3, "bmi1" },
 422         { &ebx7, 4, "hle" },
 423         { &ebx7, 5, "avx2" },
 424         { &ebx7, 8, "bmi2" },
 425         { &ebx7, 9, "erms" },
 426         { &ebx7, 10, "invpcid" },
 427         { &ebx7, 11, "rtm" },
 428         { &ebx7, 16, "avx512f" },
 429         { &ebx7, 18, "rdseed" },
 430         { &ebx7, 19, "adx" },
 431         { &ebx7, 26, "avx512pf" },
 432         { &ebx7, 27, "avx512er" },
 433         { &ebx7, 28, "avx512cd" },
 434         { &ebx7, 29, "sha" },
 435         { &ecx7, 0, "prefetchwt1" },
 436         { &ecx81, 0, "lahf" },
 437         { &ecx81, 5, "abm" },
 438         { &ecx81, 6, "sse4a" },
 439         { &ecx81, 11, "xop" },
 440         { &ecx81, 21, "tbm" },
 441         { &edx81, 11, "syscall" },
 442         { &edx81, 22, "mmxext" },
 443         { &edx81, 27, "rdtscp" },
 444         { &edx81, 30, "3dnowext" },
 445         { &edx81, 31, "3dnow" }
 446     };
 447     OUStringBuffer flags;
 448     for( const FlagItem& item : flagItems )
 449     {
 450         if( *item.reg & ( 1U << item.bit ))
 451         {
 452             if( !flags.isEmpty())
 453                 flags.append( " " );
 454             flags.appendAscii( item.name );
 455         }
 456     }
 457     if( !flags.isEmpty())
 458         addKeyValue( "CPUFlags", flags.makeStringAndClear(), AddItem );
 459 #endif
 460     // Get total memory.
 461     MEMORYSTATUSEX memoryStatus;
 462     memoryStatus.dwLength = sizeof( memoryStatus );
 463     if( GlobalMemoryStatusEx( &memoryStatus ))
 464     {
 465         addKeyValue( "MemoryTotal", OUString::number( int( memoryStatus.ullTotalPhys / 1024 ))
 466             + " kB", AddItem );
 467     }
 468 }
 469 #else
 470 void CrashReporter::writeSystemInfo()
 471 {
 472 }
 473 #endif
 474
 475 #endif //HAVE_FEATURE_BREAKPAD
 476
 477 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */