Add ChildPortServer, a MachMessageServer::Interface implementation for the child_port subsystem

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/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"
+#include "util/mach/mach_message_util.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
 // these functions. exc_server() and mach_exc_server() are unused and are
 // replaced by the more flexible ExcServer and MachExcServer, but the linker
 // still needs to see these six function definitions.
@@ skipping 75 matching lines @@
     thread_state_t new_state,
     mach_msg_type_number_t* new_state_count) {
   NOTREACHED();
   return KERN_FAILURE;
 }
 
 }  // extern "C"
 
 namespace {
 
-void PrepareReplyFromRequest(const mach_msg_header_t* in_header,
-                             mach_msg_header_t* out_header) {
-  out_header->msgh_bits =
-      MACH_MSGH_BITS(MACH_MSGH_BITS_REMOTE(in_header->msgh_bits), 0);
-  out_header->msgh_remote_port = in_header->msgh_remote_port;
-  out_header->msgh_size = sizeof(mig_reply_error_t);
-  out_header->msgh_local_port = MACH_PORT_NULL;
-  out_header->msgh_id = in_header->msgh_id + 100;
-  reinterpret_cast<mig_reply_error_t*>(out_header)->NDR = NDR_record;
-}
-
-void SetReplyError(mach_msg_header_t* out_header, kern_return_t error) {
-  reinterpret_cast<mig_reply_error_t*>(out_header)->RetCode = error;
-}
-
 // There are no predefined constants for these.
 enum MachMessageID : mach_msg_id_t {
   kMachMessageIDExceptionRaise = 2401,
   kMachMessageIDExceptionRaiseState = 2402,
   kMachMessageIDExceptionRaiseStateIdentity = 2403,
   kMachMessageIDMachExceptionRaise = 2405,
   kMachMessageIDMachExceptionRaiseState = 2406,
   kMachMessageIDMachExceptionRaiseStateIdentity = 2407,
 };
 
@@ skipping 55 matching lines @@
 namespace internal {
 
 ExcServer::ExcServer(ExcServer::Interface* interface)
     : MachMessageServer::Interface(),
       interface_(interface) {
 }
 
 bool ExcServer::MachMessageServerFunction(const mach_msg_header_t* in_header,
                                           mach_msg_header_t* out_header,
                                           bool* destroy_complex_request) {
-  PrepareReplyFromRequest(in_header, out_header);
+  PrepareMIGReplyFromRequest(in_header, out_header);
 
   switch (in_header->msgh_id) {
     case kMachMessageIDExceptionRaise: {
       // exception_raise(), catch_exception_raise().
       using Request = __Request__exception_raise_t;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
       kern_return_t kr = MIGCheckRequestExceptionRaise(in_request);
       if (kr != MACH_MSG_SUCCESS) {
-        SetReplyError(out_header, kr);
+        SetMIGReplyError(out_header, kr);
         return true;
       }
 
       using Reply = __Reply__exception_raise_t;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->RetCode =
           interface_->CatchExceptionRaise(in_header->msgh_local_port,
                                           in_request->thread.name,
                                           in_request->task.name,
                                           in_request->exception,
@@ skipping 12 matching lines @@
       // exception_raise_state(), catch_exception_raise_state().
       using Request = __Request__exception_raise_state_t;
       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);
       if (kr != MACH_MSG_SUCCESS) {
-        SetReplyError(out_header, kr);
+        SetMIGReplyError(out_header, kr);
         return true;
       }
 
       using Reply = __Reply__exception_raise_state_t;
       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_->CatchExceptionRaiseState(in_header->msgh_local_port,
                                                in_request->exception,
@@ skipping 19 matching lines @@
       // catch_exception_raise_state_identity().
       using Request = __Request__exception_raise_state_identity_t;
       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);
       if (kr != MACH_MSG_SUCCESS) {
-        SetReplyError(out_header, kr);
+        SetMIGReplyError(out_header, kr);
         return true;
       }
 
       using Reply = __Reply__exception_raise_state_identity_t;
       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(
           in_header->msgh_local_port,
           in_request->thread.name,
@@ skipping 11 matching lines @@
         return true;
       }
 
       out_header->msgh_size =
           sizeof(*out_reply) - sizeof(out_reply->new_state) +
           sizeof(out_reply->new_state[0]) * out_reply->new_stateCnt;
       return true;
     }
   }
 
-  SetReplyError(out_header, MIG_BAD_ID);
+  SetMIGReplyError(out_header, MIG_BAD_ID);
   return false;
 }
 
 mach_msg_size_t ExcServer::MachMessageServerRequestSize() {
   return sizeof(__RequestUnion__exc_subsystem);
 }
 
 mach_msg_size_t ExcServer::MachMessageServerReplySize() {
   return sizeof(__ReplyUnion__exc_subsystem);
 }
 
 MachExcServer::MachExcServer(MachExcServer::Interface* interface)
     : MachMessageServer::Interface(),
       interface_(interface) {
 }
 
 bool MachExcServer::MachMessageServerFunction(
     const mach_msg_header_t* in_header,
     mach_msg_header_t* out_header,
     bool* destroy_complex_request) {
-  PrepareReplyFromRequest(in_header, out_header);
+  PrepareMIGReplyFromRequest(in_header, out_header);
 
   switch (in_header->msgh_id) {
     case kMachMessageIDMachExceptionRaise: {
       // mach_exception_raise(), catch_mach_exception_raise().
       using Request = __Request__mach_exception_raise_t;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
       kern_return_t kr = MIGCheckRequestMachExceptionRaise(in_request);
       if (kr != MACH_MSG_SUCCESS) {
-        SetReplyError(out_header, kr);
+        SetMIGReplyError(out_header, kr);
         return true;
       }
 
       using Reply = __Reply__mach_exception_raise_t;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->RetCode =
           interface_->CatchMachExceptionRaise(in_header->msgh_local_port,
                                               in_request->thread.name,
                                               in_request->task.name,
                                               in_request->exception,
@@ skipping 12 matching lines @@
       // mach_exception_raise_state(), catch_mach_exception_raise_state().
       using Request = __Request__mach_exception_raise_state_t;
       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);
       if (kr != MACH_MSG_SUCCESS) {
-        SetReplyError(out_header, kr);
+        SetMIGReplyError(out_header, kr);
         return true;
       }
 
       using Reply = __Reply__mach_exception_raise_state_t;
       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_->CatchMachExceptionRaiseState(in_header->msgh_local_port,
                                                    in_request->exception,
@@ skipping 19 matching lines @@
       // catch_mach_exception_raise_state_identity().
       using Request = __Request__mach_exception_raise_state_identity_t;
       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 = MIGCheckRequestMachExceptionRaiseStateIdentity(
           in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
-        SetReplyError(out_header, kr);
+        SetMIGReplyError(out_header, kr);
         return true;
       }
 
       using Reply = __Reply__mach_exception_raise_state_identity_t;
       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_->CatchMachExceptionRaiseStateIdentity(
           in_header->msgh_local_port,
           in_request->thread.name,
@@ skipping 11 matching lines @@
         return true;
       }
 
       out_header->msgh_size =
           sizeof(*out_reply) - sizeof(out_reply->new_state) +
           sizeof(out_reply->new_state[0]) * out_reply->new_stateCnt;
       return true;
     }
   }
 
-  SetReplyError(out_header, MIG_BAD_ID);
+  SetMIGReplyError(out_header, MIG_BAD_ID);
   return false;
 }
 
 mach_msg_size_t MachExcServer::MachMessageServerRequestSize() {
   return sizeof(__RequestUnion__mach_exc_subsystem);
 }
 
 mach_msg_size_t MachExcServer::MachMessageServerReplySize() {
   return sizeof(__ReplyUnion__mach_exc_subsystem);
 }
@@ skipping 194 matching lines @@
           in_header, out_header, destroy_complex_request);
     case kMachMessageIDExceptionRaise:
     case kMachMessageIDExceptionRaiseState:
     case kMachMessageIDExceptionRaiseStateIdentity:
       return exc_server_.MachMessageServerFunction(
           in_header, out_header, destroy_complex_request);
   }
 
   // Do what the MIG-generated server routines do when they can’t dispatch a
   // message.
-  PrepareReplyFromRequest(in_header, out_header);
-  SetReplyError(out_header, MIG_BAD_ID);
+  PrepareMIGReplyFromRequest(in_header, out_header);
+  SetMIGReplyError(out_header, MIG_BAD_ID);
   return false;
 }
 
 mach_msg_size_t UniversalMachExcServer::MachMessageServerRequestSize() {
   return std::max(mach_exc_server_.MachMessageServerRequestSize(),
                   exc_server_.MachMessageServerRequestSize());
 }
 
 mach_msg_size_t UniversalMachExcServer::MachMessageServerReplySize() {
   return std::max(mach_exc_server_.MachMessageServerReplySize(),
@@ skipping 65 matching lines @@
 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