Pass Mach message trailers to server handler functions

util/mach/exc_server_variants_test.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 <mach/mach.h>
 #include <signal.h>
 #include <string.h>
 
 #include "base/strings/stringprintf.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "util/mach/exception_behaviors.h"
 #include "util/mach/mach_extensions.h"
+#include "util/mach/mach_message_util.h"
 #include "util/test/mac/mach_errors.h"
 #include "util/test/mac/mach_multiprocess.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 using testing::DefaultValue;
 using testing::Eq;
 using testing::Pointee;
@@ skipping 39 matching lines @@
 // of the structures from both exc.h and mach_exc.h here in this file, and
 // provide the initialization and verification code as methods in true
 // object-oriented fashion.
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseRequest {
   ExceptionRaiseRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
-    Head.msgh_size = sizeof(*this);
+    Head.msgh_size = sizeof(*this) - sizeof(trailer);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2401;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestExceptonCodes[0];
     code[1] = kTestExceptonCodes[1];
   }
 
   mach_msg_header_t Head;
   mach_msg_body_t msgh_body;
   mach_msg_port_descriptor_t thread;
   mach_msg_port_descriptor_t task;
   NDR_record_t NDR;
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   integer_t code[2];
+  mach_msg_trailer_t trailer;
 };
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseReply {
   ExceptionRaiseReply() {
     memset(this, 0x5a, sizeof(*this));
     RetCode = KERN_FAILURE;
   }
 
   // Verify accepts a |behavior| parameter because the same message format and
   // verification function is used for ExceptionRaiseReply and
@@ skipping 25 matching lines @@
   mach_msg_header_t Head;
   NDR_record_t NDR;
   kern_return_t RetCode;
 };
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseStateRequest {
   ExceptionRaiseStateRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND);
-    Head.msgh_size = sizeof(*this);
+    Head.msgh_size = sizeof(*this) - sizeof(trailer);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2402;
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestExceptonCodes[0];
     code[1] = kTestExceptonCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
 
+  // Because the message size has been adjusted, the trailer may not appear in
+  // its home member variable. This computes the actual address of the trailer.
+  const mach_msg_trailer_t* Trailer() const {
+    return MachMessageTrailerFromHeader(&Head);
+  }
+
   mach_msg_header_t Head;
   NDR_record_t NDR;
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   integer_t code[2];
   int flavor;
   mach_msg_type_number_t old_stateCnt;
   natural_t old_state[THREAD_STATE_MAX];
+  mach_msg_trailer_t trailer;
 };
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseStateReply {
   ExceptionRaiseStateReply() {
     memset(this, 0x5a, sizeof(*this));
     RetCode = KERN_FAILURE;
   }
 
   // Verify accepts a |behavior| parameter because the same message format and
   // verification function is used for ExceptionRaiseStateReply,
@@ skipping 38 matching lines @@
   mach_msg_type_number_t new_stateCnt;
   natural_t new_state[THREAD_STATE_MAX];
 };
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseStateIdentityRequest {
   ExceptionRaiseStateIdentityRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
-    Head.msgh_size = sizeof(*this);
+    Head.msgh_size = sizeof(*this) - sizeof(trailer);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2403;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestExceptonCodes[0];
     code[1] = kTestExceptonCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
 
+  // Because the message size has been adjusted, the trailer may not appear in
+  // its home member variable. This computes the actual address of the trailer.
+  const mach_msg_trailer_t* Trailer() const {
+    return MachMessageTrailerFromHeader(&Head);
+  }
+
   mach_msg_header_t Head;
   mach_msg_body_t msgh_body;
   mach_msg_port_descriptor_t thread;
   mach_msg_port_descriptor_t task;
   NDR_record_t NDR;
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   integer_t code[2];
   int flavor;
   mach_msg_type_number_t old_stateCnt;
   natural_t old_state[THREAD_STATE_MAX];
+  mach_msg_trailer_t trailer;
 };
 
 // The reply messages for exception_raise_state and
 // exception_raise_state_identity are identical.
 using ExceptionRaiseStateIdentityReply = ExceptionRaiseStateReply;
 
 struct __attribute__((packed, aligned(4))) MachExceptionRaiseRequest {
   MachExceptionRaiseRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
-    Head.msgh_size = sizeof(*this);
+    Head.msgh_size = sizeof(*this) - sizeof(trailer);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2405;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestMachExceptionCodes[0];
     code[1] = kTestMachExceptionCodes[1];
   }
 
   mach_msg_header_t Head;
   mach_msg_body_t msgh_body;
   mach_msg_port_descriptor_t thread;
   mach_msg_port_descriptor_t task;
   NDR_record_t NDR;
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   int64_t code[2];
+  mach_msg_trailer_t trailer;
 };
 
 // The reply messages for exception_raise and mach_exception_raise are
 // identical.
 using MachExceptionRaiseReply = ExceptionRaiseReply;
 
 struct __attribute__((packed, aligned(4))) MachExceptionRaiseStateRequest {
   MachExceptionRaiseStateRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND);
