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

handler/mac/exception_handler_server.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 "handler/mac/exception_handler_server.h"
 
 #include "base/logging.h"
 #include "base/mac/mach_logging.h"
 #include "util/mach/composite_mach_message_server.h"
 #include "util/mach/mach_extensions.h"
 #include "util/mach/mach_message.h"
 #include "util/mach/mach_message_server.h"
 #include "util/mach/notify_server.h"
 
 namespace crashpad {
 
 namespace {
 
-class ExceptionHandlerServerRun
-    : public UniversalMachExcServer::Interface,
-      public NotifyServer::Interface {
+class ExceptionHandlerServerRun : public UniversalMachExcServer::Interface,
+                                  public NotifyServer::Interface {
  public:
   ExceptionHandlerServerRun(
       mach_port_t exception_port,
       UniversalMachExcServer::Interface* exception_interface)
       : UniversalMachExcServer::Interface(),
         NotifyServer::Interface(),
         mach_exc_server_(this),
         notify_server_(this),
         composite_mach_message_server_(),
         exception_interface_(exception_interface),
@@ skipping 48 matching lines @@
     kr = mach_port_insert_member(
         mach_task_self(), notify_port_, server_port_set);
     MACH_CHECK(kr == KERN_SUCCESS, kr) << "mach_port_insert_member";
 
     // Run the server in kOneShot mode so that running_ can be reevaluated after
     // each message. Receipt of a valid no-senders notification causes it to be
     // set to false.
     while (running_) {
       // This will result in a call to CatchMachException() or
       // DoMachNotifyNoSenders() as appropriate.
-      mach_msg_return_t mr =
-          MachMessageServer::Run(&composite_mach_message_server_,
-                                 server_port_set,
-                                 MACH_MSG_OPTION_NONE,
-                                 MachMessageServer::kOneShot,
-                                 MachMessageServer::kReceiveLargeIgnore,
-                                 kMachMessageTimeoutWaitIndefinitely);
+      mach_msg_return_t mr = MachMessageServer::Run(
+          &composite_mach_message_server_,
+          server_port_set,
+          MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0) |
+              MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_AUDIT),
+          MachMessageServer::kOneShot,
+          MachMessageServer::kReceiveLargeIgnore,
+          kMachMessageTimeoutWaitIndefinitely);
       MACH_CHECK(mr == MACH_MSG_SUCCESS, mr) << "MachMessageServer::Run";
     }
   }
 
   // UniversalMachExcServer::Interface:
 
   kern_return_t CatchMachException(exception_behavior_t behavior,
                                    exception_handler_t exception_port,
                                    thread_t thread,
                                    task_t task,
@@ skipping 24 matching lines @@
                                                     old_state_count,
                                                     new_state,
                                                     new_state_count,
                                                     trailer,
                                                     destroy_complex_request);
   }
 
   // NotifyServer::Interface:
 
   kern_return_t DoMachNotifyPortDeleted(
-        notify_port_t notify,
-        mach_port_name_t name,
-        const mach_msg_trailer_t* trailer) override {
+      notify_port_t notify,
+      mach_port_name_t name,
+      const mach_msg_trailer_t* trailer) override {
     return UnimplementedNotifyRoutine(notify);
   }
 
   kern_return_t DoMachNotifyPortDestroyed(notify_port_t notify,
                                           mach_port_t rights,
                                           const mach_msg_trailer_t* trailer,
                                           bool* destroy_request) override {
     *destroy_request = true;
     return UnimplementedNotifyRoutine(notify);
   }
@@ skipping 64 matching lines @@
 ExceptionHandlerServer::~ExceptionHandlerServer() {
 }
 
 void ExceptionHandlerServer::Run(
     UniversalMachExcServer::Interface* exception_interface) {
   ExceptionHandlerServerRun run(receive_port_, exception_interface);
   run.Run();
 }
 
 }  // namespace crashpad