base/mach_ipc_mac.h

   1 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef BASE_MACH_IPC_MAC_H_
   6 #define BASE_MACH_IPC_MAC_H_
   7 #pragma once
   8
   9 #include <mach/mach.h>
  10 #include <mach/message.h>
  11 #include <servers/bootstrap.h>
  12 #include <sys/types.h>
  13
  14 #include <CoreServices/CoreServices.h>
  15
  16 #include "base/basictypes.h"
  17
  18 //==============================================================================
  19 // DISCUSSION:
  20 //
  21 // The three main classes of interest are
  22 //
  23 //  MachMessage:    a wrapper for a mach message of the following form
  24 //   mach_msg_header_t
  25 //   mach_msg_body_t
  26 //   optional descriptors
  27 //   optional extra message data
  28 //
  29 //  MachReceiveMessage and MachSendMessage subclass MachMessage
  30 //    and are used instead of MachMessage which is an abstract base class
  31 //
  32 //  ReceivePort:
  33 //    Represents a mach port for which we have receive rights
  34 //
  35 //  MachPortSender:
  36 //    Represents a mach port for which we have send rights
  37 //
  38 // Here's an example to receive a message on a server port:
  39 //
  40 //        // This creates our named server port
  41 //        ReceivePort receivePort("com.Google.MyService");
  42 //
  43 //        MachReceiveMessage message;
  44 //        kern_return_t result = receivePort.WaitForMessage(&message, 0);
  45 //
  46 //        if (result == KERN_SUCCESS && message.GetMessageID() == 57) {
  47 //          mach_port_t task = message.GetTranslatedPort(0);
  48 //          mach_port_t thread = message.GetTranslatedPort(1);
  49 //
  50 //          char *messageString = message.GetData();
  51 //
  52 //          printf("message string = %s\n", messageString);
  53 //        }
  54 //
  55 // Here is an example of using these classes to send a message to this port:
  56 //
  57 //    // send to already named port
  58 //    MachPortSender sender("com.Google.MyService");
  59 //    MachSendMessage message(57);      // our message ID is 57
  60 //
  61 //    // add some ports to be translated for us
  62 //    message.AddDescriptor(mach_task_self());     // our task
  63 //    message.AddDescriptor(mach_thread_self());   // this thread
  64 //
  65 //    char messageString[] = "Hello server!\n";
  66 //    message.SetData(messageString, strlen(messageString)+1);
  67 //    // timeout 1000ms
  68 //    kern_return_t result = sender.SendMessage(message, 1000);
  69 //
  70
  71 #define PRINT_MACH_RESULT(result_, message_) \
  72   printf(message_" %s (%d)\n", mach_error_string(result_), result_ );
  73
  74 namespace base {
  75
  76 //==============================================================================
  77 // A wrapper class for mach_msg_port_descriptor_t (with same memory layout)
  78 // with convenient constructors and accessors
  79 class MachMsgPortDescriptor : public mach_msg_port_descriptor_t {
  80  public:
  81   // General-purpose constructor
  82   MachMsgPortDescriptor(mach_port_t in_name,
  83                         mach_msg_type_name_t in_disposition) {
  84     name = in_name;
  85     pad1 = 0;
  86     pad2 = 0;
  87     disposition = in_disposition;
  88     type = MACH_MSG_PORT_DESCRIPTOR;
  89   }
  90
  91   // For passing send rights to a port
  92   MachMsgPortDescriptor(mach_port_t in_name) {
  93     name = in_name;
  94     pad1 = 0;
  95     pad2 = 0;
  96     disposition = MACH_MSG_TYPE_PORT_SEND;
  97     type = MACH_MSG_PORT_DESCRIPTOR;
  98   }
  99
 100   // Copy constructor
 101   MachMsgPortDescriptor(const MachMsgPortDescriptor& desc) {
 102     name = desc.name;
 103     pad1 = desc.pad1;
 104     pad2 = desc.pad2;
 105     disposition = desc.disposition;
 106     type = desc.type;
 107   }
 108
 109   mach_port_t GetMachPort() const {
 110     return name;
 111   }
 112
 113   mach_msg_type_name_t GetDisposition() const {
 114     return disposition;
 115   }
 116
 117   // We're just a simple wrapper for mach_msg_port_descriptor_t
 118   // and have the same memory layout
 119   operator mach_msg_port_descriptor_t&() {
 120     return *this;
 121   }
 122
 123   // For convenience
 124   operator mach_port_t() const {
 125     return GetMachPort();
 126   }
 127 };
 128
 129 //==============================================================================
 130 // MachMessage: a wrapper for a mach message
 131 //  (mach_msg_header_t, mach_msg_body_t, extra data)
 132 //
 133 //  This considerably simplifies the construction of a message for sending
 134 //  and the getting at relevant data and descriptors for the receiver.
 135 //
 136 //  This class can be initialized using external storage of an arbitrary size
 137 //  or it can manage storage internally.
 138 //  1. If storage is allocated internally, the combined size of the descriptors
 139 //  plus data must be less than 1024.  But as a benefit no memory allocation is
 140 //  necessary.
 141 //  2. For external storage, a buffer of at least EmptyMessageSize() must be
 142 //  provided.
 143 //
 144 //  A MachMessage object is used by ReceivePort::WaitForMessage
 145 //  and MachPortSender::SendMessage
 146 //
 147 class MachMessage {
 148  public:
 149
 150   virtual ~MachMessage();
 151
 152   // The receiver of the message can retrieve the raw data this way
 153   u_int8_t *GetData() {
 154     return GetDataLength() > 0 ? GetDataPacket()->data : NULL;
 155   }
 156
 157   u_int32_t GetDataLength() {
 158     return EndianU32_LtoN(GetDataPacket()->data_length);
 159   }
 160
 161   // The message ID may be used as a code identifying the type of message
 162   void SetMessageID(int32_t message_id) {
 163     GetDataPacket()->id = EndianU32_NtoL(message_id);
 164   }
 165
 166   int32_t GetMessageID() { return EndianU32_LtoN(GetDataPacket()->id); }
 167
 168   // Adds a descriptor (typically a mach port) to be translated
 169   // returns true if successful, otherwise not enough space
 170   bool AddDescriptor(const MachMsgPortDescriptor &desc);
 171
 172   int GetDescriptorCount() const {
 173     return storage_->body.msgh_descriptor_count;
 174   }
 175
 176   MachMsgPortDescriptor *GetDescriptor(int n);
 177
 178   // Convenience method which gets the mach port described by the descriptor
 179   mach_port_t GetTranslatedPort(int n);
 180
 181   // A simple message is one with no descriptors
 182   bool IsSimpleMessage() const { return GetDescriptorCount() == 0; }
 183
 184   // Sets raw data for the message (returns false if not enough space)
 185   bool SetData(const void* data, int32_t data_length);
 186
 187  protected:
 188   // Consider this an abstract base class - must create an actual instance
 189   // of MachReceiveMessage or MachSendMessage
 190   MachMessage();
 191
 192   // Constructor for use with preallocate storage.
 193   // storage_length must be >= EmptyMessageSize()
 194   MachMessage(void *storage, size_t storage_length);
 195
 196   friend class ReceivePort;
 197   friend class MachPortSender;
 198
 199   // Represents raw data in our message
 200   struct MessageDataPacket {
 201     int32_t  id;          // little-endian
 202     int32_t  data_length; // little-endian
 203     u_int8_t data[1];     // actual size limited by storage_length_bytes_
 204   };
 205
 206   MessageDataPacket* GetDataPacket();
 207
 208   void SetDescriptorCount(int n);
 209   void SetDescriptor(int n, const MachMsgPortDescriptor &desc);
 210
 211   // Returns total message size setting msgh_size in the header to this value
 212   int CalculateSize();
 213
 214   // Returns total storage size that this object can grow to, this is inclusive
 215   // of the mach header.
 216   size_t MaxSize() const { return storage_length_bytes_; }
 217
 218  protected:
 219   mach_msg_header_t *Head() { return &(storage_->head); }
 220
 221  private:
 222   struct MachMessageData {
 223     mach_msg_header_t  head;
 224     mach_msg_body_t    body;
 225     // descriptors and data may be embedded here.
 226     u_int8_t           padding[1024];
 227   };
 228
 229  // kEmptyMessageSize needs to have the definition of MachMessageData before
 230  // it.
 231  public:
 232    // The size of an empty message with no data.
 233   static const size_t kEmptyMessageSize = sizeof(mach_msg_header_t) +
 234                                           sizeof(mach_msg_body_t) +
 235                                           sizeof(MessageDataPacket);
 236
 237  private:
 238   MachMessageData *storage_;
 239   size_t storage_length_bytes_;
 240   bool own_storage_;  // Is storage owned by this object?
 241 };
 242
 243 //==============================================================================
 244 // MachReceiveMessage and MachSendMessage are useful to separate the idea
 245 // of a mach message being sent and being received, and adds increased type
 246 // safety:
 247 //  ReceivePort::WaitForMessage() only accepts a MachReceiveMessage
 248 //  MachPortSender::SendMessage() only accepts a MachSendMessage
 249
 250 //==============================================================================
 251 class MachReceiveMessage : public MachMessage {
 252  public:
 253   MachReceiveMessage() : MachMessage() {}
 254   MachReceiveMessage(void *storage, size_t storage_length)
 255       : MachMessage(storage, storage_length) {}
 256
 257  private:
 258     DISALLOW_COPY_AND_ASSIGN(MachReceiveMessage);
 259 };
 260
 261 //==============================================================================
 262 class MachSendMessage : public MachMessage {
 263  public:
 264   explicit MachSendMessage(int32_t message_id);
 265   MachSendMessage(void *storage, size_t storage_length, int32_t message_id);
 266
 267  private:
 268   void Initialize(int32_t message_id);
 269
 270   DISALLOW_COPY_AND_ASSIGN(MachSendMessage);
 271 };
 272
 273 //==============================================================================
 274 // Represents a mach port for which we have receive rights
 275 class ReceivePort {
 276  public:
 277   // Creates a new mach port for receiving messages and registers a name for it
 278   explicit ReceivePort(const char *receive_port_name);
 279
 280   // Given an already existing mach port, use it.  We take ownership of the
 281   // port and deallocate it in our destructor.
 282   explicit ReceivePort(mach_port_t receive_port);
 283
 284   // Create a new mach port for receiving messages
 285   ReceivePort();
 286
 287   ~ReceivePort();
 288
 289   // Waits on the mach port until message received or timeout
 290   kern_return_t WaitForMessage(MachReceiveMessage *out_message,
 291                                mach_msg_timeout_t timeout);
 292
 293   // The underlying mach port that we wrap
 294   mach_port_t  GetPort() const { return port_; }
 295
 296  private:
 297   mach_port_t   port_;
 298   kern_return_t init_result_;
 299
 300   DISALLOW_COPY_AND_ASSIGN(ReceivePort);
 301 };
 302
 303 //==============================================================================
 304 // Represents a mach port for which we have send rights
 305 class MachPortSender {
 306  public:
 307   // get a port with send rights corresponding to a named registered service
 308   explicit MachPortSender(const char *receive_port_name);
 309
 310
 311   // Given an already existing mach port, use it. Does not take ownership of
 312   // |send_port|.
 313   explicit MachPortSender(mach_port_t send_port);
 314
 315   kern_return_t SendMessage(MachSendMessage &message,
 316                             mach_msg_timeout_t timeout);
 317
 318  private:
 319   mach_port_t   send_port_;
 320   kern_return_t init_result_;
 321
 322   DISALLOW_COPY_AND_ASSIGN(MachPortSender);
 323 };
 324
 325 }  // namespace base
 326
 327 #endif // BASE_MACH_IPC_MAC_H_