- Implement Isolate.ping.

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())
 
 
+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);
+  writer.WriteMessage(obj);
+  *obj_len = writer.BytesWritten();
+}
+
+
 void Isolate::RegisterClass(const Class& cls) {
   class_table()->Register(cls);
 }
 
 
 void Isolate::RegisterClassAt(intptr_t index, const Class& cls) {
   class_table()->RegisterAt(index, cls);
 }
 
 
@@ skipping 17 matching lines @@
 #endif
   bool IsCurrentIsolate() const;
   virtual Isolate* isolate() const { return isolate_; }
   bool UnhandledExceptionCallbackHandler(const Object& message,
                                          const UnhandledException& error);
 
  private:
   // Keep in sync with isolate_patch.dart.
   enum {
     kPauseMsg = 1,
-    kResumeMsg
+    kResumeMsg = 2,
+    kPingMsg = 3,
+
+    kImmediateAction = 0,
+    kBeforeNextEventAction = 1,
+    kAsEventAction = 2
   };
 
   void HandleLibMessage(const Array& message);
   bool ProcessUnhandledException(const Object& message, const Error& result);
   RawFunction* ResolveCallbackFunction();
   Isolate* isolate_;
 };
 
 
 IsolateMessageHandler::IsolateMessageHandler(Isolate* isolate)
@@ skipping 37 matching lines @@
       Object& obj = Object::Handle(I, message.At(2));
       if (!obj.IsCapability()) return;
       if (!I->VerifyPauseCapability(Capability::Cast(obj))) return;
       obj = message.At(3);
       if (!obj.IsCapability()) return;
       if (I->RemoveResumeCapability(Capability::Cast(obj))) {
         decrement_paused();
       }
       break;
     }
+    case kPingMsg: {
+      // [ OOB, kPingMsg, responsePort, pingType ]
+      if (message.Length() != 4) return;
+      const Object& obj2 = Object::Handle(I, message.At(2));
+      if (!obj2.IsSendPort()) return;
+      const SendPort& send_port = SendPort::Cast(obj2);
+      const Object& obj3 = Object::Handle(I, message.At(3));
+      if (!obj3.IsSmi()) return;
+      const Smi& ping_type = Smi::Cast(obj3);

[siva, 2014/12/01 19:48:05]

why not
intptr_t ping_value = Smi::Cast(obj3).Value();

and use ping_value in the if .. else statements.
if (ping_value == kImmediateAction) { etc.

[Ivan Posva, 2014/12/12 20:21:46]

Done.

+      if (ping_type.Value() == kImmediateAction) {
+        uint8_t* data = NULL;
+        intptr_t len = 0;
+        SerializeObject(Object::null_instance(), &data, &len);
+        PortMap::PostMessage(new Message(send_port.Id(),
+                                         data, len,
+                                         Message::kNormalPriority));

[siva, 2014/12/01 19:48:05]

How does the spec resolve a potential Denial of Service attack if repeated PING
messages with kImmediateAction setting are sent.

[Ivan Posva, 2014/12/12 20:21:46]

If you control the isolate, then you can do other kinds of Denial of Service,
such as terminating it.

+      } else if (ping_type.Value() == kBeforeNextEventAction) {
+        // 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);
+        this->PostMessage(new Message(Message::kIllegalPort,
+                                      data, len,
+                                      Message::kNormalPriority),
+                          true /* at_head */);
+      } else if (ping_type.Value() == 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);
+        this->PostMessage(new Message(Message::kIllegalPort,
+                                      data, len,
+                                      Message::kNormalPriority));
+      }
+      break;
+    }
 #if defined(DEBUG)
     // Malformed OOB messages are silently ignored in release builds.
     default:
       UNREACHABLE();
       break;
 #endif  // defined(DEBUG)
   }
 }
 
 
@@ skipping 13 matching lines @@
 bool IsolateMessageHandler::HandleMessage(Message* message) {
   StartIsolateScope start_scope(I);
   StackZone zone(I);
   HandleScope handle_scope(I);
   // TODO(turnidge): Rework collection total dart execution.  This can
   // overcount when other things (gc, compilation) are active.
   TIMERSCOPE(isolate_, time_dart_execution);
 
   // If the message is in band we lookup the handler to dispatch to.  If the
   // receive port was closed, we drop the message without deserializing it.
+  // Illegal port is a special case for artificially enqueued isolate library
+  // messages which are handled in C++ code below.
   Object& msg_handler = Object::Handle(I);
-  if (!message->IsOOB()) {
+  if (!message->IsOOB() && (message->dest_port() != Message::kIllegalPort)) {
     msg_handler = DartLibraryCalls::LookupHandler(message->dest_port());
     if (msg_handler.IsError()) {
       delete message;
       return ProcessUnhandledException(Object::null_instance(),
                                        Error::Cast(msg_handler));
     }
     if (msg_handler.IsNull()) {
       // If the port has been closed then the message will be dropped at this
       // point. Make sure to post to the delivery failure port in that case.
       if (message->RedirectToDeliveryFailurePort()) {
@@ skipping 49 matching lines @@
             // Malformed OOB messages are silently ignored in release builds.
             default: {
               UNREACHABLE();
               break;
             }
 #endif  // defined(DEBUG)
           }
         }
       }
     }
+  } else if (message->dest_port() == Message::kIllegalPort) {
+    // Check whether this is a delayed OOB message which needed handling as
+    // part of the regular message dispatch. All other messages are dropped on
+    // the floor.
+    if (msg.IsArray()) {
+      const Array& msg_arr = Array::Cast(msg);
+      if (msg_arr.Length() > 0) {
+        const Object& oob_tag = Object::Handle(I, msg_arr.At(0));
+        if (oob_tag.IsSmi() &&
+            (Smi::Cast(oob_tag).Value() == Message::kDelayedIsolateLibOOBMsg)) {
+          HandleLibMessage(Array::Cast(msg_arr));
+        }
+      }
+    }
   } else {
     const Object& result = Object::Handle(I,
         DartLibraryCalls::HandleMessage(msg_handler, msg));
     if (result.IsError()) {
       success = ProcessUnhandledException(msg, Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
     }
   }
   delete message;
@@ skipping 1138 matching lines @@
 
 
 template<class T>
 T* Isolate::AllocateReusableHandle() {
   T* handle = reinterpret_cast<T*>(reusable_handles_.AllocateScopedHandle());
   T::initializeHandle(handle, T::null());
   return handle;
 }
 
 
-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);
-  writer.WriteMessage(obj);
-  *obj_len = writer.BytesWritten();
-}
-
-
 static RawInstance* DeserializeObject(Isolate* isolate,
                                       uint8_t* obj_data,
                                       intptr_t obj_len) {
   if (obj_data == NULL) {
     return Instance::null();
   }
   SnapshotReader reader(obj_data, obj_len, Snapshot::kMessage, isolate);
   const Object& obj = Object::Handle(isolate, reader.ReadObject());
   ASSERT(!obj.IsError());
   Instance& instance = Instance::Handle(isolate);
@@ skipping 137 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart