MachMessageServer: Make request messages const

util/mach/exc_server_variants.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 125 matching lines @@
 // There are no predefined constants for these.
 enum MachMessageID : mach_msg_id_t {
   kMachMessageIDExceptionRaise = 2401,
   kMachMessageIDExceptionRaiseState = 2402,
   kMachMessageIDExceptionRaiseStateIdentity = 2403,
   kMachMessageIDMachExceptionRaise = 2405,
   kMachMessageIDMachExceptionRaiseState = 2406,
   kMachMessageIDMachExceptionRaiseStateIdentity = 2407,
 };
 
+// The MIG-generated __MIG_check__Request__*() functions are not declared as

[Robert Sesek, 2014/09/10 21:56:45]

Could you do this in the mig.py script instead, and just fix the generated code?

[Mark Mentovai, 2014/09/10 22:35:01]

rsesek wrote:
That’s substantially harder. It’s pretty easy to fix the declaration in the
header and the prototype where it’s defined, but it winds up triggering problems
at call sites in the implementation file, because you can’t implicitly convert a
Request** to a const Request**. Rewriting those call sites to have casts too is
a lot trickier.

The exact problem is http://c-faq.com/ansi/constmismatch.html.

+// accepting const data, but they could have been because they in fact do not
+// modify the data. These wrapper functions are provided to bridge the const gap
+// between the code in this file, which is const-correct and treats request
+// message data as const, and those generated functions.
+
+kern_return_t MIGCheckRequestExceptionRaise(
+    const __Request__exception_raise_t* in_request) {
+  typedef __Request__exception_raise_t Request;
+  return __MIG_check__Request__exception_raise_t(
+      const_cast<Request*>(in_request));
+}
+
+kern_return_t MIGCheckRequestExceptionRaiseState(
+    const __Request__exception_raise_state_t* in_request,
+    const __Request__exception_raise_state_t** in_request_1) {
+  typedef __Request__exception_raise_state_t Request;
+  return __MIG_check__Request__exception_raise_state_t(
+      const_cast<Request*>(in_request), const_cast<Request**>(in_request_1));
+}
+
+kern_return_t MIGCheckRequestExceptionRaiseStateIdentity(
+    const __Request__exception_raise_state_identity_t* in_request,
+    const __Request__exception_raise_state_identity_t** in_request_1) {
+  typedef __Request__exception_raise_state_identity_t Request;
+  return __MIG_check__Request__exception_raise_state_identity_t(
+      const_cast<Request*>(in_request), const_cast<Request**>(in_request_1));
+}
+
+kern_return_t MIGCheckRequestMachExceptionRaise(
+    const __Request__mach_exception_raise_t* in_request) {
+  typedef __Request__mach_exception_raise_t Request;
+  return __MIG_check__Request__mach_exception_raise_t(
+      const_cast<Request*>(in_request));
+}
+
+kern_return_t MIGCheckRequestMachExceptionRaiseState(
+    const __Request__mach_exception_raise_state_t* in_request,
+    const __Request__mach_exception_raise_state_t** in_request_1) {
+  typedef __Request__mach_exception_raise_state_t Request;
+  return __MIG_check__Request__mach_exception_raise_state_t(
+      const_cast<Request*>(in_request), const_cast<Request**>(in_request_1));
+}
+
+kern_return_t MIGCheckRequestMachExceptionRaiseStateIdentity(
+    const __Request__mach_exception_raise_state_identity_t* in_request,
+    const __Request__mach_exception_raise_state_identity_t** in_request_1) {
+  typedef __Request__mach_exception_raise_state_identity_t Request;
+  return __MIG_check__Request__mach_exception_raise_state_identity_t(
+      const_cast<Request*>(in_request), const_cast<Request**>(in_request_1));
+}
+
 }  // namespace
 
 namespace crashpad {
 namespace internal {
 
 ExcServer::ExcServer(ExcServer::Interface* interface)
     : MachMessageServer::Interface(),
       interface_(interface) {
 }
 
-bool ExcServer::MachMessageServerFunction(mach_msg_header_t* in_header,
+bool ExcServer::MachMessageServerFunction(const mach_msg_header_t* in_header,
                                           mach_msg_header_t* out_header,
                                           bool* destroy_complex_request) {
   PrepareReplyFromRequest(in_header, out_header);
 
   switch (in_header->msgh_id) {
     case kMachMessageIDExceptionRaise: {
       // exception_raise(), catch_exception_raise().
       typedef __Request__exception_raise_t Request;
-      Request* in_request = reinterpret_cast<Request*>(in_header);
-      kern_return_t kr = __MIG_check__Request__exception_raise_t(in_request);
+      const Request* in_request = reinterpret_cast<const Request*>(in_header);
+      kern_return_t kr = MIGCheckRequestExceptionRaise(in_request);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__exception_raise_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->RetCode =
           interface_->CatchExceptionRaise(in_header->msgh_local_port,
                                           in_request->thread.name,
                                           in_request->task.name,
                                           in_request->exception,
                                           in_request->code,
                                           in_request->codeCnt,
                                           destroy_complex_request);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
       out_header->msgh_size = sizeof(*out_reply);
       return true;
     }
 
     case kMachMessageIDExceptionRaiseState: {
       // exception_raise_state(), catch_exception_raise_state().
       typedef __Request__exception_raise_state_t Request;
-      Request* in_request = reinterpret_cast<Request*>(in_header);
+      const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
-      Request* in_request_1;
-      kern_return_t kr = __MIG_check__Request__exception_raise_state_t(
+      const Request* in_request_1;
+      kern_return_t kr = MIGCheckRequestExceptionRaiseState(
           in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__exception_raise_state_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
+      out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode =
           interface_->CatchExceptionRaiseState(in_header->msgh_local_port,
                                                in_request->exception,
                                                in_request->code,
                                                in_request->codeCnt,
-                                               &in_request_1->flavor,
+                                               &out_reply->flavor,
                                                in_request_1->old_state,
                                                in_request_1->old_stateCnt,
                                                out_reply->new_state,
                                                &out_reply->new_stateCnt);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
-      out_reply->flavor = in_request_1->flavor;
       out_header->msgh_size =
           sizeof(*out_reply) - sizeof(out_reply->new_state) +
           sizeof(out_reply->new_state[0]) * out_reply->new_stateCnt;
       return true;
     }
 
     case kMachMessageIDExceptionRaiseStateIdentity: {
       // exception_raise_state_identity(),
       // catch_exception_raise_state_identity().
       typedef __Request__exception_raise_state_identity_t Request;
-      Request* in_request = reinterpret_cast<Request*>(in_header);
+      const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
-      Request* in_request_1;
-      kern_return_t kr = __MIG_check__Request__exception_raise_state_identity_t(
+      const Request* in_request_1;
+      kern_return_t kr = MIGCheckRequestExceptionRaiseStateIdentity(
           in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__exception_raise_state_identity_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
+      out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode = interface_->CatchExceptionRaiseStateIdentity(
           in_header->msgh_local_port,
           in_request->thread.name,
           in_request->task.name,
           in_request->exception,
           in_request->code,
           in_request->codeCnt,
-          &in_request_1->flavor,
+          &out_reply->flavor,
           in_request_1->old_state,
           in_request_1->old_stateCnt,
           out_reply->new_state,
           &out_reply->new_stateCnt,
           destroy_complex_request);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
-      out_reply->flavor = in_request_1->flavor;
       out_header->msgh_size =
           sizeof(*out_reply) - sizeof(out_reply->new_state) +
           sizeof(out_reply->new_state[0]) * out_reply->new_stateCnt;
       return true;
     }
   }
 
   SetReplyError(out_header, MIG_BAD_ID);
   return false;
 }
 
 mach_msg_size_t ExcServer::MachMessageServerRequestSize() {
   return sizeof(__RequestUnion__exc_subsystem);
 }
 
 mach_msg_size_t ExcServer::MachMessageServerReplySize() {
   return sizeof(__ReplyUnion__exc_subsystem);
 }
 
 MachExcServer::MachExcServer(MachExcServer::Interface* interface)
     : MachMessageServer::Interface(),
       interface_(interface) {
 }
 
-bool MachExcServer::MachMessageServerFunction(mach_msg_header_t* in_header,
-                                              mach_msg_header_t* out_header,
-                                              bool* destroy_complex_request) {
+bool MachExcServer::MachMessageServerFunction(
+    const mach_msg_header_t* in_header,
+    mach_msg_header_t* out_header,
+    bool* destroy_complex_request) {
   PrepareReplyFromRequest(in_header, out_header);
 
   switch (in_header->msgh_id) {
     case kMachMessageIDMachExceptionRaise: {
       // mach_exception_raise(), catch_mach_exception_raise().
       typedef __Request__mach_exception_raise_t Request;
-      Request* in_request = reinterpret_cast<Request*>(in_header);
-      kern_return_t kr =
-          __MIG_check__Request__mach_exception_raise_t(in_request);
+      const Request* in_request = reinterpret_cast<const Request*>(in_header);
+      kern_return_t kr = MIGCheckRequestMachExceptionRaise(in_request);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__mach_exception_raise_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->RetCode =
           interface_->CatchMachExceptionRaise(in_header->msgh_local_port,
                                               in_request->thread.name,
                                               in_request->task.name,
                                               in_request->exception,
                                               in_request->code,
                                               in_request->codeCnt,
                                               destroy_complex_request);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
       out_header->msgh_size = sizeof(*out_reply);
       return true;
     }
 
     case kMachMessageIDMachExceptionRaiseState: {
       // mach_exception_raise_state(), catch_mach_exception_raise_state().
       typedef __Request__mach_exception_raise_state_t Request;
-      Request* in_request = reinterpret_cast<Request*>(in_header);
+      const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
-      Request* in_request_1;
-      kern_return_t kr = __MIG_check__Request__mach_exception_raise_state_t(
+      const Request* in_request_1;
+      kern_return_t kr = MIGCheckRequestMachExceptionRaiseState(
           in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__mach_exception_raise_state_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
+      out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode =
           interface_->CatchMachExceptionRaiseState(in_header->msgh_local_port,
                                                    in_request->exception,
                                                    in_request->code,
                                                    in_request->codeCnt,
-                                                   &in_request_1->flavor,
+                                                   &out_reply->flavor,
                                                    in_request_1->old_state,
                                                    in_request_1->old_stateCnt,
                                                    out_reply->new_state,
                                                    &out_reply->new_stateCnt);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
-      out_reply->flavor = in_request_1->flavor;
       out_header->msgh_size =
           sizeof(*out_reply) - sizeof(out_reply->new_state) +
           sizeof(out_reply->new_state[0]) * out_reply->new_stateCnt;
       return true;
     }
 
     case kMachMessageIDMachExceptionRaiseStateIdentity: {
       // mach_exception_raise_state_identity(),
       // catch_mach_exception_raise_state_identity().
       typedef __Request__mach_exception_raise_state_identity_t Request;
-      Request* in_request = reinterpret_cast<Request*>(in_header);
+      const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
-      Request* in_request_1;
-      kern_return_t kr =
-          __MIG_check__Request__mach_exception_raise_state_identity_t(
-              in_request, &in_request_1);
+      const Request* in_request_1;
+      kern_return_t kr = MIGCheckRequestMachExceptionRaiseStateIdentity(
+          in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
       typedef __Reply__mach_exception_raise_state_identity_t Reply;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
+      out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode = interface_->CatchMachExceptionRaiseStateIdentity(
           in_header->msgh_local_port,
           in_request->thread.name,
           in_request->task.name,
           in_request->exception,
           in_request->code,
           in_request->codeCnt,
-          &in_request_1->flavor,
+          &out_reply->flavor,
           in_request_1->old_state,
           in_request_1->old_stateCnt,
           out_reply->new_state,
           &out_reply->new_stateCnt,
           destroy_complex_request);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
-      out_reply->flavor = in_request_1->flavor;
       out_header->msgh_size =
           sizeof(*out_reply) - sizeof(out_reply->new_state) +
           sizeof(out_reply->new_state[0]) * out_reply->new_stateCnt;
       return true;
     }
   }
 
   SetReplyError(out_header, MIG_BAD_ID);
   return false;
 }
@@ skipping 184 matching lines @@
 
 UniversalMachExcServer::UniversalMachExcServer()
     : MachMessageServer::Interface(),
       internal::SimplifiedExcServer::Interface(),
       internal::SimplifiedMachExcServer::Interface(),
       exc_server_(this),
       mach_exc_server_(this) {
 }
 
 bool UniversalMachExcServer::MachMessageServerFunction(
-    mach_msg_header_t* in_header,
+    const mach_msg_header_t* in_header,
     mach_msg_header_t* out_header,
     bool* destroy_complex_request) {
   switch (in_header->msgh_id) {
     case kMachMessageIDMachExceptionRaise:
     case kMachMessageIDMachExceptionRaiseState:
     case kMachMessageIDMachExceptionRaiseStateIdentity:
       return mach_exc_server_.MachMessageServerFunction(
           in_header, out_header, destroy_complex_request);
     case kMachMessageIDExceptionRaise:
     case kMachMessageIDExceptionRaiseState:
@@ skipping 48 matching lines @@
                             code_count,
                             flavor,
                             old_state,
                             old_state_count,
                             new_state,
                             new_state_count,
                             destroy_complex_request);
 }
 
 }  // namespace crashpad