Enhance the MachMessageServer test to cover large messages (MACH_RCV_LARGE)

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 38 matching lines @@
       // Make the server see the reply port as a dead name by setting the reply
       // port to a receive right and then destroying that right before the
       // server processes the request. The server should return
       // 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_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),
           client_send_request_count(1),
           client_send_complex(false),
+          client_send_large(false),
           client_reply_port_type(kReplyPortNormal),
           client_expect_reply(true),
           child_send_all_requests_before_receiving_any_replies(false),
           child_wait_for_parent_pipe(false) {
     }
 
     // true if MachMessageServerFunction() is expected to be called.
     bool expect_server_interface_method_called;
 
     // true if the parent should wait for the child to write a byte to the pipe
     // as a signal that the child is ready for the parent to begin its side of
     // the test. This is used for nonblocking tests, which require that there
     // be something in the server’s queue before attempting a nonblocking
     // receive if the receive is to be successful.
     bool parent_wait_for_child_pipe;
 
+    // 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 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
     // should be destroyed, and false if they should not be destroyed, assuming
     // that the server function indicates success.
     bool server_destroy_complex;
 
     // Whether to expect the server to destroy a complex message. Even if
     // server_destroy_complex is false, a complex message will be destroyed if
     // the MIG return code was unsuccessful.
     bool expect_server_destroyed_complex;
 
     // The expected return value from MachMessageServer::Run().
     kern_return_t expect_server_result;
 
+    // The number of transactions that the server is expected to handle.
+    size_t expect_server_transaction_count;
+
     // 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.
+    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
     // succeed in sending a reply, and the child process should not wait for
     // one.
@@ skipping 23 matching lines @@
   }
 
   // Runs the test.
   void Test() {
     EXPECT_EQ(requests_, replies_);
     uint32_t start = requests_;
 
     Run();
 
     EXPECT_EQ(requests_, replies_);
-    EXPECT_EQ(options_.client_send_request_count, requests_ - start);
+    EXPECT_EQ(options_.expect_server_transaction_count, requests_ - start);
   }
 
   // MachMessageServerInterface:
 
   virtual bool MachMessageServerFunction(
       mach_msg_header_t* in,
       mach_msg_header_t* out,
       bool* destroy_complex_request) override {
     *destroy_complex_request = options_.server_destroy_complex;
 
     EXPECT_TRUE(options_.expect_server_interface_method_called);
     if (!options_.expect_server_interface_method_called) {
       return false;
     }
 
     struct ReceiveRequestMessage : public RequestMessage {
       mach_msg_trailer_t trailer;
     };
 
+    struct ReceiveLargeRequestMessage : public LargeRequestMessage {
+      mach_msg_trailer_t trailer;
+    };
+
     const ReceiveRequestMessage* request =
         reinterpret_cast<ReceiveRequestMessage*>(in);
     const mach_msg_bits_t expect_msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND, MACH_MSG_TYPE_MOVE_SEND) |
         (options_.client_send_complex ? MACH_MSGH_BITS_COMPLEX : 0);
     EXPECT_EQ(expect_msgh_bits, request->header.msgh_bits);
-    EXPECT_EQ(sizeof(RequestMessage), request->header.msgh_size);
+    EXPECT_EQ(options_.client_send_large ? sizeof(LargeRequestMessage) :
+                                           sizeof(RequestMessage),
+              request->header.msgh_size);
     if (options_.client_reply_port_type == Options::kReplyPortNormal) {
       EXPECT_EQ(RemotePort(), request->header.msgh_remote_port);
     }
     EXPECT_EQ(LocalPort(), request->header.msgh_local_port);
     EXPECT_EQ(kRequestMessageId, request->header.msgh_id);
     if (options_.client_send_complex) {
       EXPECT_EQ(1u, request->body.msgh_descriptor_count);
       EXPECT_NE(static_cast<mach_port_t>(MACH_PORT_NULL),
                 request->port_descriptor.name);
       parent_complex_message_port_ = request->port_descriptor.name;
       EXPECT_EQ(static_cast<mach_msg_type_name_t>(MACH_MSG_TYPE_MOVE_SEND),
                 request->port_descriptor.disposition);
       EXPECT_EQ(
           static_cast<mach_msg_descriptor_type_t>(MACH_MSG_PORT_DESCRIPTOR),
           request->port_descriptor.type);
     } else {
       EXPECT_EQ(0u, request->body.msgh_descriptor_count);
       EXPECT_EQ(static_cast<mach_port_t>(MACH_PORT_NULL),
                 request->port_descriptor.name);
       EXPECT_EQ(0u, request->port_descriptor.disposition);
       EXPECT_EQ(0u, request->port_descriptor.type);
     }
     EXPECT_EQ(0, memcmp(&request->ndr, &NDR_record, sizeof(NDR_record)));
     EXPECT_EQ(requests_, request->number);
+
+    // Look for the trailer in the right spot, depending on whether the request
+    // message was a RequestMessage or a LargeRequestMessage.
+    const mach_msg_trailer_t* trailer;
+    if (options_.client_send_large) {
+      const ReceiveLargeRequestMessage* large_request =
+          reinterpret_cast<const ReceiveLargeRequestMessage*>(request);
+      for (size_t index = 0; index < sizeof(large_request->data); ++index) {
+        EXPECT_EQ('!', large_request->data[index]);
+      }
+      trailer = &large_request->trailer;
+    } else {
+      trailer = &request->trailer;
+    }
+
     EXPECT_EQ(static_cast<mach_msg_trailer_type_t>(MACH_MSG_TRAILER_FORMAT_0),
-              request->trailer.msgh_trailer_type);
-    EXPECT_EQ(MACH_MSG_TRAILER_MINIMUM_SIZE,
-              request->trailer.msgh_trailer_size);
+              trailer->msgh_trailer_type);
+    EXPECT_EQ(MACH_MSG_TRAILER_MINIMUM_SIZE, trailer->msgh_trailer_size);
 
     ++requests_;
 
     ReplyMessage* reply = reinterpret_cast<ReplyMessage*>(out);
     reply->Head.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);
     reply->Head.msgh_size = sizeof(*reply);
     reply->Head.msgh_remote_port = request->header.msgh_remote_port;
     reply->Head.msgh_local_port = MACH_PORT_NULL;
     reply->Head.msgh_id = kReplyMessageId;
     reply->NDR = NDR_record;
     reply->RetCode = options_.server_mig_retcode;
     reply->number = replies_++;
 
     return true;
   }
 
   virtual mach_msg_size_t MachMessageServerRequestSize() override {
     return sizeof(RequestMessage);
   }
 
   virtual mach_msg_size_t MachMessageServerReplySize() override {
     return sizeof(ReplyMessage);
   }
 
  private:
   struct RequestMessage : public mach_msg_base_t {
+    // If body.msgh_descriptor_count is 0, port_descriptor will still be
+    // present, but it will be zeroed out. It wouldn’t normally be present in a
+    // message froma MIG-generated interface, but it’s harmless and simpler to
+    // leave it here and just treat it as more data.
     mach_msg_port_descriptor_t port_descriptor;
+
     NDR_record_t ndr;
     uint32_t number;
   };
 
+  // LargeRequestMessage is larger enough than a regular RequestMessage to
+  // ensure that whatever buffer was allocated to receive a RequestMessage is
+  // not large enough to receive a LargeRequestMessage.
+  struct LargeRequestMessage : public RequestMessage {
+    uint8_t data[4 * PAGE_SIZE];
+  };
+
   struct ReplyMessage : public mig_reply_error_t {
     uint32_t number;
   };
 
   // MachMultiprocess:
 
   virtual void MachMultiprocessParent() override {
     if (options_.parent_wait_for_child_pipe) {
       // Wait until the child is done sending what it’s going to send.
       char c;
       ssize_t rv = ReadFD(ReadPipeFD(), &c, 1);
       EXPECT_EQ(1, rv) << ErrnoMessage("read");
       EXPECT_EQ('\0', c);
     }
 
     kern_return_t kr;
     ASSERT_EQ(options_.expect_server_result,
               (kr = MachMessageServer::Run(this,
                                            LocalPort(),
-                                           MACH_MSG_OPTION_NONE,
+                                           options_.server_options,
                                            options_.server_persistent,
                                            options_.server_nonblocking,
                                            options_.server_timeout_ms)))
         << MachErrorMessage(kr, "MachMessageServer");
 
     if (options_.client_send_complex) {
       EXPECT_NE(static_cast<mach_port_t>(MACH_PORT_NULL),
                 parent_complex_message_port_);
       mach_port_type_t type;
 
@@ skipping 76 matching lines @@
     }
   }
 
   // In the child process, sends a request message to the server.
   void ChildSendRequest() {
     // local_receive_port_owner will the receive right that is created in this
     // scope and intended to be destroyed when leaving this scope, after it has
     // been carried in a Mach message.
     base::mac::ScopedMachReceiveRight local_receive_port_owner;
 
-    RequestMessage request = {};
+    // A LargeRequestMessage is always allocated, but the message that will be
+    // sent will be a normal RequestMessage due to the msgh_size field
+    // indicating the size of the smaller base structure unless
+    // options_.client_send_large is true.
+    LargeRequestMessage request = {};
+
     request.header.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND) |
         (options_.client_send_complex ? MACH_MSGH_BITS_COMPLEX : 0);
-    request.header.msgh_size = sizeof(request);
+    request.header.msgh_size = options_.client_send_large ?
+        sizeof(LargeRequestMessage) : sizeof(RequestMessage);
     request.header.msgh_remote_port = RemotePort();
     kern_return_t kr;
     switch (options_.client_reply_port_type) {
       case Options::kReplyPortNormal:
         request.header.msgh_local_port = LocalPort();
         break;
       case Options::kReplyPortNull:
         request.header.msgh_local_port = MACH_PORT_NULL;
         break;
       case Options::kReplyPortDead: {
@@ skipping 26 matching lines @@
       request.port_descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
     } else {
       request.body.msgh_descriptor_count = 0;
       request.port_descriptor.name = MACH_PORT_NULL;
       request.port_descriptor.disposition = 0;
       request.port_descriptor.type = 0;
     }
     request.ndr = NDR_record;
     request.number = requests_++;
 
+    if (options_.client_send_large) {
+      memset(request.data, '!', sizeof(request.data));
+    }
+
     kr = mach_msg(&request.header,
                   MACH_SEND_MSG | MACH_SEND_TIMEOUT,
                   request.header.msgh_size,
                   0,
                   MACH_PORT_NULL,
                   MACH_MSG_TIMEOUT_NONE,
                   MACH_PORT_NULL);
     ASSERT_EQ(MACH_MSG_SUCCESS, kr) << MachErrorMessage(kr, "mach_msg");
   }
 
@@ skipping 102 matching lines @@
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, NonblockingNoMessage) {
   // The server waits in nonblocking mode and the client sends nothing, so the
   // server should return immediately without processing any message.
   TestMachMessageServer::Options options;
   options.expect_server_interface_method_called = false;
   options.server_nonblocking = MachMessageServer::kNonblocking;
   options.expect_server_result = MACH_RCV_TIMED_OUT;
+  options.expect_server_transaction_count = 0;
   options.client_send_request_count = 0;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, TimeoutNoMessage) {
   // The server waits in blocking mode for one message, but with a timeout. The
   // client sends no message, so the server returns after the timeout.
   TestMachMessageServer::Options options;
   options.expect_server_interface_method_called = false;
   options.server_timeout_ms = 10;
   options.expect_server_result = MACH_RCV_TIMED_OUT;
+  options.expect_server_transaction_count = 0;
   options.client_send_request_count = 0;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, Nonblocking) {
   // The client sends one message to the server and then signals the server that
   // it’s safe to start waiting for it in nonblocking mode. The message is in
   // the server’s queue, so it’s able to receive it when it begins listening in
   // nonblocking mode.
@@ skipping 14 matching lines @@
 }
 
 TEST(MachMessageServer, PersistentTenMessages) {
   // The server waits for as many messages as it can receive in blocking mode
   // with a timeout. The client sends several messages, and the server processes
   // them all.
   TestMachMessageServer::Options options;
   options.server_persistent = MachMessageServer::kPersistent;
   options.server_timeout_ms = 10;
   options.expect_server_result = MACH_RCV_TIMED_OUT;
+  options.expect_server_transaction_count = 10;
   options.client_send_request_count = 10;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, PersistentNonblockingFourMessages) {
   // The client sends several messages to the server and then signals the server
   // that it’s safe to start waiting for them in nonblocking mode. The server
   // then listens for them in nonblocking persistent mode, and receives all of
   // them because they’ve been queued up. The client doesn’t wait for the
   // replies until after it’s put all of its requests into the server’s queue.
   //
   // This test is sensitive to the length of the IPC queue limit. Mach ports
   // normally have a queue length limit of MACH_PORT_QLIMIT_DEFAULT (which is
   // MACH_PORT_QLIMIT_BASIC, or 5). The number of messages sent for this test
   // must be below this, because the server does not begin dequeueing request
   // messages until the client has finished sending them.
+  const size_t kTransactionCount = 4;
+  COMPILE_ASSERT(kTransactionCount <= MACH_PORT_QLIMIT_DEFAULT,
+                 must_not_exceed_queue_limit);
+
   TestMachMessageServer::Options options;
   options.parent_wait_for_child_pipe = true;
   options.server_persistent = MachMessageServer::kPersistent;
   options.server_nonblocking = MachMessageServer::kNonblocking;
   options.expect_server_result = MACH_RCV_TIMED_OUT;
-  options.client_send_request_count = 4;
+  options.expect_server_transaction_count = kTransactionCount;
+  options.client_send_request_count = kTransactionCount;
   options.child_send_all_requests_before_receiving_any_replies = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, ReturnCodeInvalidArgument) {
   // This tests that the mig_reply_error_t::RetCode field is properly returned
   // to the client.
   TestMachMessageServer::Options options;
   options.server_mig_retcode = KERN_INVALID_ARGUMENT;
@@ skipping 93 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 = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
+TEST(MachMessageServer, LargeUnexpected) {
+  // 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.
+  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) {
+  // 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.
+  TestMachMessageServer::Options options;
+  options.server_options = MACH_RCV_LARGE;
+  options.client_send_large = true;
+  TestMachMessageServer test_mach_message_server(options);
+  test_mach_message_server.Test();
+}
+
 }  // namespace