Add exc_client_variants (UniversalRaiseException()) and its test

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 26 matching lines @@
 const mach_port_t kClientRemotePort = 0x01010101;
 const mach_port_t kServerLocalPort = 0x02020202;
 const mach_port_t kExceptionThreadPort = 0x03030303;
 const mach_port_t kExceptionTaskPort = 0x04040404;
 
 // Other fake exception values.
 const exception_type_t kExceptionType = EXC_BAD_ACCESS;
 
 // Test using an exception code with the high bit set to ensure that it gets
 // promoted to the wider mach_exception_data_type_t type as a signed quantity.
-const exception_data_type_t kExceptionCodes[] = {
+const exception_data_type_t kTestExceptonCodes[] = {
     KERN_PROTECTION_FAILURE,
     static_cast<exception_data_type_t>(0xfedcba98),
 };
 
-const exception_data_type_t kMachExceptionCodes[] = {
+const exception_data_type_t kTestMachExceptionCodes[] = {
     KERN_PROTECTION_FAILURE,
     static_cast<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) {
@@ skipping 27 matching lines @@
     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;
     codeCnt = 2;
-    code[0] = kExceptionCodes[0];
-    code[1] = kExceptionCodes[1];
+    code[0] = kTestExceptonCodes[0];
+    code[1] = kTestExceptonCodes[1];
   }
 };
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseReply {
   mach_msg_header_t Head;
   NDR_record_t NDR;
   kern_return_t RetCode;
 
   void InitializeForTesting() {
     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(static_cast<mach_msg_bits_t>(
                   MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 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 static_cast<exception_behavior_t>(EXCEPTION_DEFAULT |
-                                             MACH_EXCEPTION_CODES):
+      case EXCEPTION_DEFAULT | kMachExceptionCodes:
         EXPECT_EQ(2505, Head.msgh_id);
         break;
       default:
         ADD_FAILURE() << "behavior " << behavior << ", Head.msgh_id "
                       << Head.msgh_id;
         break;
     }
     EXPECT_EQ(0, memcmp(&NDR, &NDR_record, sizeof(NDR)));
     EXPECT_EQ(KERN_SUCCESS, RetCode);
   }
@@ skipping 13 matching lines @@
     memset(this, 0xa5, sizeof(*this));
     Head.msgh_bits =
         MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE);
     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] = kExceptionCodes[0];
-    code[1] = kExceptionCodes[1];
+    code[0] = kTestExceptonCodes[0];
+    code[1] = kTestExceptonCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
 };
 
 struct __attribute__((packed, aligned(4))) ExceptionRaiseStateReply {
@@ skipping 21 matching lines @@
     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);
         break;
-      case static_cast<exception_behavior_t>(EXCEPTION_STATE |
-                                             MACH_EXCEPTION_CODES):
+      case EXCEPTION_STATE | kMachExceptionCodes:
         EXPECT_EQ(2506, Head.msgh_id);
         break;
-      case static_cast<exception_behavior_t>(EXCEPTION_STATE_IDENTITY |
-                                             MACH_EXCEPTION_CODES):
+      case EXCEPTION_STATE_IDENTITY | kMachExceptionCodes:
         EXPECT_EQ(2507, Head.msgh_id);
         break;
       default:
         ADD_FAILURE() << "behavior " << behavior << ", Head.msgh_id "
                       << Head.msgh_id;
         break;
     }
     EXPECT_EQ(0, memcmp(&NDR, &NDR_record, sizeof(NDR)));
     EXPECT_EQ(KERN_SUCCESS, RetCode);
     EXPECT_EQ(kThreadStateFlavor, flavor);
@@ skipping 22 matching lines @@
     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;
     codeCnt = 2;
-    code[0] = kExceptionCodes[0];
-    code[1] = kExceptionCodes[1];
+    code[0] = kTestExceptonCodes[0];
+    code[1] = kTestExceptonCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
 };
 
 // The reply messages for exception_raise_state and
@@ skipping 18 matching lines @@
     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;
     codeCnt = 2;
-    code[0] = kMachExceptionCodes[0];
-    code[1] = kMachExceptionCodes[1];
+    code[0] = kTestMachExceptionCodes[0];
+    code[1] = kTestMachExceptionCodes[1];
   }
 };
 
 // The reply messages for exception_raise and mach_exception_raise are
 // identical.
 typedef ExceptionRaiseReply MachExceptionRaiseReply;
 
 struct __attribute__((packed, aligned(4))) MachExceptionRaiseStateRequest {
   mach_msg_header_t Head;
   NDR_record_t NDR;
   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);
     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] = kMachExceptionCodes[0];
-    code[1] = kMachExceptionCodes[1];
+    code[0] = kTestMachExceptionCodes[0];
+    code[1] = kTestMachExceptionCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
 };
 
 // The reply messages for exception_raise_state and mach_exception_raise_state
@@ skipping 22 matching lines @@
     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;
     codeCnt = 2;
-    code[0] = kMachExceptionCodes[0];
-    code[1] = kMachExceptionCodes[1];
+    code[0] = kTestMachExceptionCodes[0];
+    code[1] = kTestMachExceptionCodes[1];
     flavor = kThreadStateFlavor;
     old_stateCnt = kThreadStateFlavorCount;
 
     // Adjust the message size for the data that it’s actually carrying, which
     // may be smaller than the maximum that it can carry.
     Head.msgh_size += sizeof(old_state[0]) * old_stateCnt - sizeof(old_state);
   }
 };
 
 // The reply messages for exception_raise_state_identity and
@@ skipping 175 matching lines @@
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_DEFAULT;
 
   EXPECT_CALL(server,
               MockCatchMachException(
                   kExceptionBehavior,
                   kServerLocalPort,
                   kExceptionThreadPort,
                   kExceptionTaskPort,
                   kExceptionType,
-                  AreExceptionCodes(kExceptionCodes[0], kExceptionCodes[1]),
+                  AreExceptionCodes(
+                      kTestExceptonCodes[0], kTestExceptonCodes[1]),
                   Pointee(Eq(THREAD_STATE_NONE)),
                   IsThreadStateCount(0u),
                   IsThreadStateCount(0u)))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
@@ skipping 18 matching lines @@
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE;
 
   EXPECT_CALL(server,
               MockCatchMachException(
                   kExceptionBehavior,
                   kServerLocalPort,
                   MACH_PORT_NULL,
                   MACH_PORT_NULL,
                   kExceptionType,
-                  AreExceptionCodes(kExceptionCodes[0], kExceptionCodes[1]),
+                  AreExceptionCodes(
+                      kTestExceptonCodes[0], kTestExceptonCodes[1]),
                   Pointee(Eq(kThreadStateFlavor)),
                   IsThreadStateCount(kThreadStateFlavorCount),
                   IsThreadStateCount(arraysize(reply.new_state))))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
@@ skipping 21 matching lines @@
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE_IDENTITY;
 
   EXPECT_CALL(server,
               MockCatchMachException(
                   kExceptionBehavior,
                   kServerLocalPort,
                   kExceptionThreadPort,
                   kExceptionTaskPort,
                   kExceptionType,
-                  AreExceptionCodes(kExceptionCodes[0], kExceptionCodes[1]),
+                  AreExceptionCodes(
+                      kTestExceptonCodes[0], kTestExceptonCodes[1]),
                   Pointee(Eq(kThreadStateFlavor)),
                   IsThreadStateCount(kThreadStateFlavorCount),
                   IsThreadStateCount(arraysize(reply.new_state))))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
@@ skipping 20 matching lines @@
       EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(
           kExceptionBehavior,
           kServerLocalPort,
           kExceptionThreadPort,
           kExceptionTaskPort,
           kExceptionType,
-          AreExceptionCodes(kMachExceptionCodes[0], kMachExceptionCodes[1]),
+          AreExceptionCodes(
+              kTestMachExceptionCodes[0], kTestMachExceptionCodes[1]),
           Pointee(Eq(THREAD_STATE_NONE)),
           IsThreadStateCount(0u),
           IsThreadStateCount(0u)))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
@@ skipping 20 matching lines @@
       EXCEPTION_STATE | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(
           kExceptionBehavior,
           kServerLocalPort,
           MACH_PORT_NULL,
           MACH_PORT_NULL,
           kExceptionType,
-          AreExceptionCodes(kMachExceptionCodes[0], kMachExceptionCodes[1]),
+          AreExceptionCodes(
+              kTestMachExceptionCodes[0], kTestMachExceptionCodes[1]),
           Pointee(Eq(kThreadStateFlavor)),
           IsThreadStateCount(kThreadStateFlavorCount),
           IsThreadStateCount(arraysize(reply.new_state))))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
@@ skipping 23 matching lines @@
       EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(
           kExceptionBehavior,
           kServerLocalPort,
           kExceptionThreadPort,
           kExceptionTaskPort,
           kExceptionType,
-          AreExceptionCodes(kMachExceptionCodes[0], kMachExceptionCodes[1]),
+          AreExceptionCodes(
+              kTestMachExceptionCodes[0], kTestMachExceptionCodes[1]),
           Pointee(Eq(kThreadStateFlavor)),
           IsThreadStateCount(kThreadStateFlavorCount),
           IsThreadStateCount(arraysize(reply.new_state))))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
@@ skipping 132 matching lines @@
       int sig = (code[0] >> 24) & 0xff;
       SetExpectedChildTermination(kTerminationSignal, sig);
     }
 
     if (has_state) {
       EXPECT_EQ(flavor_, *flavor);
       EXPECT_EQ(state_count_, old_state_count);
       EXPECT_NE(static_cast<const natural_t*>(NULL), old_state);
       EXPECT_EQ(static_cast<mach_msg_type_number_t>(THREAD_STATE_MAX),
                 *new_state_count);
-      EXPECT_NE(static_cast<const natural_t*>(NULL), new_state);
+      EXPECT_NE(static_cast<natural_t*>(NULL), new_state);
     } else {
       EXPECT_EQ(THREAD_STATE_NONE, *flavor);
       EXPECT_EQ(0u, old_state_count);
       EXPECT_EQ(NULL, old_state);
       EXPECT_EQ(0u, *new_state_count);
       EXPECT_EQ(NULL, new_state);
     }
 
     // Even for an EXC_CRASH handler, returning KERN_SUCCESS with a
     // state-carrying reply will cause the kernel to try to set a new thread
@@ skipping 140 matching lines @@
 
     TestExcServerVariants test_exc_server_variants(
         MACH_EXCEPTION_CODES | EXCEPTION_STATE_IDENTITY,
         test.flavor,
         test.count);
     test_exc_server_variants.Run();
   }
 }
 
 }  // namespace