Fix for issue 21398 (only send "literal like" objects across isolates spawned using spawnURI

runtime/vm/isolate.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
@@ skipping 34 matching lines @@
             "Pause isolates exiting.");
 DEFINE_FLAG(bool, break_at_isolate_spawn, false,
             "Insert a one-time breakpoint at the entrypoint for all spawned "
             "isolates");
 
 
 // Quick access to the locally defined isolate() method.
 #define I (isolate())
 
 
+#if defined(DEBUG)
+// Helper class to ensure that a live origin_id is never reused
+// and assigned to an isolate.
+class VerifyOriginId : public IsolateVisitor {
+ public:
+  explicit VerifyOriginId(Dart_Port id) : id_(id) {}
+
+  void VisitIsolate(Isolate* isolate) {
+    ASSERT(isolate->origin_id() != id_);
+  }
+
+ private:
+  Dart_Port id_;
+  DISALLOW_COPY_AND_ASSIGN(VerifyOriginId);
+};
+#endif
+
+
 static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
 static void SerializeObject(const Instance& obj,
                             uint8_t** obj_data,
-                            intptr_t* obj_len) {
-  MessageWriter writer(obj_data, &allocator);
+                            intptr_t* obj_len,
+                            bool allow_any_object) {
+  MessageWriter writer(obj_data, &allocator, allow_any_object);
   writer.WriteMessage(obj);
   *obj_len = writer.BytesWritten();
 }
 
 
 void Isolate::RegisterClass(const Class& cls) {
   class_table()->Register(cls);
 }
 
 
@@ skipping 99 matching lines @@
       if (message.Length() != 4) return true;
       const Object& obj2 = Object::Handle(I, message.At(2));
       if (!obj2.IsSendPort()) return true;
       const SendPort& send_port = SendPort::Cast(obj2);
       const Object& obj3 = Object::Handle(I, message.At(3));
       if (!obj3.IsSmi()) return true;
       const intptr_t priority = Smi::Cast(obj3).Value();
       if (priority == kImmediateAction) {
         uint8_t* data = NULL;
         intptr_t len = 0;
-        SerializeObject(Object::null_instance(), &data, &len);
+        SerializeObject(Object::null_instance(), &data, &len, false);
         PortMap::PostMessage(new Message(send_port.Id(),
                                          data, len,
                                          Message::kNormalPriority));
       } else {
         ASSERT((priority == kBeforeNextEventAction) ||
                (priority == kAsEventAction));
         // Update the message so that it will be handled immediately when it
         // is picked up from the message queue the next time.
         message.SetAt(
             0, Smi::Handle(I, Smi::New(Message::kDelayedIsolateLibOOBMsg)));
         message.SetAt(3, Smi::Handle(I, Smi::New(kImmediateAction)));
         uint8_t* data = NULL;
         intptr_t len = 0;
-        SerializeObject(message, &data, &len);
+        SerializeObject(message, &data, &len, false);
         this->PostMessage(new Message(Message::kIllegalPort,
                                       data, len,
                                       Message::kNormalPriority),
                           priority == kBeforeNextEventAction /* at_head */);
       }
       break;
     }
     case kKillMsg: {
       // [ OOB, kKillMsg, terminate capability, priority ]
       if (message.Length() != 4) return true;
       Object& obj = Object::Handle(I, message.At(3));
       if (!obj.IsSmi()) return true;
       const intptr_t priority = Smi::Cast(obj).Value();
       if (priority == kImmediateAction) {
         obj = message.At(2);
         // Signal that the isolate should stop execution.
         return !I->VerifyTerminateCapability(obj);
       } else {
         ASSERT((priority == kBeforeNextEventAction) ||
                (priority == kAsEventAction));
         // Update the message so that it will be handled immediately when it
         // is picked up from the message queue the next time.
         message.SetAt(
             0, Smi::Handle(I, Smi::New(Message::kDelayedIsolateLibOOBMsg)));
         message.SetAt(3, Smi::Handle(I, Smi::New(kImmediateAction)));
         uint8_t* data = NULL;
         intptr_t len = 0;
-        SerializeObject(message, &data, &len);
+        SerializeObject(message, &data, &len, false);
         this->PostMessage(new Message(Message::kIllegalPort,
                                       data, len,
                                       Message::kNormalPriority),
                           priority == kBeforeNextEventAction /* at_head */);
       }
       break;
     }
 #if defined(DEBUG)
     // Malformed OOB messages are silently ignored in release builds.
     default:
@@ skipping 254 matching lines @@
 
 #define REUSABLE_HANDLE_INITIALIZERS(object)                                   \
   object##_handle_(NULL),
 
 Isolate::Isolate()
     : store_buffer_(),
       message_notify_callback_(NULL),
       name_(NULL),
       start_time_(OS::GetCurrentTimeMicros()),
       main_port_(0),
+      origin_id_(0),
       pause_capability_(0),
       terminate_capability_(0),
       heap_(NULL),
       object_store_(NULL),
       top_exit_frame_info_(0),
       init_callback_data_(NULL),
       environment_callback_(NULL),
       library_tag_handler_(NULL),
       api_state_(NULL),
       stub_code_(NULL),
@@ skipping 190 matching lines @@
   ApiState* state = new ApiState();
   ASSERT(state != NULL);
   result->set_api_state(state);
 
   // Initialize stack top and limit in case we are running the isolate in the
   // main thread.
   // TODO(5411455): Need to figure out how to set the stack limit for the
   // main thread.
   result->SetStackLimitFromStackBase(reinterpret_cast<uword>(&result));
   result->set_main_port(PortMap::CreatePort(result->message_handler()));
+#if defined(DEBUG)
+  // Verify that we are never reusing a live origin id.
+  VerifyOriginId id_verifier(result->main_port());
+  Isolate::VisitIsolates(&id_verifier);
+#endif
+  result->set_origin_id(result->main_port());
   result->set_pause_capability(result->random()->NextUInt64());
   result->set_terminate_capability(result->random()->NextUInt64());
 
   result->BuildName(name_prefix);
 
   result->debugger_ = new Debugger();
   result->debugger_->Initialize(result);
   if (FLAG_trace_isolates) {
     if (name_prefix == NULL || strcmp(name_prefix, "vm-isolate") != 0) {
       OS::Print("[+] Starting isolate:\n"
@@ skipping 842 matching lines @@
   const String& lib_url = String::Handle(lib.url());
   library_url_ = strdup(lib_url.ToCString());
 
   const String& func_name = String::Handle(func.name());
   function_name_ = strdup(func_name.ToCString());
   if (!cls.IsTopLevel()) {
     const String& class_name = String::Handle(cls.Name());
     class_name_ = strdup(class_name.ToCString());
   }
   exception_callback_name_ = strdup("_unhandledExceptionCallback");
-  SerializeObject(message, &serialized_message_, &serialized_message_len_);
+  bool can_send_any_object = true;
+  SerializeObject(message,
+                  &serialized_message_,
+                  &serialized_message_len_,
+                  can_send_any_object);
 }
 
 
 IsolateSpawnState::IsolateSpawnState(Dart_Port parent_port,
                                      const char* script_url,
                                      const char* package_root,
                                      const Instance& args,
                                      const Instance& message,
                                      bool paused)
     : isolate_(NULL),
       parent_port_(parent_port),
       package_root_(NULL),
       library_url_(NULL),
       class_name_(NULL),
       function_name_(NULL),
       exception_callback_name_(NULL),
       serialized_args_(NULL),
       serialized_args_len_(0),
       serialized_message_(NULL),
       serialized_message_len_(0),
       paused_(paused) {
   script_url_ = strdup(script_url);
   if (package_root != NULL) {
     package_root_ = strdup(package_root);
   }
   library_url_ = NULL;
   function_name_ = strdup("main");
   exception_callback_name_ = strdup("_unhandledExceptionCallback");
-  SerializeObject(args, &serialized_args_, &serialized_args_len_);
-  SerializeObject(message, &serialized_message_, &serialized_message_len_);
+  bool can_send_any_object = false;
+  SerializeObject(args,
+                  &serialized_args_,
+                  &serialized_args_len_,
+                  can_send_any_object);
+  SerializeObject(message,
+                  &serialized_message_,
+                  &serialized_message_len_,
+                  can_send_any_object);
 }
 
 
 IsolateSpawnState::~IsolateSpawnState() {
   free(script_url_);
   free(package_root_);
   free(library_url_);
   free(function_name_);
   free(class_name_);
   free(exception_callback_name_);
@@ skipping 65 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart