handler: Write crash reports to a crash report database

handler/mac/exception_handler_server.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 "handler/mac/exception_handler_server.h"
 
 #include "base/logging.h"
 #include "base/mac/mach_logging.h"
-#include "base/strings/stringprintf.h"
 #include "util/mach/composite_mach_message_server.h"
-#include "util/mach/exc_server_variants.h"
-#include "util/mach/exception_behaviors.h"
 #include "util/mach/mach_extensions.h"
 #include "util/mach/mach_message.h"
 #include "util/mach/mach_message_server.h"
 #include "util/mach/notify_server.h"
 
 namespace crashpad {
 
 namespace {
 
 class ExceptionHandlerServerRun
     : public UniversalMachExcServer::Interface,
       public NotifyServer::Interface {
  public:
-  explicit ExceptionHandlerServerRun(mach_port_t exception_port)
+  ExceptionHandlerServerRun(
+      mach_port_t exception_port,
+      UniversalMachExcServer::Interface* exception_interface)
       : UniversalMachExcServer::Interface(),
         NotifyServer::Interface(),
         mach_exc_server_(this),
         notify_server_(this),
         composite_mach_message_server_(),
+        exception_interface_(exception_interface),
         exception_port_(exception_port),
         notify_port_(NewMachPort(MACH_PORT_RIGHT_RECEIVE)),
         running_(true) {
     CHECK_NE(notify_port_, kMachPortNull);
 
     composite_mach_message_server_.AddHandler(&mach_exc_server_);
     composite_mach_message_server_.AddHandler(&notify_server_);
   }
 
   ~ExceptionHandlerServerRun() {
@@ skipping 65 matching lines @@
                                    exception_type_t exception,
                                    const mach_exception_data_type_t* code,
                                    mach_msg_type_number_t code_count,
                                    thread_state_flavor_t* flavor,
                                    const natural_t* old_state,
                                    mach_msg_type_number_t old_state_count,
                                    thread_state_t new_state,
                                    mach_msg_type_number_t* new_state_count,
                                    const mach_msg_trailer_t* trailer,
                                    bool* destroy_complex_request) override {
-    *destroy_complex_request = true;
-
     if (exception_port != exception_port_) {
       LOG(WARNING) << "exception port mismatch";
       return MIG_BAD_ID;
     }
 
-    // The expected behavior is EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES,
-    // but it’s possible to deal with any exception behavior as long as it
-    // carries identity information (valid thread and task ports).
-    if (!ExceptionBehaviorHasIdentity(behavior)) {
-      LOG(WARNING) << base::StringPrintf(
-          "unexpected exception behavior 0x%x, rejecting", behavior);
-      return KERN_FAILURE;
-    } else if (behavior != (EXCEPTION_STATE_IDENTITY | kMachExceptionCodes)) {
-      LOG(WARNING) << base::StringPrintf(
-          "unexpected exception behavior 0x%x, proceeding", behavior);
-    }
-
-    // TODO(mark): Implement.
-
-    return ExcServerSuccessfulReturnValue(behavior, false);
+    return exception_interface_->CatchMachException(behavior,
+                                                    exception_port,
+                                                    thread,
+                                                    task,
+                                                    exception,
+                                                    code,
+                                                    code_count,
+                                                    flavor,
+                                                    old_state,
+                                                    old_state_count,
+                                                    new_state,
+                                                    new_state_count,
+                                                    trailer,
+                                                    destroy_complex_request);
   }
 
   // NotifyServer::Interface:
 
   kern_return_t DoMachNotifyPortDeleted(
         notify_port_t notify,
         mach_port_name_t name,
         const mach_msg_trailer_t* trailer) override {
     return UnimplementedNotifyRoutine(notify);
   }
@@ skipping 47 matching lines @@
       return MIG_BAD_ID;
     }
 
     NOTREACHED();
     return KERN_FAILURE;
   }
 
   UniversalMachExcServer mach_exc_server_;
   NotifyServer notify_server_;
   CompositeMachMessageServer composite_mach_message_server_;
+  UniversalMachExcServer::Interface* exception_interface_;  // weak
   mach_port_t exception_port_;  // weak
   base::mac::ScopedMachReceiveRight notify_port_;
   bool running_;
 
   DISALLOW_COPY_AND_ASSIGN(ExceptionHandlerServerRun);
 };
 
 }  // namespace
 
 ExceptionHandlerServer::ExceptionHandlerServer()
     : receive_port_(NewMachPort(MACH_PORT_RIGHT_RECEIVE)) {
   CHECK_NE(receive_port_, kMachPortNull);
 }
 
 ExceptionHandlerServer::~ExceptionHandlerServer() {
 }
 
-void ExceptionHandlerServer::Run() {
-  ExceptionHandlerServerRun run(receive_port_);
+void ExceptionHandlerServer::Run(
+    UniversalMachExcServer::Interface* exception_interface) {
+  ExceptionHandlerServerRun run(receive_port_, exception_interface);
   run.Run();
 }
 
 }  // namespace crashpad