// Copyright 2016 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.
//
// Note: aside from using windows headers to obtain the definitions of minidump
//     structures, nothing here is windows specific. This seems like the best
//     approach given this code is for temporary experimentation on Windows.
//     Longer term, Crashpad will take over the minidump writing in this case as
//     well.

#include "components/browser_watcher/postmortem_minidump_writer.h"

#include <windows.h>  // NOLINT
#include <dbghelp.h>

#include <map>
#include <type_traits>
#include <vector>

#include "base/files/file_util.h"
#include "base/macros.h"
#include "base/metrics/histogram_macros.h"
#include "base/numerics/safe_math.h"
#include "base/strings/string_piece.h"
#include "components/browser_watcher/minidump_user_streams.h"
#include "components/browser_watcher/stability_data_names.h"
#include "third_party/crashpad/crashpad/minidump/minidump_extensions.h"

namespace browser_watcher {

namespace {

struct ProductDetails {
  std::string product;
  std::string channel;
  std::string platform;
  std::string version;
};

bool GetStringFromTypedValueMap(
    const google::protobuf::Map<std::string, TypedValue>& map,
    const std::string& key,
    std::string* out) {
  DCHECK(out);

  auto it = map.find(key);
  if (it == map.end())
    return false;

  const TypedValue& value = it->second;
  if (value.value_case() != TypedValue::kStringValue)
    return false;

  *out = value.string_value();
  return true;
}

bool GetProductDetails(
    const google::protobuf::Map<std::string, TypedValue>& global_data,
    ProductDetails* product_details) {
  DCHECK(product_details);

  if (!GetStringFromTypedValueMap(global_data, kStabilityProduct,
                                  &(product_details->product)))
    return false;
  if (!GetStringFromTypedValueMap(global_data, kStabilityChannel,
                                  &(product_details->channel)))
    return false;
  if (!GetStringFromTypedValueMap(global_data, kStabilityPlatform,
                                  &(product_details->platform)))
    return false;
  return GetStringFromTypedValueMap(global_data, kStabilityVersion,
                                    &(product_details->version));
}

int64_t GetFileOffset(base::File* file) {
  DCHECK(file);
  return file->Seek(base::File::FROM_CURRENT, 0LL);
}

// Returns true if the file is empty, and false if the file is not empty or if
// there is an error.
bool IsFileEmpty(base::File* file) {
  DCHECK(file);
  int64_t end = file->Seek(base::File::FROM_END, 0LL);
  return end == 0LL;
}

// A class with functionality for writing minimal minidump containers to wrap
// postmortem stability reports.
// TODO(manzagop): remove this class once Crashpad takes over writing postmortem
//     minidumps.
// TODO(manzagop): revisit where the module information should be transported,
//     in the protocol buffer or in a module stream.
class PostmortemMinidumpWriter {
 public:
  // DO NOT CHANGE VALUES. This is logged persistently in a histogram.
  enum WriteStatus {
    SUCCESS = 0,
    FAILED = 1,
    FAILED_MISSING_PRODUCT_DETAILS = 2,
    WRITE_STATUS_MAX = 3
  };

  PostmortemMinidumpWriter();
  ~PostmortemMinidumpWriter();

  // Write to |minidump_file| a minimal minidump that wraps |report|. Returns
  // true on success, false otherwise.
  // Note: the caller owns |minidump_file| and is responsible for keeping it
  // valid for this object's lifetime. |minidump_file| is expected to be empty
  // and a binary stream.
  bool WriteDump(base::PlatformFile minidump_file,
                 const crashpad::UUID& client_id,
                 const crashpad::UUID& report_id,
                 StabilityReport* report);

 private:
  // An offset within a minidump file. Note: using this type to avoid including
  // windows.h and relying on the RVA type.
  using FilePosition = uint32_t;

  // The minidump header is always located at the head.
  static const FilePosition kHeaderPos = 0U;

  bool WriteDumpImpl(const StabilityReport& report,
                     const crashpad::UUID& client_id,
                     const crashpad::UUID& report_id,
                     const ProductDetails& product_details);

  bool AppendCrashpadInfo(const crashpad::UUID& client_id,
                          const crashpad::UUID& report_id,
                          const std::map<std::string, std::string>& crash_keys);

  bool AppendCrashpadDictionaryEntry(
      const std::string& key,
      const std::string& value,
      std::vector<crashpad::MinidumpSimpleStringDictionaryEntry>* entries);

  // Allocate |size_bytes| within the minidump. On success, |pos| contains the
  // location of the allocation. Returns true on success, false otherwise.
  bool Allocate(size_t size_bytes, FilePosition* pos);

  // Seeks |cursor_|. The seek operation is kept separate from the write in
  // order to make the call explicit. Seek operations can be costly and should
  // be avoided.
  bool SeekCursor(FilePosition destination);

  // Write to pre-allocated space.
  // Note: |pos| must match |cursor_|.
  template <class DataType>
  bool Write(FilePosition pos, const DataType& data);
  bool WriteBytes(FilePosition pos, size_t size_bytes, const char* data);

  // Allocate space for and write the contents of |data|. On success, |pos|
  // contains the location of the write. Returns true on success, false
  // otherwise.
  template <class DataType>
  bool Append(const DataType& data, FilePosition* pos);
  template <class DataType>
  bool AppendVec(const std::vector<DataType>& data, FilePosition* pos);
  bool AppendUtf8String(base::StringPiece data, FilePosition* pos);
  bool AppendBytes(base::StringPiece data, FilePosition* pos);

  void RegisterDirectoryEntry(uint32_t stream_type,
                              FilePosition pos,
                              uint32_t size);

  // The next allocatable FilePosition.
  FilePosition next_available_byte_;

  // Storage for the directory during writes.
  std::vector<MINIDUMP_DIRECTORY> directory_;

  // The file to write to. Only valid within the scope of a call to WriteDump.
  base::File* minidump_file_;

