[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 341 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 296 matching lines @@
         }
   #endif
         delegate_->OnRelayPortsMessage(remote_node_name_, from_process,
                                        data->destination, std::move(message));
         return;
       }
       break;
     }
 #endif
 
-    case MessageType::BROADCAST:
-      // This is here as a placeholder for now because nothing sends a BROADCAST
-      // message yet. This avoids breakage on version skew (namely for ARC) when
-      // we actually begin using the message.
-      DVLOG(1) << "Ignoring unhandled BROADCAST message.";
+    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 || message->has_handles()) {
+        DLOG(ERROR) << "Dropping invalid broadcast message.";
+        break;
+      }
+      delegate_->OnBroadcast(remote_node_name_, std::move(message));
       return;
+    }
 
 #if defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
     case MessageType::PORTS_MESSAGE_FROM_RELAY:
       const PortsMessageFromRelayData* data;
       if (GetMessagePayload(payload, payload_size, &data)) {
         size_t num_bytes = payload_size - sizeof(*data);
         if (num_bytes < sizeof(Header))
           break;
         num_bytes -= sizeof(Header);
 
@@ skipping 150 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