Allow exception forwarding to the system’s native crash reporter to be disabled

snapshot/mac/mach_o_image_reader.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "snapshot/mac/mach_o_image_reader.h"
 
 #include <mach-o/loader.h>
 #include <mach-o/nlist.h>
 #include <string.h>
 
 #include <limits>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
+#include "client/crashpad_info.h"
 #include "snapshot/mac/mach_o_image_segment_reader.h"
 #include "snapshot/mac/mach_o_image_symbol_table_reader.h"
 #include "snapshot/mac/process_reader.h"
 #include "util/mac/checked_mach_address_range.h"
 
 namespace {
 
 const uint32_t kInvalidSegmentIndex = std::numeric_limits<uint32_t>::max();
 
 }  // namespace
@@ skipping 411 matching lines @@
 
   // In case this was a weird dylib without an LC_ID_DYLIB command.
   return 0;
 }
 
 void MachOImageReader::UUID(crashpad::UUID* uuid) const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   memcpy(uuid, &uuid_, sizeof(uuid_));
 }
 
+bool MachOImageReader::GetCrashpadInfo(
+    process_types::CrashpadInfo* crashpad_info) const {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+
+  mach_vm_address_t crashpad_info_address;
+  const process_types::section* crashpad_info_section =
+      GetSectionByName(SEG_DATA, "__crashpad_info", &crashpad_info_address);
+  if (!crashpad_info_section) {
+    return false;
+  }
+
+  if (crashpad_info_section->size <
+      crashpad_info->ExpectedSize(process_reader_)) {
+    LOG(WARNING) << "small crashpad info section size "
+                 << crashpad_info_section->size << module_info_;
+    return false;
+  }
+
+  if (!crashpad_info->Read(process_reader_, crashpad_info_address)) {
+    LOG(WARNING) << "could not read crashpad info" << module_info_;
+    return false;
+  }
+
+  if (crashpad_info->signature != CrashpadInfo::kSignature ||
+      crashpad_info->size != crashpad_info_section->size ||
+      crashpad_info->version < 1) {
+    LOG(WARNING) << "unexpected crashpad info data" << module_info_;
+    return false;
+  }
+
+  return true;
+}
+
 template <typename T>
 bool MachOImageReader::ReadLoadCommand(mach_vm_address_t load_command_address,
                                        const std::string& load_command_info,
                                        uint32_t expected_load_command_id,
                                        T* load_command) {
   if (!load_command->Read(process_reader_, load_command_address)) {
     LOG(WARNING) << "could not read load command" << load_command_info;
     return false;
   }
 
@@ skipping 195 matching lines @@
                                  linkedit_segment,
                                  module_info_)) {
     symbol_table_.reset();
     return;
   }
 
   symbol_table_initialized_.set_valid();
 }
 
 }  // namespace crashpad