[mojo-edk] Support transferring null 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>
@@ skipping 35 matching lines @@
 
   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);
+  if (max_handles) {
+    extra_header_size =
+        sizeof(MachPortsExtraHeader) + (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 22 matching lines @@
       static_cast<uint16_t>(sizeof(Header) + extra_header_size);
 #endif
 
   if (max_handles_ > 0) {
 #if defined(OS_WIN)
     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());
+    mach_ports_header_ =
+        reinterpret_cast<MachPortsExtraHeader*>(mutable_extra_header());
+    mach_ports_header_->num_ports = 0;
     // 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)};
+    for (size_t i = 0; i < max_handles_; ++i) {
+      mach_ports_header_->entries[i] =
+          {0, static_cast<uint32_t>(MACH_PORT_NULL)};
+    }
 #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
@@ skipping 121 matching lines @@
   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++;
+  if (mach_ports_header_) {
+    for (size_t i = 0; i < max_handles_; ++i) {
+      mach_ports_header_->entries[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_header_->entries[mach_port_index].index = i;
+        mach_ports_header_->entries[mach_port_index].mach_port = port;
+        mach_port_index++;
+      }
+    }
+    mach_ports_header_->num_ports = static_cast<uint16_t>(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)};
+  if (mach_ports_header_) {
+    for (size_t i = 0; i < max_handles_; ++i) {
+      mach_ports_header_->entries[i] =
+          {0, static_cast<uint32_t>(MACH_PORT_NULL)};
+    }
+    mach_ports_header_->num_ports = 0;
+  }
   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)
@@ skipping 242 matching lines @@
   return true;
 }
 
 void Channel::OnError() {
   if (delegate_)
     delegate_->OnChannelError();
 }
 
 }  // namespace edk
 }  // namespace mojo