-    Head.msgh_size = sizeof(*this);
+    Head.msgh_size = sizeof(*this) - sizeof(trailer);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2406;
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestMachExceptionCodes[0];
     code[1] = kTestMachExceptionCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
 
+  // Because the message size has been adjusted, the trailer may not appear in
+  // its home member variable. This computes the actual address of the trailer.
+  const mach_msg_trailer_t* Trailer() const {
+    return MachMessageTrailerFromHeader(&Head);
+  }
+
   mach_msg_header_t Head;
   NDR_record_t NDR;
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   int64_t code[2];
   int flavor;
   mach_msg_type_number_t old_stateCnt;
   natural_t old_state[THREAD_STATE_MAX];
+  mach_msg_trailer_t trailer;
 };
 
 // The reply messages for exception_raise_state and mach_exception_raise_state
 // are identical.
 using MachExceptionRaiseStateReply = ExceptionRaiseStateReply;
 
 struct __attribute__((packed,
                       aligned(4))) MachExceptionRaiseStateIdentityRequest {
   MachExceptionRaiseStateIdentityRequest() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
-    Head.msgh_size = sizeof(*this);
+    Head.msgh_size = sizeof(*this) - sizeof(trailer);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2407;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestMachExceptionCodes[0];
     code[1] = kTestMachExceptionCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
 
+  // Because the message size has been adjusted, the trailer may not appear in
+  // its home member variable. This computes the actual address of the trailer.
+  const mach_msg_trailer_t* Trailer() const {
+    return MachMessageTrailerFromHeader(&Head);
+  }
+
   mach_msg_header_t Head;
   mach_msg_body_t msgh_body;
   mach_msg_port_descriptor_t thread;
   mach_msg_port_descriptor_t task;
   NDR_record_t NDR;
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   int64_t code[2];
   int flavor;
   mach_msg_type_number_t old_stateCnt;
   natural_t old_state[THREAD_STATE_MAX];
+  mach_msg_trailer_t trailer;
 };
 
 // The reply messages for exception_raise_state_identity and
 // mach_exception_raise_state_identity are identical.
 using MachExceptionRaiseStateIdentityReply = ExceptionRaiseStateIdentityReply;
 
 // InvalidRequest and BadIDErrorReply are used to test that
 // UniversalMachExcServer deals appropriately with messages that it does not
 // understand: messages with an unknown Head.msgh_id.
 
@@ skipping 52 matching lines @@
       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_complex_request) override {
     *destroy_complex_request = true;
     const ConstExceptionCodes exception_codes = {code, code_count};
     const ConstThreadState old_thread_state = {old_state, &old_state_count};
     ThreadState new_thread_state = {new_state, new_state_count};
     return MockCatchMachException(behavior,
                                   exception_port,
                                   thread,
                                   task,
                                   exception,
                                   &exception_codes,
                                   flavor,
                                   &old_thread_state,
-                                  &new_thread_state);
+                                  &new_thread_state,
+                                  trailer);
   }
 
