[mojo-edk] Add support for transferring mach ports.

mojo/edk/system/channel.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "mojo/edk/system/channel.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
+#include <utility>
 
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "mojo/edk/embedder/platform_handle.h"
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+#include "base/mac/mach_logging.h"
+#endif
+
 namespace mojo {
 namespace edk {
 
 namespace {
 
 static_assert(sizeof(Channel::Message::Header) % kChannelMessageAlignment == 0,
     "Invalid Header size.");
 
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
 static_assert(sizeof(Channel::Message::Header) == 8,
@@ skipping 10 matching lines @@
 Channel::Message::Message(size_t payload_size,
                           size_t max_handles,
                           Header::MessageType message_type)
     : max_handles_(max_handles) {
   DCHECK_LE(max_handles_, kMaxAttachedHandles);
 
   size_t extra_header_size = 0;
 #if defined(OS_WIN)
   // On Windows we serialize platform handles into the extra header space.
   extra_header_size = max_handles_ * sizeof(PlatformHandle);
+#elif defined(OS_MACOSX) && !defined(OS_IOS)
+  // On OSX, some of the platform handles may be mach ports, which are
+  // serialised into the message buffer. Since there could be a mix of fds and
+  // mach ports, we store the mach ports as an <index, port> pair (of uint32_t),
+  // so that the original ordering of handles can be re-created.
+  extra_header_size = max_handles * sizeof(MachPortsEntry);
 #endif
   // Pad extra header data to be aliged to |kChannelMessageAlignment| bytes.
   if (extra_header_size % kChannelMessageAlignment) {
     extra_header_size += kChannelMessageAlignment -
                          (extra_header_size % kChannelMessageAlignment);
   }
   DCHECK_EQ(0u, extra_header_size % kChannelMessageAlignment);
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
   DCHECK_EQ(0u, extra_header_size);
 #endif
@@ skipping 15 matching lines @@
   DCHECK_LE(sizeof(Header) + extra_header_size,
             std::numeric_limits<uint16_t>::max());
   header_->message_type = message_type;
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
   header_->num_handles = static_cast<uint16_t>(max_handles);
 #else
   header_->num_header_bytes =
       static_cast<uint16_t>(sizeof(Header) + extra_header_size);
 #endif
 
+  if (max_handles_ > 0) {
 #if defined(OS_WIN)
-  if (max_handles_ > 0) {
     handles_ = reinterpret_cast<PlatformHandle*>(mutable_extra_header());
     // Initialize all handles to invalid values.
     for (size_t i = 0; i < max_handles_; ++i)
       handles()[i] = PlatformHandle();
+#elif defined(OS_MACOSX) && !defined(OS_IOS)
+    mach_ports_ = reinterpret_cast<MachPortsEntry*>(mutable_extra_header());
+    // Initialize all handles to invalid values.
+    for (size_t i = 0; i < max_handles_; ++i)
+      mach_ports_[i] = {0, static_cast<uint32_t>(MACH_PORT_NULL)};
+#endif
   }
-#endif
 }
 
 Channel::Message::~Message() {
 #if defined(OS_WIN)
   // On POSIX the ScopedPlatformHandleVectorPtr will do this for us.
   for (size_t i = 0; i < header_->num_handles; ++i)
     handles()[i].CloseIfNecessary();
 #endif
   base::AlignedFree(data_);
 }
 
 // static
 Channel::MessagePtr Channel::Message::Deserialize(const void* data,
                                                   size_t data_num_bytes) {
-#if !defined(OS_WIN)
+#if !defined(OS_WIN) && !(defined(OS_MACOSX) && !defined(OS_IOS))
   // We only serialize messages into other messages when performing message
-  // relay on Windows.
+  // relay on Windows and OSX.
   NOTREACHED();
   return nullptr;
 #else
   if (data_num_bytes < sizeof(Header))
     return nullptr;
 
   const Header* header = reinterpret_cast<const Header*>(data);
   if (header->num_bytes != data_num_bytes) {
     DLOG(ERROR) << "Decoding invalid message: " << header->num_bytes
                 << " != " << data_num_bytes;
     return nullptr;
   }
 
   if (header->num_bytes < header->num_header_bytes) {
     DLOG(ERROR) << "Decoding invalid message: " << header->num_bytes << " < "
                 << header->num_header_bytes;
     return nullptr;
   }
 
   uint32_t extra_header_size = header->num_header_bytes - sizeof(Header);
+#if defined(OS_WIN)
   uint32_t max_handles = extra_header_size / sizeof(PlatformHandle);
+#elif defined(OS_MACOSX) && !defined(OS_IOS)
+  uint32_t max_handles = extra_header_size / sizeof(MachPortsEntry);
+#endif
   if (header->num_handles > max_handles) {
-    DLOG(ERROR) << "Decoding invalid message:" << header->num_handles << " > "
-                << max_handles;
+    DLOG(ERROR) << "Decoding invalid message:" << header->num_handles
+                << " > " << max_handles;
     return nullptr;
   }
 
-  MessagePtr message(
-      new Message(data_num_bytes - header->num_header_bytes, max_handles));
-
+  MessagePtr message(new Message(data_num_bytes - header->num_header_bytes,
+                                 max_handles));
   DCHECK_EQ(message->data_num_bytes(), data_num_bytes);
   DCHECK_EQ(message->extra_header_size(), extra_header_size);
   DCHECK_EQ(message->header_->num_header_bytes, header->num_header_bytes);
 
   // Copy all payload bytes.
   memcpy(message->mutable_payload(),
          static_cast<const char*>(data) + header->num_header_bytes,
          data_num_bytes - header->num_header_bytes);
   // Copy extra header bytes.
   memcpy(message->mutable_extra_header(),
@@ skipping 31 matching lines @@
 #endif  // defined(OS_WIN)
 #endif  // defined(OS_CHROMEOS) || defined(OS_ANDROID)
 }
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 bool Channel::Message::has_mach_ports() const {
   if (!has_handles())
     return false;
 
   for (const auto& handle : (*handle_vector_)) {
-    if (handle.type == PlatformHandle::Type::MACH)
+    if (handle.type == PlatformHandle::Type::MACH ||
+        handle.type == PlatformHandle::Type::MACH_NAME) {
       return true;
+    }
   }
   return false;
 }
 #endif
 
 void Channel::Message::SetHandles(ScopedPlatformHandleVectorPtr new_handles) {
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
   // Old semantics for ChromeOS and Android
   if (header_->num_handles == 0) {
     CHECK(!new_handles || new_handles->size() == 0);
@@ skipping 11 matching lines @@
   CHECK(new_handles && new_handles->size() <= max_handles_);
   header_->num_handles = static_cast<uint16_t>(new_handles->size());
 #if defined(OS_WIN)
   memcpy(handles(), new_handles->data(),
          sizeof(PlatformHandle) * new_handles->size());
   new_handles->clear();
 #else
   std::swap(handle_vector_, new_handles);
 #endif  // defined(OS_WIN)
 #endif  // defined(OS_CHROMEOS) || defined(OS_ANDROID)
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  size_t mach_port_index = 0;
+  for (size_t i = 0; i < max_handles_; ++i)
+    mach_ports_[i] = {0, static_cast<uint32_t>(MACH_PORT_NULL)};
+  for (size_t i = 0; i < handle_vector_->size(); i++) {
+    if ((*handle_vector_)[i].type == PlatformHandle::Type::MACH ||
+        (*handle_vector_)[i].type == PlatformHandle::Type::MACH_NAME) {
+      mach_port_t port = (*handle_vector_)[i].port;
+      mach_ports_[mach_port_index].index = i;
+      mach_ports_[mach_port_index].mach_port = port;
+      mach_port_index++;
+    }
+  }
+#endif
 }
 
 ScopedPlatformHandleVectorPtr Channel::Message::TakeHandles() {
 #if defined(OS_WIN)
   if (header_->num_handles == 0)
     return ScopedPlatformHandleVectorPtr();
   ScopedPlatformHandleVectorPtr moved_handles(
       new PlatformHandleVector(header_->num_handles));
   for (size_t i = 0; i < header_->num_handles; ++i)
     std::swap(moved_handles->at(i), handles()[i]);
+  header_->num_handles = 0;
   return moved_handles;
+#elif defined(OS_MACOSX) && !defined(OS_IOS)
+  for (size_t i = 0; i < max_handles_; ++i)
+    mach_ports_[i] = {0, static_cast<uint32_t>(MACH_PORT_NULL)};
+  header_->num_handles = 0;
+  return std::move(handle_vector_);
+#else
+  header_->num_handles = 0;
+  return std::move(handle_vector_);
+#endif
+}
+
+ScopedPlatformHandleVectorPtr Channel::Message::TakeHandlesForTransport() {
+#if defined(OS_WIN)
+  // Not necessary on Windows.
+  NOTREACHED();
+  return nullptr;
+#elif defined(OS_MACOSX) && !defined(OS_IOS)
+  if (handle_vector_) {
+    for (auto it = handle_vector_->begin(); it != handle_vector_->end(); ) {
+      if (it->type == PlatformHandle::Type::MACH ||
+          it->type == PlatformHandle::Type::MACH_NAME) {
+        // For Mach port names, we can can just leak them. They're not real
+        // ports anyways. For real ports, they're leaked because this is a child
+        // process and the remote process will take ownership.
+        it = handle_vector_->erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+  return std::move(handle_vector_);
 #else
   return std::move(handle_vector_);
 #endif
 }
 
 #if defined(OS_WIN)
 // static
 bool Channel::Message::RewriteHandles(base::ProcessHandle from_process,
                                       base::ProcessHandle to_process,
                                       PlatformHandle* handles,
@@ skipping 206 matching lines @@
   return true;
 }
 
 void Channel::OnError() {
   if (delegate_)
     delegate_->OnChannelError();
 }
 
 }  // namespace edk
 }  // namespace mojo