Add a ReceiveLarge parameter to MachMessageServer::Run()

util/mach/mach_message_server_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,
@@ skipping 40 matching lines @@
       // MACH_SEND_INVALID_DEST, and the client will not expect a reply.
       kReplyPortDead,
     };
 
     Options()
         : expect_server_interface_method_called(true),
           parent_wait_for_child_pipe(false),
           server_options(MACH_MSG_OPTION_NONE),
           server_persistent(MachMessageServer::kOneShot),
           server_nonblocking(MachMessageServer::kBlocking),
+          server_receive_large(MachMessageServer::kReceiveLargeError),
           server_timeout_ms(MACH_MSG_TIMEOUT_NONE),
           server_mig_retcode(KERN_SUCCESS),
           server_destroy_complex(true),
           expect_server_destroyed_complex(true),
           expect_server_result(KERN_SUCCESS),
           expect_server_transaction_count(1),
           child_wait_for_parent_pipe_early(false),
           client_send_request_count(1),
           client_send_complex(false),
           client_send_large(false),
@@ skipping 15 matching lines @@
 
     // Options to pass to MachMessageServer::Run() as the |options| parameter.
     mach_msg_options_t server_options;
 
     // Whether the server should run in one-shot or persistent mode.
     MachMessageServer::Persistent server_persistent;
 
     // Whether the server should run in blocking or nonblocking mode.
     MachMessageServer::Nonblocking server_nonblocking;
 
+    // The strategy for handling large messages.
+    MachMessageServer::ReceiveLarge server_receive_large;
+
     // The server’s timeout.
     mach_msg_timeout_t server_timeout_ms;
 
     // The return code that the server returns to the client via the
     // mig_reply_error_t::RetCode field. A client would normally see this as
     // a Mach RPC return value.
     kern_return_t server_mig_retcode;
 
     // The value that the server function should set its destroy_complex_request
     // parameter to. This is true if resources sent in complex request messages
@@ skipping 21 matching lines @@
     bool child_wait_for_parent_pipe_early;
 
     // The number of requests that the client should send to the server.
     size_t client_send_request_count;
 
     // true if the client should send a complex message, one that carries a port
     // descriptor in its body. Normally false.
     bool client_send_complex;
 
     // true if the client should send a larger message than the server has
-    // allocated space to receive. If server_options contains MACH_RCV_LARGE,
-    // the server will resize its buffer to receive the message. Otherwise, the
-    // message will be destroyed and the server will return MACH_RCV_TOO_LARGE.
+    // allocated space to receive. The server’s response is directed by
+    // server_receive_large.
     bool client_send_large;
 
     // The type of reply port that the client should provide in its request’s
     // mach_msg_header_t::msgh_local_port, which will appear to the server as
     // mach_msg_header_t::msgh_remote_port.
     ReplyPortType client_reply_port_type;
 
     // true if the client should wait for a reply from the server. For
     // non-normal reply ports or requests which the server responds to with no
     // reply (MIG_NO_REPLY), the server will either not send a reply or not
@@ skipping 185 matching lines @@
       CheckedReadFD(ReadPipeFD(), &c, 1);
       EXPECT_EQ('\0', c);
     }
 
     ASSERT_EQ(options_.expect_server_result,
               (kr = MachMessageServer::Run(this,
                                            local_port,
                                            options_.server_options,
                                            options_.server_persistent,
                                            options_.server_nonblocking,
+                                           options_.server_receive_large,
                                            options_.server_timeout_ms)))
         << MachErrorMessage(kr, "MachMessageServer");
 
     if (options_.client_send_complex) {
       EXPECT_NE(kMachPortNull, parent_complex_message_port_);
       mach_port_type_t type;
 
       if (!options_.expect_server_destroyed_complex) {
         // MachMessageServer should not have destroyed the resources sent in the
         // complex request message.
@@ skipping 440 matching lines @@
   options.server_mig_retcode = MIG_NO_REPLY;
   options.server_destroy_complex = false;
   options.expect_server_destroyed_complex = false;
   options.client_send_complex = true;
   options.client_expect_reply = false;
   options.child_wait_for_parent_pipe_late = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
-TEST(MachMessageServer, LargeUnexpected) {
+TEST(MachMessageServer, ReceiveLargeError) {
   // The client sends a request to the server that is larger than the server is
-  // expecting. The server did not specify MACH_RCV_LARGE in its options, so the
-  // request is destroyed and the server returns a MACH_RCV_TOO_LARGE error. The
-  // client does not receive a reply.
+  // expecting. server_receive_large is kReceiveLargeError, so the request is
+  // destroyed and the server returns a MACH_RCV_TOO_LARGE error. The client
+  // does not receive a reply.
   TestMachMessageServer::Options options;
   options.expect_server_result = MACH_RCV_TOO_LARGE;
   options.expect_server_transaction_count = 0;
   options.client_send_large = true;
   options.client_expect_reply = false;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
-TEST(MachMessageServer, LargeExpected) {
+TEST(MachMessageServer, ReceiveLargeRetry) {
   // The client sends a request to the server that is larger than the server is
-  // initially expecting. The server did specify MACH_RCV_LARGE in its options,
-  // so a new buffer is allocated to receive the message. The server receives
-  // the large request message, processes it, and returns a reply to the client.
+  // initially expecting. server_receive_large is kReceiveLargeResize, so a new
+  // buffer is allocated to receive the message. The server receives the large
+  // request message, processes it, and returns a reply to the client.
   TestMachMessageServer::Options options;
-  options.server_options = MACH_RCV_LARGE;
+  options.server_receive_large = MachMessageServer::kReceiveLargeResize;
   options.client_send_large = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
+
+TEST(MachMessageServer, ReceiveLargeIgnore) {
+  // The client sends a request to the server that is larger than the server is
+  // expecting. server_receive_large is kReceiveLargeIgnore, so the request is
+  // destroyed but the server does not consider this an error. The server is
+  // running in blocking mode with a timeout, and continues to wait for a
+  // message until it times out. The client does not receive a reply.
+  TestMachMessageServer::Options options;
+  options.server_receive_large = MachMessageServer::kReceiveLargeIgnore;
+  options.server_timeout_ms = 10;
+  options.expect_server_result = MACH_RCV_TIMED_OUT;
+  options.expect_server_transaction_count = 0;
+  options.client_send_large = true;
+  options.client_expect_reply = false;
+  TestMachMessageServer test_mach_message_server(options);
+  test_mach_message_server.Test();
+}
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad