Add a ReceiveLarge parameter to MachMessageServer::Run()

util/mach/mach_message_server.h

 // 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 85 matching lines @@
   //! \brief Informs Run() whether or not to block while waiting for requests.
   enum Nonblocking {
     //! \brief Wait for a request message if none is queued.
     kBlocking = false,
 
     //! \brief Return as soon as there no request messages queued. This may
     //!     result in an immediate return without handling any requests.
     kNonblocking,
   };
 
+  //! \brief Determines how to handle the reception of messages larger than the
+  //!     size of the buffer allocated to store them.
+  enum ReceiveLarge {
+    //! \brief Return `MACH_RCV_TOO_LARGE` upon receipt of a large message.
+    //!
+    //! This mimics the default behavior of `mach_msg_server()` when `options`
+    //! does not contain `MACH_RCV_LARGE`.
+    kReceiveLargeError = 0,
+
+    //! \brief Ignore large messages, and attempt to receive the next queued
+    //!     message upon encountering one.
+    //!
+    //! When a large message is encountered, a warning will be logged.
+    //!
+    //! `mach_msg()` will be called to receive the next message after a large
+    //! one even when accompanied by a #Persistent value of #kOneShot.
+    kReceiveLargeIgnore,
+
+    //! \brief Allocate an appropriately-sized buffer upon encountering a large
+    //!     message. The buffer will be used to receive the message. This
+    //!
+    //! This mimics the behavior of `mach_msg_server()` when `options` contains
+    //! `MACH_RCV_LARGE`.
+    kReceiveLargeResize,
+  };
+
   //! \brief Runs a Mach message server to handle a Mach RPC request for MIG
   //!     servers.
   //!
   //! This function listens for a request message and passes it to a callback
   //! interface. A reponse is collected from that interface, and is sent back as
   //! a reply.
   //!
   //! This function is similar to `mach_msg_server()` and
   //! `mach_msg_server_once()`.
   //!
   //! \param[in] interface The MachMessageServerInterface that is responsible
   //!     for handling the message. Interface::MachMessageServerRequestSize() is
   //!     used as the receive size for the request message, and
   //!     Interface::MachMessageServerReplySize() is used as the
   //!     maximum size of the reply message. If \a options contains
   //!     `MACH_RCV_LARGE`, this function will retry a receive operation that
   //!     returns `MACH_RCV_TOO_LARGE` with an appropriately-sized buffer.
   //!     MachMessageServerInterface::MachMessageServerFunction() is called to
   //!     handle the request and populate the reply.
   //! \param[in] receive_port The port on which to receive the request message.
   //! \param[in] options Options suitable for mach_msg. For the defaults, use
-  //!     `MACH_MSG_OPTION_NONE`.
+  //!     `MACH_MSG_OPTION_NONE`. `MACH_RCV_LARGE` when specified here is
+  //!     ignored. Set \a receive_large to #kReceiveLargeResize instead.
   //! \param[in] persistent Chooses between one-shot and persistent operation.
   //! \param[in] nonblocking Chooses between blocking and nonblocking operation.
+  //! \param[in] receive_large Determines the behavior upon encountering a
+  //!     message larger than the receive buffer’s size.
   //! \param[in] timeout_ms When \a nonblocking is `false`, the the maximum
   //!     duration that this entire function will run, in milliseconds, or
   //!     `MACH_MSG_TIMEOUT_NONE` to specify no timeout (infinite waiting). When
   //!     \a nonblocking is `true`, this parameter has no effect. When \a
   //!     persistent is `true`, the timeout applies to the overall duration of
   //!     this function, not to any individual `mach_msg()` call.
   //!
   //! \return On success, `KERN_SUCCESS` (when \a persistent is `false`) or
   //!     `MACH_RCV_TIMED_OUT` (when \a persistent and \a nonblocking are both
   //!     `true`, or when \a persistent is `true`, \a nonblocking is `false`,
   //!     and \a timeout is not `MACH_MSG_TIMEOUT_NONE`. This function has no
   //!     successful return value when \a persistent is `true`, \a nonblocking
   //!     is `false`, and \a timeout is `MACH_MSG_TIMEOUT_NONE`. On failure,
   //!     returns a value identifying the nature of the error.
   static mach_msg_return_t Run(Interface* interface,
                                mach_port_t receive_port,
                                mach_msg_options_t options,
                                Persistent persistent,
                                Nonblocking nonblocking,
+                               ReceiveLarge receive_large,
                                mach_msg_timeout_t timeout_ms);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(MachMessageServer);
 };
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_UTIL_MACH_MACH_MESSAGE_SERVER_H_