Pass Mach message trailers to server handler functions

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,
@@ skipping 178 matching lines @@
 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) {
   PrepareMIGReplyFromRequest(in_header, out_header);
 
+  const mach_msg_trailer_t* in_trailer =
+      MachMessageTrailerFromHeader(in_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) {
         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,
                                           in_request->code,
                                           in_request->codeCnt,
+                                          in_trailer,
                                           destroy_complex_request);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
       out_header->msgh_size = sizeof(*out_reply);
       return true;
     }
 
     case kMachMessageIDExceptionRaiseState: {
@@ skipping 17 matching lines @@
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode =
           interface_->CatchExceptionRaiseState(in_header->msgh_local_port,
                                                in_request->exception,
                                                in_request->code,
                                                in_request->codeCnt,
                                                &out_reply->flavor,
                                                in_request_1->old_state,
                                                in_request_1->old_stateCnt,
                                                out_reply->new_state,
-                                               &out_reply->new_stateCnt);
+                                               &out_reply->new_stateCnt,
+                                               in_trailer);
       if (out_reply->RetCode != KERN_SUCCESS) {
         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;
     }
 
@@ skipping 22 matching lines @@
           in_request->thread.name,
           in_request->task.name,
           in_request->exception,
           in_request->code,
           in_request->codeCnt,
           &out_reply->flavor,
           in_request_1->old_state,
           in_request_1->old_stateCnt,
           out_reply->new_state,
           &out_reply->new_stateCnt,
+          in_trailer,
           destroy_complex_request);
       if (out_reply->RetCode != KERN_SUCCESS) {
         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;
     }
@@ skipping 15 matching lines @@
     : MachMessageServer::Interface(),
       interface_(interface) {
 }
 
 bool MachExcServer::MachMessageServerFunction(
     const mach_msg_header_t* in_header,
     mach_msg_header_t* out_header,
     bool* destroy_complex_request) {
   PrepareMIGReplyFromRequest(in_header, out_header);
 
+  const mach_msg_trailer_t* in_trailer =
+      MachMessageTrailerFromHeader(in_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) {
         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,
                                               in_request->code,
                                               in_request->codeCnt,
+                                              in_trailer,
                                               destroy_complex_request);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
       out_header->msgh_size = sizeof(*out_reply);
       return true;
     }
 
     case kMachMessageIDMachExceptionRaiseState: {
@@ skipping 17 matching lines @@
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode =
           interface_->CatchMachExceptionRaiseState(in_header->msgh_local_port,
                                                    in_request->exception,
                                                    in_request->code,
                                                    in_request->codeCnt,
                                                    &out_reply->flavor,
                                                    in_request_1->old_state,
                                                    in_request_1->old_stateCnt,
                                                    out_reply->new_state,
-                                                   &out_reply->new_stateCnt);
+                                                   &out_reply->new_stateCnt,
+                                                   in_trailer);
       if (out_reply->RetCode != KERN_SUCCESS) {
         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;
     }
 
@@ skipping 22 matching lines @@
           in_request->thread.name,
           in_request->task.name,
           in_request->exception,
           in_request->code,
           in_request->codeCnt,
           &out_reply->flavor,
           in_request_1->old_state,
           in_request_1->old_stateCnt,
           out_reply->new_state,
           &out_reply->new_stateCnt,
+          in_trailer,
           destroy_complex_request);
       if (out_reply->RetCode != KERN_SUCCESS) {
         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;
     }
@@ skipping 18 matching lines @@
       interface_(interface) {
 }
 
 kern_return_t SimplifiedExcServer::CatchExceptionRaise(
     exception_handler_t exception_port,
     thread_t thread,
     task_t task,
     exception_type_t exception,
     const exception_data_type_t* code,
     mach_msg_type_number_t code_count,
+    const mach_msg_trailer_t* trailer,
     bool* destroy_request) {
   thread_state_flavor_t flavor = THREAD_STATE_NONE;
   mach_msg_type_number_t new_state_count = 0;
   return interface_->CatchException(EXCEPTION_DEFAULT,
                                     exception_port,
                                     thread,
                                     task,
                                     exception,
                                     code,
                                     code_count,
                                     &flavor,
                                     nullptr,
                                     0,
                                     nullptr,
                                     &new_state_count,
+                                    trailer,
                                     destroy_request);
 }
 
 kern_return_t SimplifiedExcServer::CatchExceptionRaiseState(
     exception_handler_t exception_port,
     exception_type_t exception,
     const 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) {
+    mach_msg_type_number_t* new_state_count,
+    const mach_msg_trailer_t* trailer) {
   bool destroy_complex_request = false;
   return interface_->CatchException(EXCEPTION_STATE,
                                     exception_port,
                                     THREAD_NULL,
                                     TASK_NULL,
                                     exception,
                                     code,
                                     code_count,
                                     flavor,
                                     old_state,
                                     old_state_count,
                                     new_state,
                                     new_state_count,
+                                    trailer,
                                     &destroy_complex_request);
 }
 
 kern_return_t SimplifiedExcServer::CatchExceptionRaiseStateIdentity(
     exception_handler_t exception_port,
     thread_t thread,
     task_t task,
     exception_type_t exception,
     const 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_request) {
   return interface_->CatchException(EXCEPTION_STATE_IDENTITY,
                                     exception_port,
                                     thread,
                                     task,
                                     exception,
                                     code,
                                     code_count,
                                     flavor,
                                     old_state,
                                     old_state_count,
                                     new_state,
                                     new_state_count,
+                                    trailer,
                                     destroy_request);
 }
 
 SimplifiedMachExcServer::SimplifiedMachExcServer(
     SimplifiedMachExcServer::Interface* interface)
     : MachExcServer(this),
       MachExcServer::Interface(),
       interface_(interface) {
 }
 
 kern_return_t SimplifiedMachExcServer::CatchMachExceptionRaise(
     exception_handler_t exception_port,
     thread_t thread,
     task_t task,
     exception_type_t exception,
     const mach_exception_data_type_t* code,
     mach_msg_type_number_t code_count,
+    const mach_msg_trailer_t* trailer,
     bool* destroy_request) {
   thread_state_flavor_t flavor = THREAD_STATE_NONE;
   mach_msg_type_number_t new_state_count = 0;
   return interface_->CatchMachException(
       EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES,
       exception_port,
       thread,
       task,
       exception,
       code,
       code_count,
       &flavor,
       nullptr,
       0,
       nullptr,
       &new_state_count,
+      trailer,
       destroy_request);
 }
 
 kern_return_t SimplifiedMachExcServer::CatchMachExceptionRaiseState(
     exception_handler_t exception_port,
     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) {
+    mach_msg_type_number_t* new_state_count,
+    const mach_msg_trailer_t* trailer) {
   bool destroy_complex_request = false;
   return interface_->CatchMachException(EXCEPTION_STATE | MACH_EXCEPTION_CODES,
                                         exception_port,
                                         THREAD_NULL,
                                         TASK_NULL,
                                         exception,
                                         code,
                                         code_count,
                                         flavor,
                                         old_state,
                                         old_state_count,
                                         new_state,
                                         new_state_count,
+                                        trailer,
                                         &destroy_complex_request);
 }
 
 kern_return_t SimplifiedMachExcServer::CatchMachExceptionRaiseStateIdentity(
     exception_handler_t exception_port,
     thread_t thread,
     task_t task,
     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_request) {
   return interface_->CatchMachException(
       EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES,
       exception_port,
       thread,
       task,
       exception,
       code,
       code_count,
       flavor,
       old_state,
       old_state_count,
       new_state,
       new_state_count,
+      trailer,
       destroy_request);
 }
 
 }  // namespace internal
 
 UniversalMachExcServer::UniversalMachExcServer()
     : MachMessageServer::Interface(),
       internal::SimplifiedExcServer::Interface(),
       internal::SimplifiedMachExcServer::Interface(),
       exc_server_(this),
@@ skipping 40 matching lines @@
     thread_t thread,
     task_t task,
     exception_type_t exception,
     const 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) {
   std::vector<mach_exception_data_type_t> mach_codes;
   mach_codes.reserve(code_count);
   for (size_t index = 0; index < code_count; ++index) {
     mach_codes.push_back(code[index]);
   }
 
   return CatchMachException(behavior,
                             exception_port,
                             thread,
                             task,
                             exception,
                             code_count ? &mach_codes[0] : nullptr,
                             code_count,
                             flavor,
                             old_state,
                             old_state_count,
                             new_state,
                             new_state_count,
+                            trailer,
                             destroy_complex_request);
 }
 
 exception_type_t ExcCrashRecoverOriginalException(
     mach_exception_code_t code_0,
     mach_exception_code_t* original_code_0,
     int* signal) {
   // 10.9.4 xnu-2422.110.17/bsd/kern/kern_exit.c proc_prepareexit() sets code[0]
   // based on the signal value, original exception type, and low 20 bits of the
   // original code[0] before calling xnu-2422.110.17/osfmk/kern/exception.c
@@ skipping 20 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