  DISALLOW_COPY_AND_ASSIGN(PostmortemMinidumpWriter);
};

// This function's purpose is to limit code / data size caused by uma macros.
void RecordWriteDumpStatus(PostmortemMinidumpWriter::WriteStatus status) {
  UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.WriteDumpStatus", status,
                            PostmortemMinidumpWriter::WRITE_STATUS_MAX);
}

PostmortemMinidumpWriter::PostmortemMinidumpWriter()
    : next_available_byte_(0U), minidump_file_(nullptr) {}

PostmortemMinidumpWriter::~PostmortemMinidumpWriter() {
  DCHECK_EQ(nullptr, minidump_file_);
}

bool PostmortemMinidumpWriter::WriteDump(
    base::PlatformFile minidump_platform_file,
    const crashpad::UUID& client_id,
    const crashpad::UUID& report_id,
    StabilityReport* report) {
  DCHECK_NE(base::kInvalidPlatformFile, minidump_platform_file);
  DCHECK(report);

  DCHECK_EQ(0U, next_available_byte_);
  DCHECK(directory_.empty());
  DCHECK_EQ(nullptr, minidump_file_);

  // Ensure the report contains the crasher's product details.
  ProductDetails product_details = {};
  if (!GetProductDetails(report->global_data(), &product_details)) {
    // The report is missing the basic information to determine the affected
    // version. Ignore the report.
    RecordWriteDumpStatus(FAILED_MISSING_PRODUCT_DETAILS);
    return false;
  }

  // No need to keep the version details inside the report.
  report->mutable_global_data()->erase(kStabilityProduct);
  report->mutable_global_data()->erase(kStabilityChannel);
  report->mutable_global_data()->erase(kStabilityPlatform);
  report->mutable_global_data()->erase(kStabilityVersion);

  // We do not own |minidump_platform_file|, but we want to rely on base::File's
  // API, and so we need to duplicate it.
  HANDLE duplicated_handle;
  BOOL duplicate_success = ::DuplicateHandle(
      ::GetCurrentProcess(), minidump_platform_file, ::GetCurrentProcess(),
      &duplicated_handle, 0, FALSE, DUPLICATE_SAME_ACCESS);
  if (!duplicate_success) {
    RecordWriteDumpStatus(FAILED);
    return false;
  }
  base::File minidump_file(duplicated_handle);
  DCHECK(minidump_file.IsValid());
  minidump_file_ = &minidump_file;
  DCHECK_EQ(0LL, GetFileOffset(minidump_file_));
  DCHECK(IsFileEmpty(minidump_file_));

  // Write the minidump, then reset members.
  bool success = WriteDumpImpl(*report, client_id, report_id, product_details);
  next_available_byte_ = 0U;
  directory_.clear();
  minidump_file_ = nullptr;

  RecordWriteDumpStatus(success ? SUCCESS : FAILED);
  return success;
}

bool PostmortemMinidumpWriter::WriteDumpImpl(
    const StabilityReport& report,
    const crashpad::UUID& client_id,
    const crashpad::UUID& report_id,
    const ProductDetails& product_details) {
  // Allocate space for the header and seek the cursor.
  FilePosition pos = 0U;
  if (!Allocate(sizeof(MINIDUMP_HEADER), &pos))
    return false;
  if (!SeekCursor(sizeof(MINIDUMP_HEADER)))
    return false;
  DCHECK_EQ(kHeaderPos, pos);

  // Write the proto to the file.
  std::string serialized_report;
  if (!report.SerializeToString(&serialized_report))
    return false;
  FilePosition report_pos = 0U;
  if (!AppendBytes(serialized_report, &report_pos))
    return false;

  // The directory entry for the stability report's stream.
  RegisterDirectoryEntry(kStabilityReportStreamType, report_pos,
                         serialized_report.length());

  // Write mandatory crash keys. These will be read by crashpad and used as
  // http request parameters for the upload. Keys and values should match
  // server side configuration.
  // TODO(manzagop): use product and version from the stability report. The
  // current executable's values are an (imperfect) proxy.
  std::map<std::string, std::string> crash_keys = {
      {"prod", product_details.product + "_Postmortem"},
      {"ver", product_details.version},
      {"channel", product_details.channel},
      {"plat", product_details.platform}};
  if (!AppendCrashpadInfo(client_id, report_id, crash_keys))
    return false;

  // Write the directory.
  FilePosition directory_pos = 0U;
  if (!AppendVec(directory_, &directory_pos))
    return false;

  // Write the header.
  MINIDUMP_HEADER header;
  header.Signature = MINIDUMP_SIGNATURE;
  header.Version = MINIDUMP_VERSION;
  header.NumberOfStreams = directory_.size();
  header.StreamDirectoryRva = directory_pos;
  if (!SeekCursor(0U))
    return false;
  return Write(kHeaderPos, header);
}

bool PostmortemMinidumpWriter::AppendCrashpadInfo(
    const crashpad::UUID& client_id,
    const crashpad::UUID& report_id,
    const std::map<std::string, std::string>& crash_keys) {
  // Write the crash keys as the contents of a crashpad dictionary.
  std::vector<crashpad::MinidumpSimpleStringDictionaryEntry> entries;
  for (const auto& crash_key : crash_keys) {
    if (!AppendCrashpadDictionaryEntry(crash_key.first, crash_key.second,
                                       &entries)) {
      return false;
    }
  }

  // Write the dictionary's index.
  FilePosition dict_pos = 0U;
  uint32_t entry_count = entries.size();
  if (entry_count > 0) {
    if (!Append(entry_count, &dict_pos))
      return false;
    FilePosition unused_pos = 0U;
    if (!AppendVec(entries, &unused_pos))
      return false;
  }

  MINIDUMP_LOCATION_DESCRIPTOR simple_annotations = {0};
  simple_annotations.DataSize = 0U;
  if (entry_count > 0)
    simple_annotations.DataSize = next_available_byte_ - dict_pos;
  // Note: an RVA of 0 indicates the absence of a dictionary.
  simple_annotations.Rva = dict_pos;

  // Write the crashpad info.
  crashpad::MinidumpCrashpadInfo crashpad_info;
  crashpad_info.version = crashpad::MinidumpCrashpadInfo::kVersion;
  crashpad_info.report_id = report_id;
  crashpad_info.client_id = client_id;
  crashpad_info.simple_annotations = simple_annotations;
  // Note: module_list is left at 0, which means none.

  FilePosition crashpad_pos = 0U;
  if (!Append(crashpad_info, &crashpad_pos))
    return false;

  // Append a directory entry for the crashpad info stream.
  RegisterDirectoryEntry(crashpad::kMinidumpStreamTypeCrashpadInfo,
                         crashpad_pos, sizeof(crashpad::MinidumpCrashpadInfo));

  return true;
}

bool PostmortemMinidumpWriter::AppendCrashpadDictionaryEntry(
    const std::string& key,
    const std::string& value,
    std::vector<crashpad::MinidumpSimpleStringDictionaryEntry>* entries) {
  DCHECK_NE(nullptr, entries);

  FilePosition key_pos = 0U;
  if (!AppendUtf8String(key, &key_pos))
    return false;
  FilePosition value_pos = 0U;
  if (!AppendUtf8String(value, &value_pos))
    return false;

  crashpad::MinidumpSimpleStringDictionaryEntry entry = {0};
  entry.key = key_pos;
  entry.value = value_pos;
  entries->push_back(entry);

  return true;
}

bool PostmortemMinidumpWriter::Allocate(size_t size_bytes, FilePosition* pos) {
  DCHECK(pos);
  *pos = next_available_byte_;

  base::CheckedNumeric<FilePosition> next = next_available_byte_;
  next += size_bytes;
  if (!next.IsValid())
    return false;

  next_available_byte_ += size_bytes;
  return true;
}

bool PostmortemMinidumpWriter::SeekCursor(FilePosition destination) {
  DCHECK_NE(nullptr, minidump_file_);
  DCHECK(minidump_file_->IsValid());

  // Validate the write does not extend past the allocated space.
  if (destination > next_available_byte_)
    return false;

  int64_t new_pos = minidump_file_->Seek(base::File::FROM_BEGIN,
                                         static_cast<int64_t>(destination));
  return new_pos != -1;
}

template <class DataType>
bool PostmortemMinidumpWriter::Write(FilePosition pos, const DataType& data) {
  static_assert(std::is_trivially_copyable<DataType>::value,
                "restricted to trivially copyable");
  return WriteBytes(pos, sizeof(data), reinterpret_cast<const char*>(&data));
}

bool PostmortemMinidumpWriter::WriteBytes(FilePosition pos,
                                          size_t size_bytes,
                                          const char* data) {
  DCHECK(data);
  DCHECK_NE(nullptr, minidump_file_);
  DCHECK(minidump_file_->IsValid());
  DCHECK_EQ(static_cast<int64_t>(pos), GetFileOffset(minidump_file_));

  // Validate the write does not extend past the next available byte.
  base::CheckedNumeric<FilePosition> pos_end = pos;
  pos_end += size_bytes;
  if (!pos_end.IsValid() || pos_end.ValueOrDie() > next_available_byte_)
    return false;

  int size_bytes_signed = static_cast<int>(size_bytes);
  CHECK_LE(0, size_bytes_signed);

  int written_bytes =
      minidump_file_->WriteAtCurrentPos(data, size_bytes_signed);
  if (written_bytes < 0)
    return false;
  return static_cast<size_t>(written_bytes) == size_bytes;
}

template <class DataType>
bool PostmortemMinidumpWriter::Append(const DataType& data, FilePosition* pos) {
  static_assert(std::is_trivially_copyable<DataType>::value,
                "restricted to trivially copyable");
  DCHECK(pos);
  if (!Allocate(sizeof(data), pos))
    return false;
  return Write(*pos, data);
}

template <class DataType>
bool PostmortemMinidumpWriter::AppendVec(const std::vector<DataType>& data,
                                         FilePosition* pos) {
  static_assert(std::is_trivially_copyable<DataType>::value,
                "restricted to trivially copyable");
  DCHECK(!data.empty());
  DCHECK(pos);

  size_t size_bytes = sizeof(DataType) * data.size();
  if (!Allocate(size_bytes, pos))
    return false;
  return WriteBytes(*pos, size_bytes,
                    reinterpret_cast<const char*>(&data.at(0)));
}

bool PostmortemMinidumpWriter::AppendUtf8String(base::StringPiece data,
                                                FilePosition* pos) {
  DCHECK(pos);
  uint32_t string_size = data.size();
  if (!Append(string_size, pos))
    return false;

  FilePosition unused_pos = 0U;
  return AppendBytes(data, &unused_pos);
}

bool PostmortemMinidumpWriter::AppendBytes(base::StringPiece data,
                                           FilePosition* pos) {
  DCHECK(pos);
  if (!Allocate(data.length(), pos))
    return false;
  return WriteBytes(*pos, data.length(), data.data());
}

void PostmortemMinidumpWriter::RegisterDirectoryEntry(uint32_t stream_type,
                                                      FilePosition pos,
                                                      uint32_t size) {
  MINIDUMP_DIRECTORY entry = {0};
  entry.StreamType = stream_type;
  entry.Location.Rva = pos;
  entry.Location.DataSize = size;
  directory_.push_back(entry);
}

}  // namespace

bool WritePostmortemDump(base::PlatformFile minidump_file,
                         const crashpad::UUID& client_id,
                         const crashpad::UUID& report_id,
                         StabilityReport* report) {
  DCHECK(report);

  PostmortemMinidumpWriter writer;
  return writer.WriteDump(minidump_file, client_id, report_id, report);
}

}  // namespace browser_watcher