[mojo-edk] Broadcast surprise port disruptions

mojo/edk/system/node_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/node_channel.h"
 
 #include <cstring>
 #include <limits>
 #include <sstream>
 
@@ skipping 21 matching lines @@
 enum class MessageType : uint32_t {
   ACCEPT_CHILD,
   ACCEPT_PARENT,
   ADD_BROKER_CLIENT,
   BROKER_CLIENT_ADDED,
   ACCEPT_BROKER_CLIENT,
   PORTS_MESSAGE,
   REQUEST_PORT_MERGE,
   REQUEST_INTRODUCTION,
   INTRODUCE,
+  BROADCAST,
 #if defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
   RELAY_PORTS_MESSAGE,
 #endif
 };
 
 struct Header {
   MessageType type;
   uint32_t padding;
 };
 
@@ skipping 270 matching lines @@
   ScopedPlatformHandleVectorPtr handles(new PlatformHandleVector());
   if (channel_handle.is_valid())
     handles->push_back(channel_handle.release());
   Channel::MessagePtr message = CreateMessage(
       MessageType::INTRODUCE, sizeof(IntroductionData), handles->size(), &data);
   message->SetHandles(std::move(handles));
   data->name = name;
   WriteChannelMessage(std::move(message));
 }
 
+void NodeChannel::Broadcast(Channel::MessagePtr message) {
+  DCHECK(!message->has_handles());
+  void* data;
+  Channel::MessagePtr broadcast_message = CreateMessage(
+      MessageType::BROADCAST, message->data_num_bytes(), 0, &data);
+  memcpy(data, message->data(), message->data_num_bytes());
+  WriteChannelMessage(std::move(broadcast_message));
+}
+
 #if defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
 void NodeChannel::RelayPortsMessage(const ports::NodeName& destination,
                                     Channel::MessagePtr message) {
 #if defined(OS_WIN)
   DCHECK(message->has_handles());
 
   // Note that this is only used on Windows, and on Windows all platform
   // handles are included in the message data. We blindly copy all the data
   // here and the relay node (the parent) will duplicate handles as needed.
   size_t num_bytes = sizeof(RelayPortsMessageData) + message->data_num_bytes();
@@ skipping 225 matching lines @@
           channel_handle = ScopedPlatformHandle(handles->at(0));
           handles->clear();
         }
         delegate_->OnIntroduce(remote_node_name_, data->name,
                                std::move(channel_handle));
         return;
       }
       break;
     }
 
+    case MessageType::BROADCAST: {
+      if (payload_size <= sizeof(Header))
+        break;
+      const void* data = static_cast<const void*>(
+          reinterpret_cast<const Header*>(payload) + 1);
+      Channel::MessagePtr message =
+          Channel::Message::Deserialize(data, payload_size - sizeof(Header));
+      if (!message) {
+        DLOG(ERROR) << "Dropping invalid broadcast message.";
+        break;
+      }
+      delegate_->OnBroadcast(std::move(message));
+      return;
+    }
+
 #if defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
     case MessageType::RELAY_PORTS_MESSAGE: {
       base::ProcessHandle from_process;
       {
         base::AutoLock lock(remote_process_handle_lock_);
         from_process = remote_process_handle_;
       }
       const RelayPortsMessageData* data;
       if (GetMessagePayload(payload, payload_size, &data)) {
         // Don't try to relay an empty message.
@@ skipping 167 matching lines @@
 
   base::AutoLock lock(channel_lock_);
   if (!channel_)
     DLOG(ERROR) << "Dropping message on closed channel.";
   else
     channel_->Write(std::move(message));
 }
 
 }  // namespace edk
 }  // namespace mojo