handler/mac: Log a warning when an exception message has a suspicious

util/test/mac/mach_multiprocess.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 10 matching lines @@
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/mac/scoped_mach_port.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "gtest/gtest.h"
 #include "util/file/file_io.h"
 #include "util/mach/mach_extensions.h"
+#include "util/mach/mach_message.h"
 #include "util/misc/scoped_forbid_return.h"
 #include "util/test/errors.h"
 #include "util/test/mac/mach_errors.h"
 
 namespace {
 
 // The “hello” message contains a send right to the child process’ task port.
 struct SendHelloMessage : public mach_msg_base_t {
   mach_msg_port_descriptor_t port_descriptor;
 };
 
 struct ReceiveHelloMessage : public SendHelloMessage {
-  mach_msg_audit_trailer_t audit_trailer;
+  union {
+    mach_msg_trailer_t trailer;
+    mach_msg_audit_trailer_t audit_trailer;
+  };
 };
 
 }  // namespace
 
 namespace crashpad {
 namespace test {
 
 namespace internal {
 
 struct MachMultiprocessInfo {
@@ skipping 59 matching lines @@
 }
 
 task_t MachMultiprocess::ChildTask() const {
   EXPECT_NE(TASK_NULL, info_->child_task);
   return info_->child_task;
 }
 
 void MachMultiprocess::MultiprocessParent() {
   ReceiveHelloMessage message = {};
 
-  kern_return_t kr =
-      mach_msg(&message.header,
-               MACH_RCV_MSG | MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0) |
-                   MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_AUDIT),
-               0,
-               sizeof(message),
-               info_->local_port,
-               MACH_MSG_TIMEOUT_NONE,
-               MACH_PORT_NULL);
+  kern_return_t kr = mach_msg(&message.header,
+                              MACH_RCV_MSG | kMachMessageReceiveAuditTrailer,
+                              0,
+                              sizeof(message),
+                              info_->local_port,
+                              MACH_MSG_TIMEOUT_NONE,
+                              MACH_PORT_NULL);
   ASSERT_EQ(MACH_MSG_SUCCESS, kr) << MachErrorMessage(kr, "mach_msg");
 
   // Comb through the entire message, checking every field against its expected
   // value.
   EXPECT_EQ(MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND, MACH_MSG_TYPE_MOVE_SEND) |
                 MACH_MSGH_BITS_COMPLEX,
             message.header.msgh_bits);
   ASSERT_EQ(sizeof(SendHelloMessage), message.header.msgh_size);
   EXPECT_EQ(info_->local_port, message.header.msgh_local_port);
   ASSERT_EQ(1u, message.body.msgh_descriptor_count);
@@ skipping 37 matching lines @@
   gid_t audit_rgid = audit_token_to_rgid(message.audit_trailer.msgh_audit);
   pid_t audit_pid = audit_token_to_pid(message.audit_trailer.msgh_audit);
   au_asid_t audit_asid = audit_token_to_asid(message.audit_trailer.msgh_audit);
 #endif
   EXPECT_EQ(geteuid(), audit_euid);
   EXPECT_EQ(getegid(), audit_egid);
   EXPECT_EQ(getuid(), audit_ruid);
   EXPECT_EQ(getgid(), audit_rgid);
   ASSERT_EQ(ChildPID(), audit_pid);
 
+  ASSERT_EQ(ChildPID(), AuditPIDFromMachMessageTrailer(&message.trailer));
+
   auditinfo_addr_t audit_info;
   int rv = getaudit_addr(&audit_info, sizeof(audit_info));
   ASSERT_EQ(0, rv) << ErrnoMessage("getaudit_addr");
   EXPECT_EQ(audit_info.ai_auid, audit_auid);
   EXPECT_EQ(audit_info.ai_asid, audit_asid);
 
   // Retrieve the remote port from the message header, and the child’s task port
   // from the message body.
   info_->remote_port.reset(message.header.msgh_remote_port);
   info_->child_task.reset(message.port_descriptor.name);
@@ skipping 68 matching lines @@
   if (testing::Test::HasFailure()) {
     // Trigger the ScopedForbidReturn destructor.
     return;
   }
 
   forbid_return.Disarm();
 }
 
 }  // namespace test
 }  // namespace crashpad