Add ExcServerSuccessfulReturnValue() and its test

util/mach/exc_server_variants.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 "util/mach/exc_server_variants.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "util/mach/exc.h"
+#include "util/mach/exception_behaviors.h"
 #include "util/mach/excServer.h"
 #include "util/mach/mach_exc.h"
 #include "util/mach/mach_excServer.h"
 
 extern "C" {
 
 // These six functions are not used, and are in fact obsoleted by the other
 // functionality implemented in this file. The standard MIG-generated exc_server
 // (in excServer.c) and mach_exc_server (in mach_excServer.c) server dispatch
 // routines usable with the standard mach_msg_server() function call out to
@@ skipping 207 matching lines @@
     }
 
     case kMachMessageIDExceptionRaiseState: {
       // exception_raise_state(), catch_exception_raise_state().
       typedef __Request__exception_raise_state_t Request;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
       const Request* in_request_1;
-      kern_return_t kr = MIGCheckRequestExceptionRaiseState(
-          in_request, &in_request_1);
+      kern_return_t kr =
+          MIGCheckRequestExceptionRaiseState(in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__exception_raise_state_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode =
@@ skipping 18 matching lines @@
 
     case kMachMessageIDExceptionRaiseStateIdentity: {
       // exception_raise_state_identity(),
       // catch_exception_raise_state_identity().
       typedef __Request__exception_raise_state_identity_t Request;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
       const Request* in_request_1;
-      kern_return_t kr = MIGCheckRequestExceptionRaiseStateIdentity(
-          in_request, &in_request_1);
+      kern_return_t kr =
+          MIGCheckRequestExceptionRaiseStateIdentity(in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__exception_raise_state_identity_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode = interface_->CatchExceptionRaiseStateIdentity(
@@ skipping 73 matching lines @@
     }
 
     case kMachMessageIDMachExceptionRaiseState: {
       // mach_exception_raise_state(), catch_mach_exception_raise_state().
       typedef __Request__mach_exception_raise_state_t Request;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
       const Request* in_request_1;
-      kern_return_t kr = MIGCheckRequestMachExceptionRaiseState(
-          in_request, &in_request_1);
+      kern_return_t kr =
+          MIGCheckRequestMachExceptionRaiseState(in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__mach_exception_raise_state_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode =
@@ skipping 318 matching lines @@
                             code_count ? &mach_codes[0] : NULL,
                             code_count,
                             flavor,
                             old_state,
                             old_state_count,
                             new_state,
                             new_state_count,
                             destroy_complex_request);
 }
 
+kern_return_t ExcServerSuccessfulReturnValue(exception_behavior_t behavior,
+                                             bool set_thread_state) {
+  if (!set_thread_state && ExceptionBehaviorHasState(behavior)) {
+    return MACH_RCV_PORT_DIED;
+  }
+
+  return KERN_SUCCESS;
+}
+
 }  // namespace crashpad