[mojo-edk] Serialise windows handles into an "extra header" section.

mojo/edk/system/channel.h

 // 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.
 
 #ifndef MOJO_EDK_SYSTEM_CHANNEL_H_
 #define MOJO_EDK_SYSTEM_CHANNEL_H_
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 11 matching lines @@
 // delimited messages over an underlying I/O channel, optionally transferring
 // one or more platform handles in the process.
 class Channel : public base::RefCountedThreadSafe<Channel> {
  public:
   struct Message;
 
   using MessagePtr = scoped_ptr<Message>;
 
   // A message to be written to a channel.
   struct Message {
+#pragma pack(push, 1)
     struct Header {
       enum class MessageType : uint16_t {
         // A normal message.
         NORMAL = 0,
 #if defined(OS_MACOSX)
         // A control message containing handles to echo back.
         HANDLES_SENT,
         // A control message containing handles that can now be closed.
         HANDLES_SENT_ACK,
 #endif
       };
 
       // Message size in bytes, including the header.
       uint32_t num_bytes;
 
-      // Number of attached handles.
+      // Total size of header, including extra header data (i.e. HANDLEs on
+      // windows).
+      uint16_t num_header_bytes;
+
+      // Number of attached handles. May be less than the reserved handle
+      // storage size in this message on platforms that serialise handles as
+      // data (i.e. HANDLEs on Windows, Mach ports on OSX).
       uint16_t num_handles;
 
       MessageType message_type;
+
+      char padding[6];
     };
+#pragma pack(pop)
 
     // Allocates and owns a buffer for message data with enough capacity for
-    // |payload_size| bytes plus a header. Takes ownership of |handles|, which
-    // may be null.
+    // |payload_size| bytes plus a header, plus |max_handles| platform handles.
     Message(size_t payload_size,
-            size_t num_handles,
+            size_t max_handles,
             Header::MessageType message_type = Header::MessageType::NORMAL);
 
     ~Message();
 
     // Constructs a Message from serialized message data.
     static MessagePtr Deserialize(const void* data, size_t data_num_bytes);
 
     const void* data() const { return data_; }
     size_t data_num_bytes() const { return size_; }
 
-    void* mutable_payload() { return static_cast<void*>(header_ + 1); }
-    const void* payload() const {
-      return static_cast<const void*>(header_ + 1);
+    const void* extra_header() const { return data_ + sizeof(Header); }
+    void* mutable_extra_header() { return data_ + sizeof(Header); }
+    size_t extra_header_size() const {
+      return header_->num_header_bytes - sizeof(Header);
     }
+
+    void* mutable_payload() { return data_ + header_->num_header_bytes; }
+    const void* payload() const { return data_ + header_->num_header_bytes; }
     size_t payload_size() const;
 
     size_t num_handles() const { return header_->num_handles; }
     bool has_handles() const { return header_->num_handles > 0; }
     PlatformHandle* handles();
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+    bool has_mach_ports() const;
+#endif
 
     // Note: SetHandles() and TakeHandles() invalidate any previous value of
     // handles().
     void SetHandles(ScopedPlatformHandleVectorPtr new_handles);
     ScopedPlatformHandleVectorPtr TakeHandles();
 
 #if defined(OS_WIN)
     // Prepares the handles in this message for use in a different process.
     // Upon calling this the handles should belong to |from_process|; after the
     // call they'll belong to |to_process|. The source handles are always
     // closed by this call. Returns false iff one or more handles failed
     // duplication.
     static bool RewriteHandles(base::ProcessHandle from_process,
                                base::ProcessHandle to_process,
                                PlatformHandle* handles,
                                size_t num_handles);
 #endif
 
    private:
     size_t size_;
+    size_t max_handles_;
     char* data_;
     Header* header_;
 
 #if defined(OS_WIN)
     // On Windows, handles are serialized in the data buffer along with the
     // rest of the payload.
     PlatformHandle* handles_ = nullptr;
 #else
     ScopedPlatformHandleVectorPtr handle_vector_;
 #endif
@@ skipping 61 matching lines @@
   // Called by the implementation when new data is available in the read
   // buffer. Returns false to indicate an error. Upon success,
   // |*next_read_size_hint| will be set to a recommended size for the next
   // read done by the implementation.
   bool OnReadComplete(size_t bytes_read, size_t* next_read_size_hint);
 
   // Called by the implementation when something goes horribly wrong. It is NOT
   // OK to call this synchronously from any public interface methods.
   void OnError();
 
-  // Retrieves the set of platform handles read for a given message. |payload|
-  // and |payload_size| correspond to the full message body. Depending on
-  // the Channel implementation, this body may encode platform handles, or
-  // handles may be stored and managed elsewhere by the implementation.
-  // If |num_handles| handles cannot be returned, this must return null.
-  // The implementation may also adjust the values of |*payload| and/or
-  // |*payload_size| to hide handle data from the user.
+  // Retrieves the set of platform handles read for a given message.
+  // |extra_header| and |extra_header_size| correspond to the extra header data.
+  // Depending on the Channel implementation, this body may encode platform
+  // handles, or handles may be stored and managed elsewhere by the
+  // implementation.  If |num_handles| handles cannot be returned, this must
+  // return null.
   virtual ScopedPlatformHandleVectorPtr GetReadPlatformHandles(
       size_t num_handles,
-      void** payload,
-      size_t* payload_size) = 0;
+      const void* extra_header,
+      size_t extra_header_size) = 0;
 
   virtual void OnControlMessage(Message::Header::MessageType message_type,
                                 const void* payload,
                                 size_t payload_size,
                                 ScopedPlatformHandleVectorPtr handles) {}
 
  private:
   friend class base::RefCountedThreadSafe<Channel>;
 
   class ReadBuffer;
 
   Delegate* delegate_;
   const scoped_ptr<ReadBuffer> read_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(Channel);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_CHANNEL_H_