root/chrome_elf/breakpad.cc

DEFINITIONS

1. GetCustomInfo
2. GetUserSidString
3. IsHeadless
4. GenerateCrashDump
5. InitializeCrashReporting

// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This module contains the necessary code to register the Breakpad exception
// handler. This implementation is based on Chrome's crash reporting code.

#include "chrome_elf/breakpad.h"

#include <sddl.h>

#include "base/macros.h"
#include "breakpad/src/client/windows/handler/exception_handler.h"
#include "chrome_elf/chrome_elf_util.h"
#include "version.h"  // NOLINT

google_breakpad::ExceptionHandler* g_elf_breakpad = NULL;

namespace {

const wchar_t kBreakpadProductName[] = L"Chrome";
const wchar_t kBreakpadVersionEntry[] = L"ver";
const wchar_t kBreakpadProdEntry[] = L"prod";
const wchar_t kBreakpadPlatformEntry[] = L"plat";
const wchar_t kBreakpadPlatformWin32[] = L"Win32";

// The protocol for connecting to the out-of-process Breakpad crash
// reporter is different for x86-32 and x86-64: the message sizes
// are different because the message struct contains a pointer.  As
// a result, there are two different named pipes to connect to.  The
// 64-bit one is distinguished with an "-x64" suffix.
const wchar_t kChromePipeName[] = L"\\\\.\\pipe\\ChromeCrashServices\\";
const wchar_t kGoogleUpdatePipeName[] = L"\\\\.\\pipe\\GoogleCrashServices\\";
const wchar_t kSystemPrincipalSid[] = L"S-1-5-18";

const wchar_t kNoErrorDialogs[] = L"noerrdialogs";
const wchar_t kChromeHeadless[] = L"CHROME_HEADLESS";

google_breakpad::CustomClientInfo* GetCustomInfo() {
  static google_breakpad::CustomInfoEntry ver_entry(
      kBreakpadVersionEntry, TEXT(CHROME_VERSION_STRING));
  static google_breakpad::CustomInfoEntry prod_entry(
      kBreakpadProdEntry, kBreakpadProductName);
  static google_breakpad::CustomInfoEntry plat_entry(
      kBreakpadPlatformEntry, kBreakpadPlatformWin32);
  static google_breakpad::CustomInfoEntry entries[] = {
      ver_entry, prod_entry, plat_entry  };
  static google_breakpad::CustomClientInfo custom_info = {
      entries, arraysize(entries) };
  return &custom_info;
}

base::string16 GetUserSidString() {
  // Get the current token.
  HANDLE token = NULL;
  base::string16 user_sid;
  if (!::OpenProcessToken(::GetCurrentProcess(), TOKEN_QUERY, &token))
    return user_sid;

  DWORD size = sizeof(TOKEN_USER) + SECURITY_MAX_SID_SIZE;
  BYTE user_bytes[sizeof(TOKEN_USER) + SECURITY_MAX_SID_SIZE] = {};
  TOKEN_USER* user = reinterpret_cast<TOKEN_USER*>(user_bytes);

  wchar_t* sid_string = NULL;
  if (::GetTokenInformation(token, TokenUser, user, size, &size) &&
      user->User.Sid &&
      ::ConvertSidToStringSid(user->User.Sid, &sid_string)) {
    user_sid = sid_string;
    ::LocalFree(sid_string);
  }

  CloseHandle(token);
  return user_sid;
}

bool IsHeadless() {
  DWORD ret = ::GetEnvironmentVariable(L"CHROME_HEADLESS", NULL, 0);
  if (ret != 0)
    return true;

  wchar_t* command_line = ::GetCommandLine();

  // Note: Since this is a pure substring search rather than a check for a
  // switch, there is a small chance that this code will match things that the
  // Chrome code (which executes a similar check) does not. However, as long as
  // no other switches contain the string "noerrdialogs", it should not be an
  // issue.
  return (command_line && wcsstr(command_line, kNoErrorDialogs));
}

}  // namespace

int GenerateCrashDump(EXCEPTION_POINTERS* exinfo) {
  DWORD code = exinfo->ExceptionRecord->ExceptionCode;
  if (code == EXCEPTION_BREAKPOINT || code == EXCEPTION_SINGLE_STEP)
    return EXCEPTION_CONTINUE_SEARCH;

  if (g_elf_breakpad != NULL)
    g_elf_breakpad->WriteMinidumpForException(exinfo);
  return EXCEPTION_CONTINUE_SEARCH;
}

void InitializeCrashReporting() {
  wchar_t exe_path[MAX_PATH] = {};
  if(!::GetModuleFileName(NULL, exe_path, arraysize(exe_path)))
    return;

  // Disable the message box for assertions.
  _CrtSetReportMode(_CRT_ASSERT, 0);

  // Get the alternate dump directory. We use the temp path.
  // N.B. We don't use base::GetTempDir() here to avoid running more code then
  //      necessary before crashes can be properly reported.
  wchar_t temp_directory[MAX_PATH + 1] = {};
  DWORD length = GetTempPath(MAX_PATH, temp_directory);
  if (length == 0)
    return;

  // Minidump with stacks, PEB, TEBs and unloaded module list.
  MINIDUMP_TYPE dump_type = static_cast<MINIDUMP_TYPE>(
      MiniDumpWithProcessThreadData |  // Get PEB and TEB.
      MiniDumpWithUnloadedModules |  // Get unloaded modules when available.
      MiniDumpWithIndirectlyReferencedMemory);  // Get memory referenced by
                                                // stack.

  // Convert #define to a variable so that we can use if() rather than
  // #if below and so at least compile-test the Chrome code in
  // Chromium builds.
#if defined(GOOGLE_CHROME_BUILD)
  bool is_chrome_build = true;
#else
  bool is_chrome_build = false;
#endif

  base::string16 pipe_name;

  bool enabled_by_policy = false;
  bool use_policy = ReportingIsEnforcedByPolicy(&enabled_by_policy);

  if (!use_policy && IsHeadless()) {
    pipe_name = kChromePipeName;
  } else if (use_policy ? enabled_by_policy :
                          (is_chrome_build && AreUsageStatsEnabled(exe_path))) {
    // Build the pipe name. It can be one of:
    // 32-bit system: \\.\pipe\GoogleCrashServices\S-1-5-18
    // 32-bit user: \\.\pipe\GoogleCrashServices\<user SID>
    // 64-bit system: \\.\pipe\GoogleCrashServices\S-1-5-18-x64
    // 64-bit user: \\.\pipe\GoogleCrashServices\<user SID>-x64
    base::string16 user_sid = IsSystemInstall(exe_path) ? kSystemPrincipalSid :
                                                          GetUserSidString();
    if (user_sid.empty())
      return;

    pipe_name = kGoogleUpdatePipeName;
    pipe_name += user_sid;

#if defined(_WIN64)
    pipe_name += L"-x64";
#endif
  } else {
    // Either this is a Chromium build, reporting is disabled by policy or the
    // user has not given consent.
    return;
  }

  g_elf_breakpad = new google_breakpad::ExceptionHandler(
      temp_directory,
      NULL,
      NULL,
      NULL,
      google_breakpad::ExceptionHandler::HANDLER_ALL,
      dump_type,
      pipe_name.c_str(),
      GetCustomInfo());

  if (g_elf_breakpad->IsOutOfProcess()) {
    // Tells breakpad to handle breakpoint and single step exceptions.
    g_elf_breakpad->set_handle_debug_exceptions(true);
  }
}