-  MOCK_METHOD9(MockCatchMachException,
-               kern_return_t(exception_behavior_t behavior,
-                             exception_handler_t exception_port,
-                             thread_t thread,
-                             task_t task,
-                             exception_type_t exception,
-                             const ConstExceptionCodes* exception_codes,
-                             thread_state_flavor_t* flavor,
-                             const ConstThreadState* old_thread_state,
-                             ThreadState* new_thread_state));
+  MOCK_METHOD10(MockCatchMachException,
+                kern_return_t(exception_behavior_t behavior,
+                              exception_handler_t exception_port,
+                              thread_t thread,
+                              task_t task,
+                              exception_type_t exception,
+                              const ConstExceptionCodes* exception_codes,
+                              thread_state_flavor_t* flavor,
+                              const ConstThreadState* old_thread_state,
+                              ThreadState* new_thread_state,
+                              const mach_msg_trailer_t* trailer));
 };
 
 // Matcher for ConstExceptionCodes, testing that it carries 2 codes matching
 // code_0 and code_1.
 MATCHER_P2(AreExceptionCodes, code_0, code_1, "") {
   if (!arg) {
     return false;
   }
 
   if (arg->code_count == 2 && arg->code[0] == code_0 &&
@@ skipping 53 matching lines @@
 
   ~ScopedDefaultValue() { DefaultValue<T>::Clear(); }
 };
 
 TEST(ExcServerVariants, MockExceptionRaise) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   ExceptionRaiseRequest request;
-  EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
 
   ExceptionRaiseReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_DEFAULT;
 
   EXPECT_CALL(server,
               MockCatchMachException(kExceptionBehavior,
                                      kServerLocalPort,
                                      kExceptionThreadPort,
                                      kExceptionTaskPort,
                                      kExceptionType,
                                      AreExceptionCodes(kTestExceptonCodes[0],
                                                        kTestExceptonCodes[1]),
                                      Pointee(Eq(THREAD_STATE_NONE)),
                                      IsThreadStateCount(0u),
-                                     IsThreadStateCount(0u)))
+                                     IsThreadStateCount(0u),
+                                     Eq(&request.trailer)))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockExceptionRaiseState) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   ExceptionRaiseStateRequest request;
-  EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
 
   ExceptionRaiseStateReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(
           kExceptionBehavior,
           kServerLocalPort,
           THREAD_NULL,
           TASK_NULL,
           kExceptionType,
           AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
           Pointee(Eq(kThreadStateFlavor)),
           IsThreadStateCount(kThreadStateFlavorCount),
-          IsThreadStateCount(arraysize(reply.new_state))))
+          IsThreadStateCount(arraysize(reply.new_state)),
+          Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
 
   // The request wasn’t complex, so nothing got a chance to change the value of
   // this variable.
   EXPECT_FALSE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockExceptionRaiseStateIdentity) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   ExceptionRaiseStateIdentityRequest request;
-  EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
 
   ExceptionRaiseStateIdentityReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE_IDENTITY;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(
           kExceptionBehavior,
           kServerLocalPort,
           kExceptionThreadPort,
           kExceptionTaskPort,
           kExceptionType,
           AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
           Pointee(Eq(kThreadStateFlavor)),
           IsThreadStateCount(kThreadStateFlavorCount),
-          IsThreadStateCount(arraysize(reply.new_state))))
+          IsThreadStateCount(arraysize(reply.new_state)),
+          Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaise) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   MachExceptionRaiseRequest request;
-  EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
 
   MachExceptionRaiseReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              kExceptionThreadPort,
                              kExceptionTaskPort,
                              kExceptionType,
                              AreExceptionCodes(kTestMachExceptionCodes[0],
                                                kTestMachExceptionCodes[1]),
                              Pointee(Eq(THREAD_STATE_NONE)),
                              IsThreadStateCount(0u),
-                             IsThreadStateCount(0u)))
+                             IsThreadStateCount(0u),
+                             Eq(&request.trailer)))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaiseState) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   MachExceptionRaiseStateRequest request;
-  EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
 
   MachExceptionRaiseStateReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_STATE | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              THREAD_NULL,
                              TASK_NULL,
                              kExceptionType,
                              AreExceptionCodes(kTestMachExceptionCodes[0],
                                                kTestMachExceptionCodes[1]),
                              Pointee(Eq(kThreadStateFlavor)),
                              IsThreadStateCount(kThreadStateFlavorCount),
-                             IsThreadStateCount(arraysize(reply.new_state))))
+                             IsThreadStateCount(arraysize(reply.new_state)),
+                             Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
 
   // The request wasn’t complex, so nothing got a chance to change the value of
   // this variable.
   EXPECT_FALSE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaiseStateIdentity) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
 
   MachExceptionRaiseStateIdentityRequest request;
-  EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
 
   MachExceptionRaiseStateIdentityReply reply;
   EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              kExceptionThreadPort,
                              kExceptionTaskPort,
                              kExceptionType,
                              AreExceptionCodes(kTestMachExceptionCodes[0],
                                                kTestMachExceptionCodes[1]),
                              Pointee(Eq(kThreadStateFlavor)),
                              IsThreadStateCount(kThreadStateFlavorCount),
-                             IsThreadStateCount(arraysize(reply.new_state))))
+                             IsThreadStateCount(arraysize(reply.new_state)),
+                             Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
@@ skipping 86 matching lines @@
       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_complex_request) override {
     *destroy_complex_request = true;
 
     EXPECT_FALSE(handled_);
     handled_ = true;
 
     EXPECT_EQ(behavior_, behavior);
 
     EXPECT_EQ(LocalPort(), exception_port);
 
@@ skipping 26 matching lines @@
                 *new_state_count);
       EXPECT_NE(nullptr, new_state);
     } else {
       EXPECT_EQ(THREAD_STATE_NONE, *flavor);
       EXPECT_EQ(0u, old_state_count);
       EXPECT_EQ(nullptr, old_state);
       EXPECT_EQ(0u, *new_state_count);
       EXPECT_EQ(nullptr, new_state);
     }
 
+    EXPECT_EQ(implicit_cast<mach_msg_trailer_type_t>(MACH_MSG_TRAILER_FORMAT_0),
+              trailer->msgh_trailer_type);
+    EXPECT_EQ(REQUESTED_TRAILER_SIZE(kMachMessageOptions),
+              trailer->msgh_trailer_size);
+
     return ExcServerSuccessfulReturnValue(behavior, false);
   }
 
  private:
   // MachMultiprocess:
 
   void MachMultiprocessParent() override {
     kern_return_t kr =
         MachMessageServer::Run(this,
                                LocalPort(),
-                               MACH_MSG_OPTION_NONE,
+                               kMachMessageOptions,
                                MachMessageServer::kOneShot,
                                MachMessageServer::kBlocking,
                                MachMessageServer::kReceiveLargeError,
                                0);
     EXPECT_EQ(KERN_SUCCESS, kr)
         << MachErrorMessage(kr, "MachMessageServer::Run");
 
     EXPECT_TRUE(handled_);
   }
 
   void MachMultiprocessChild() override {
     // Set the parent as the exception handler for EXC_CRASH.
     kern_return_t kr = task_set_exception_ports(
         mach_task_self(), EXC_MASK_CRASH, RemotePort(), behavior_, flavor_);
     ASSERT_EQ(KERN_SUCCESS, kr)
         << MachErrorMessage(kr, "task_set_exception_ports");
 
     // Now crash.
     __builtin_trap();
   }
 
   exception_behavior_t behavior_;
   thread_state_flavor_t flavor_;
   mach_msg_type_number_t state_count_;
   bool handled_;
 
+  static const mach_msg_option_t kMachMessageOptions =
+      MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0);
+
   DISALLOW_COPY_AND_ASSIGN(TestExcServerVariants);
 };
 
 TEST(ExcServerVariants, ExceptionRaise) {
   TestExcServerVariants test_exc_server_variants(
       EXCEPTION_DEFAULT, THREAD_STATE_NONE, 0);
   test_exc_server_variants.Run();
 }
 
 TEST(ExcServerVariants, ExceptionRaiseState) {
@@ skipping 185 matching lines @@
 
     EXPECT_EQ(test_data.kr,
               ExcServerSuccessfulReturnValue(test_data.behavior,
                                              test_data.set_thread_state));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad