ExcServerVariants test: make the mock test port dispositions reflect reality

util/mach/exc_server_variants_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 47 matching lines @@
     implicit_cast<mach_exception_data_type_t>(0xfedcba9876543210),
 };
 
 const thread_state_flavor_t kThreadStateFlavor = MACHINE_THREAD_STATE;
 const mach_msg_type_number_t kThreadStateFlavorCount =
     MACHINE_THREAD_STATE_COUNT;
 
 void InitializeMachMsgPortDescriptor(mach_msg_port_descriptor_t* descriptor,
                                      mach_port_t port) {
   descriptor->name = port;
-  descriptor->disposition = MACH_MSG_TYPE_MOVE_SEND;
+  descriptor->disposition = MACH_MSG_TYPE_PORT_SEND;
   descriptor->type = MACH_MSG_PORT_DESCRIPTOR;
 }
 
 // The definitions of the request and reply structures from mach_exc.h aren’t
 // available here. They need custom initialization code, and the reply
 // structures need verification code too, so duplicate the expected definitions
 // of the structures from both exc.h and mach_exc.h here in this file, and
 // provide the initialization and verification code as methods in true
 // object-oriented fashion.
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseRequest {
   mach_msg_header_t Head;
   mach_msg_body_t msgh_body;
   mach_msg_port_descriptor_t thread;
   mach_msg_port_descriptor_t task;
   NDR_record_t NDR;
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   integer_t code[2];
 
   void InitializeForTesting() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
-        MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE) |
+        MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2401;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
@@ skipping 12 matching lines @@
     memset(this, 0x5a, sizeof(*this));
     RetCode = KERN_FAILURE;
   }
 
   // Verify accepts a |behavior| parameter because the same message format and
   // verification function is used for ExceptionRaiseReply and
   // MachExceptionRaiseReply. Knowing which behavior is expected allows the
   // message ID to be checked.
   void Verify(exception_behavior_t behavior) {
     EXPECT_EQ(implicit_cast<mach_msg_bits_t>(
-                  MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0)),
+                  MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND_ONCE, 0)),
               Head.msgh_bits);
     EXPECT_EQ(sizeof(*this), Head.msgh_size);
     EXPECT_EQ(kClientRemotePort, Head.msgh_remote_port);
     EXPECT_EQ(kMachPortNull, Head.msgh_local_port);
     switch (behavior) {
       case EXCEPTION_DEFAULT:
         EXPECT_EQ(2501, Head.msgh_id);
         break;
       case EXCEPTION_DEFAULT | kMachExceptionCodes:
         EXPECT_EQ(2505, Head.msgh_id);
@@ skipping 14 matching lines @@
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   integer_t code[2];
   int flavor;
   mach_msg_type_number_t old_stateCnt;
   natural_t old_state[THREAD_STATE_MAX];
 
   void InitializeForTesting() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
-        MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+        MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND);
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2402;
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestExceptonCodes[0];
     code[1] = kTestExceptonCodes[1];
     flavor = kThreadStateFlavor;
@@ skipping 18 matching lines @@
     RetCode = KERN_FAILURE;
   }
 
   // Verify accepts a |behavior| parameter because the same message format and
   // verification function is used for ExceptionRaiseStateReply,
   // ExceptionRaiseStateIdentityReply, MachExceptionRaiseStateReply, and
   // MachExceptionRaiseStateIdentityReply. Knowing which behavior is expected
   // allows the message ID to be checked.
   void Verify(exception_behavior_t behavior) {
     EXPECT_EQ(implicit_cast<mach_msg_bits_t>(
-                  MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0)),
+                  MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND_ONCE, 0)),
               Head.msgh_bits);
     EXPECT_EQ(sizeof(*this), Head.msgh_size);
     EXPECT_EQ(kClientRemotePort, Head.msgh_remote_port);
     EXPECT_EQ(kMachPortNull, Head.msgh_local_port);
     switch (behavior) {
       case EXCEPTION_STATE:
         EXPECT_EQ(2502, Head.msgh_id);
         break;
       case EXCEPTION_STATE_IDENTITY:
         EXPECT_EQ(2503, Head.msgh_id);
@@ skipping 25 matching lines @@
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   integer_t code[2];
   int flavor;
   mach_msg_type_number_t old_stateCnt;
   natural_t old_state[THREAD_STATE_MAX];
 
   void InitializeForTesting() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
-        MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE) |
+        MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2403;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
@@ skipping 19 matching lines @@
   mach_msg_port_descriptor_t thread;
   mach_msg_port_descriptor_t task;
   NDR_record_t NDR;
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   int64_t code[2];
 
   void InitializeForTesting() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
-        MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE) |
+        MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2405;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
@@ skipping 13 matching lines @@
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   int64_t code[2];
   int flavor;
   mach_msg_type_number_t old_stateCnt;
   natural_t old_state[THREAD_STATE_MAX];
 
   void InitializeForTesting() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
-        MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+        MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND);
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2406;
     NDR = NDR_record;
     exception = kExceptionType;
     codeCnt = 2;
     code[0] = kTestMachExceptionCodes[0];
     code[1] = kTestMachExceptionCodes[1];
     flavor = kThreadStateFlavor;
@@ skipping 19 matching lines @@
   exception_type_t exception;
   mach_msg_type_number_t codeCnt;
   int64_t code[2];
   int flavor;
   mach_msg_type_number_t old_stateCnt;
   natural_t old_state[THREAD_STATE_MAX];
 
   void InitializeForTesting() {
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
-        MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE) |
+        MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND) |
         MACH_MSGH_BITS_COMPLEX;
     Head.msgh_size = sizeof(*this);
     Head.msgh_remote_port = kClientRemotePort;
     Head.msgh_local_port = kServerLocalPort;
     Head.msgh_id = 2407;
     msgh_body.msgh_descriptor_count = 2;
     InitializeMachMsgPortDescriptor(&thread, kExceptionThreadPort);
     InitializeMachMsgPortDescriptor(&task, kExceptionTaskPort);
     NDR = NDR_record;
     exception = kExceptionType;
@@ skipping 15 matching lines @@
 
 // InvalidRequest and BadIDErrorReply are used to test that
 // UniversalMachExcServer deals appropriately with messages that it does not
 // understand: messages with an unknown Head.msgh_id.
 
 struct __attribute__((packed, aligned(4))) InvalidRequest
     : public mach_msg_empty_send_t {
   void InitializeForTesting(mach_msg_id_t id) {
     memset(this, 0xa5, sizeof(*this));
     header.msgh_bits =
-        MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE);
+        MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, MACH_MSG_TYPE_PORT_SEND);
     header.msgh_size = sizeof(*this);
     header.msgh_remote_port = kClientRemotePort;
     header.msgh_local_port = kServerLocalPort;
     header.msgh_id = id;
   }
 };
 
 struct __attribute__((packed, aligned(4))) BadIDErrorReply
     : public mig_reply_error_t {
   void InitializeForTesting() {
     memset(this, 0x5a, sizeof(*this));
     RetCode = KERN_FAILURE;
   }
 
   void Verify(mach_msg_id_t id) {
     EXPECT_EQ(implicit_cast<mach_msg_bits_t>(
-                  MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0)),
+                  MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND_ONCE, 0)),
               Head.msgh_bits);
     EXPECT_EQ(sizeof(*this), Head.msgh_size);
     EXPECT_EQ(kClientRemotePort, Head.msgh_remote_port);
     EXPECT_EQ(kMachPortNull, Head.msgh_local_port);
     EXPECT_EQ(id + 100, Head.msgh_id);
     EXPECT_EQ(0, memcmp(&NDR, &NDR_record, sizeof(NDR)));
     EXPECT_EQ(MIG_BAD_ID, RetCode);
   }
 };
 
@@ skipping 743 matching lines @@
 
     EXPECT_EQ(test_data.kr,
               ExcServerSuccessfulReturnValue(test_data.behavior,
                                              test_data.set_thread_state));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad