win32/CrashReportContext.cpp

Go to the documentation of this file.

/*!********************************************************************
*
 Audacity: A Digital Audio Editor
 
 CrashReportContext.cpp
 
 Vitaly Sverchinsky
 
 Some parts of the code are designed to operate while app is crashing,
 so there may be some restrictions on heap usage. For more information
 please read Breakpad documentation.
 
 **********************************************************************/
 
#include "CrashReportContext.h"
 
#include <locale>
#include <codecvt>
#include <sstream>
#include "client/windows/handler/exception_handler.h"
 
namespace
{
   //copy src(null-terminated) to dst, 
   //returns false if dest is not large enough
   bool StrcpyChecked(wchar_t* dest, size_t destsz, const wchar_t* src)
   {
      auto len = wcslen(src);
      if (len < destsz)
      {
         memcpy(dest, src, sizeof(wchar_t) * len);
         dest[len] = 0;
         return true;
      }
      return false;
   }
 
   //appends src(null-terminated) to dest, destsz is the total dest buffer size, not remaining
   //returns false if dest is not large enough
   bool StrcatChecked(wchar_t* dest, size_t destsz, const wchar_t* src)
   {
      auto srclen = wcslen(src);
      auto dstlen = wcslen(dest);
      if (srclen + dstlen < destsz)
      {
         memcpy(dest + dstlen, src, sizeof(wchar_t) * srclen);
         dest[srclen + dstlen] = 0;
         return true;
      }
      return false;
   }
 
   //converts parameters map to a string, so that the Crash Reporting program
   //would understand them
   std::string StringifyParameters(const std::map<std::string, std::string>& parameters)
   {
      std::stringstream stream;
 
      std::size_t parameterIndex = 0;
      std::size_t parametersCount = parameters.size();
      for (auto& pair : parameters)
      {
         stream << pair.first.c_str() << "=\\\"" << pair.second.c_str() << "\\\"";
         ++parameterIndex;
         if (parameterIndex < parametersCount)
            stream << ",";
      }
      return stream.str();
   }
}
 
bool MakeCommand(CrashReportContext* c, const wchar_t* path, const wchar_t* id)
{
   //utility path
   auto ok = StrcpyChecked(c->mCommand, CrashReportContext::MaxCommandLength, L"\"");
   ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxCommandLength, c->mSenderPath);
   ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxCommandLength, L"\"");
 
   //parameters: /p "..."
   if (ok && c->mParameters[0] != 0)
   {
      ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxCommandLength, L" /a \"");
      ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxCommandLength, c->mParameters);
      ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxCommandLength, L"\"");
   }
   //crash report URL: /u https://...
   ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxBufferLength, L" /u \"");
   ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxBufferLength, c->mReportURL);
   ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxBufferLength, L"\" ");
   //minidump path: path/to/minidump.dmp
   ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxCommandLength, L" \"");
   ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxCommandLength, path);
   ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxCommandLength, L"\\");
   ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxCommandLength, id);
   ok = ok && StrcatChecked(c->mCommand, CrashReportContext::MaxCommandLength, L".dmp\"");
   return ok;
}
 
bool SendReport(CrashReportContext* c, const wchar_t* path, const wchar_t* id)
{
   if (!MakeCommand(c, path, id))
      return false;
 
   STARTUPINFOW si;
   ZeroMemory(&si, sizeof(si));
   si.cb = sizeof(si);
   si.dwFlags = STARTF_USESHOWWINDOW;
   si.wShowWindow = SW_SHOW;
 
   PROCESS_INFORMATION pi;
   ZeroMemory(&pi, sizeof(pi));
 
   if (CreateProcessW(NULL, c->mCommand, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
   {
      CloseHandle(pi.hProcess);
      CloseHandle(pi.hThread);
      return true;
   }
   else
      return false;
}
 
bool UploadReport(
   const wchar_t* dump_path,
   const wchar_t* minidump_id,
   void* context,
   EXCEPTION_POINTERS* /*exinfo*/,
   MDRawAssertionInfo* /*assertion*/,
   bool succeeded)
{
   CrashReportContext* crashReportContext = static_cast<CrashReportContext*>(context);
   if (!SendReport(crashReportContext, dump_path, minidump_id))
      return false;
   return succeeded;
}
 
bool CrashReportContext::SetSenderPathUTF8(const std::string& path)
{
   auto fullpath = path + "\\" + CRASHREPORTER_PROGRAM_NAME;
    return StrcpyChecked(mSenderPath, MaxBufferLength, std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t>().from_bytes(fullpath).c_str());
}
 
bool CrashReportContext::SetReportURL(const std::string& url)
{
    return StrcpyChecked(mReportURL, MaxBufferLength, std::wstring(url.begin(), url.end()).c_str());
}
 
bool CrashReportContext::SetParameters(const std::map<std::string, std::string>& p)
{
   auto str = StringifyParameters(p);
   return StrcpyChecked(mParameters, MaxBufferLength, std::wstring(str.begin(), str.end()).c_str());
}
 
void CrashReportContext::StartHandler(const std::string& databasePath)
{
   //intentinal leak: error hooks may be useful while application is terminating
   //CrashReportContext data should be alive too...
   static auto handler = new google_breakpad::ExceptionHandler(
      std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t>().from_bytes(databasePath),
      NULL,
      UploadReport,
      this,
      google_breakpad::ExceptionHandler::HANDLER_ALL);
}